opt = -g
CXXFLAGS = -ansi -pedantic -Wall $(opt) -Isrc/3dengfx/src -MMD `sdl-config --cflags`
CFLAGS = -std=c89 -pedantic -Wall $(opt) -MMD `sdl-config --cflags`
-libs = src/3dengfx/lib3dengfx.a `sdl-config --libs` -lGL -lvorbisfile -ljpeg -lpng -lz
+libs = -Llibs src/3dengfx/lib3dengfx.a `sdl-config --libs` -lGL -lvorbis -logg \
+ -ljpeg -lpng -lz -l3ds
-$(bin): $(obj) 3dengfx
+$(bin): $(obj) 3dengfx libs
$(CXX) -o $@ $(obj) $(libs)
.PHONY: 3dengfx
clean:
$(RM) $(obj) $(bin)
-.PHONY: cleanall
-cleanall: clean 3dengfx-clean cleandep
+.PHONY: clean-all
+clean-all: clean 3dengfx-clean cleandep clean-libs
.PHONY: cleandep
cleandep:
$(RM) $(obj:.o=.d)
+
+.PHONY: libs
+libs:
+ $(MAKE) -C libs
+
+.PHONY: clean-libs
+clean-libs:
+ $(MAKE) -C libs clean
Contact info...
http://thelab.demoscene.gr - nuclear@siggraph.org
```
+
+Build instructions
+------------------
+If you acquired the source code from the git repo, it does not include the
+binary data files (images, 3D models, and music). Grab the data file archive
+from: http://nuclear.mutantstargoat.com/sw/demos/summerhack-data.tar.gz and
+extract it in the project root directory, so that you now have the `img`, `geom`
+and `music` subdirectories in the `data` directory.
+
+If you got the source code from a full release archive of the demo, the data
+files are already there. Of course the release archive also contains
+pre-compiled binaries for multiple platforms.
+
+### UNIX
+
+The only dependencies are SDL 1.2 and OpenGL. After installing them, just type
+`make` to build the demo. For example under Debian GNU/Linux:
+
+ sudo apt-get install libgl-dev libsdl1.2-dev
+ make
+
+While on FreeBSD:
+
+ sudo pkg install mesa-libs sdl
+ gmake
+
+### Windows
+
+TODO
+
+### MacOS X
+
+TODO
--- /dev/null
+.PHONY: all
+all: zlib libpng jpeglib lib3ds ogg vorbis
+
+.PHONY: clean
+clean: clean-zlib clean-libpng clean-jpeglib clean-lib3ds clean-ogg clean-vorbis
+
+.PHONY: zlib
+zlib:
+ $(MAKE) -C zlib
+
+.PHONY: clean-zlib
+clean-zlib:
+ $(MAKE) -C zlib clean
+
+
+.PHONY: libpng
+libpng:
+ $(MAKE) -C libpng
+
+.PHONY: clean-libpng
+clean-libpng:
+ $(MAKE) -C libpng clean
+
+
+.PHONY: jpeglib
+jpeglib:
+ $(MAKE) -C jpeglib
+
+.PHONY: clean-jpeglib
+clean-jpeglib:
+ $(MAKE) -C jpeglib clean
+
+
+.PHONY: lib3ds
+lib3ds:
+ $(MAKE) -C lib3ds
+
+.PHONY: clean-lib3ds
+clean-lib3ds:
+ $(MAKE) -C lib3ds clean
+
+
+.PHONY: ogg
+ogg:
+ $(MAKE) -C ogg
+
+.PHONY: clean-ogg
+clean-ogg:
+ $(MAKE) -C ogg clean
+
+
+.PHONY: vorbis
+vorbis:
+ $(MAKE) -C vorbis
+
+.PHONY: clean-vorbis
+clean-vorbis:
+ $(MAKE) -C vorbis clean
--- /dev/null
+obj = jcapimin.o jcapistd.o jccoefct.o jccolor.o jcdctmgr.o jchuff.o jcinit.o \
+ jcmainct.o jcmarker.o jcmaster.o jcomapi.o jcparam.o jcphuff.o jcprepct.o \
+ jcsample.o jctrans.o jdapimin.o jdapistd.o jdatadst.o jdatasrc.o \
+ jdcoefct.o jdcolor.o jddctmgr.o jdhuff.o jdinput.o jdmainct.o jdmarker.o \
+ jdmaster.o jdmerge.o jdphuff.o jdpostct.o jdsample.o jdtrans.o jerror.o \
+ jfdctflt.o jfdctfst.o jfdctint.o jidctflt.o jidctfst.o jidctint.o \
+ jidctred.o jmemmgr.o jmemnobs.o jquant1.o jquant2.o jutils.o
+
+liba = ../libjpeg.a
+
+CFLAGS = -O3
+
+$(liba): $(obj)
+ $(AR) rcs $@ $(obj)
+
+.PHONY: clean
+clean:
+ rm -f $(obj) $(liba)
--- /dev/null
+The Independent JPEG Group's JPEG software
+==========================================
+
+README for release 8c of 16-Jan-2011
+====================================
+
+This distribution contains the eighth public release of the Independent JPEG
+Group's free JPEG software. You are welcome to redistribute this software and
+to use it for any purpose, subject to the conditions under LEGAL ISSUES, below.
+
+This software is the work of Tom Lane, Guido Vollbeding, Philip Gladstone,
+Bill Allombert, Jim Boucher, Lee Crocker, Bob Friesenhahn, Ben Jackson,
+Julian Minguillon, Luis Ortiz, George Phillips, Davide Rossi, Ge' Weijers,
+and other members of the Independent JPEG Group.
+
+IJG is not affiliated with the official ISO JPEG standards committee.
+
+
+DOCUMENTATION ROADMAP
+=====================
+
+This file contains the following sections:
+
+OVERVIEW General description of JPEG and the IJG software.
+LEGAL ISSUES Copyright, lack of warranty, terms of distribution.
+REFERENCES Where to learn more about JPEG.
+ARCHIVE LOCATIONS Where to find newer versions of this software.
+ACKNOWLEDGMENTS Special thanks.
+FILE FORMAT WARS Software *not* to get.
+TO DO Plans for future IJG releases.
+
+Other documentation files in the distribution are:
+
+User documentation:
+ install.txt How to configure and install the IJG software.
+ usage.txt Usage instructions for cjpeg, djpeg, jpegtran,
+ rdjpgcom, and wrjpgcom.
+ *.1 Unix-style man pages for programs (same info as usage.txt).
+ wizard.txt Advanced usage instructions for JPEG wizards only.
+ change.log Version-to-version change highlights.
+Programmer and internal documentation:
+ libjpeg.txt How to use the JPEG library in your own programs.
+ example.c Sample code for calling the JPEG library.
+ structure.txt Overview of the JPEG library's internal structure.
+ filelist.txt Road map of IJG files.
+ coderules.txt Coding style rules --- please read if you contribute code.
+
+Please read at least the files install.txt and usage.txt. Some information
+can also be found in the JPEG FAQ (Frequently Asked Questions) article. See
+ARCHIVE LOCATIONS below to find out where to obtain the FAQ article.
+
+If you want to understand how the JPEG code works, we suggest reading one or
+more of the REFERENCES, then looking at the documentation files (in roughly
+the order listed) before diving into the code.
+
+
+OVERVIEW
+========
+
+This package contains C software to implement JPEG image encoding, decoding,
+and transcoding. JPEG (pronounced "jay-peg") is a standardized compression
+method for full-color and gray-scale images.
+
+This software implements JPEG baseline, extended-sequential, and progressive
+compression processes. Provision is made for supporting all variants of these
+processes, although some uncommon parameter settings aren't implemented yet.
+We have made no provision for supporting the hierarchical or lossless
+processes defined in the standard.
+
+We provide a set of library routines for reading and writing JPEG image files,
+plus two sample applications "cjpeg" and "djpeg", which use the library to
+perform conversion between JPEG and some other popular image file formats.
+The library is intended to be reused in other applications.
+
+In order to support file conversion and viewing software, we have included
+considerable functionality beyond the bare JPEG coding/decoding capability;
+for example, the color quantization modules are not strictly part of JPEG
+decoding, but they are essential for output to colormapped file formats or
+colormapped displays. These extra functions can be compiled out of the
+library if not required for a particular application.
+
+We have also included "jpegtran", a utility for lossless transcoding between
+different JPEG processes, and "rdjpgcom" and "wrjpgcom", two simple
+applications for inserting and extracting textual comments in JFIF files.
+
+The emphasis in designing this software has been on achieving portability and
+flexibility, while also making it fast enough to be useful. In particular,
+the software is not intended to be read as a tutorial on JPEG. (See the
+REFERENCES section for introductory material.) Rather, it is intended to
+be reliable, portable, industrial-strength code. We do not claim to have
+achieved that goal in every aspect of the software, but we strive for it.
+
+We welcome the use of this software as a component of commercial products.
+No royalty is required, but we do ask for an acknowledgement in product
+documentation, as described under LEGAL ISSUES.
+
+
+LEGAL ISSUES
+============
+
+In plain English:
+
+1. We don't promise that this software works. (But if you find any bugs,
+ please let us know!)
+2. You can use this software for whatever you want. You don't have to pay us.
+3. You may not pretend that you wrote this software. If you use it in a
+ program, you must acknowledge somewhere in your documentation that
+ you've used the IJG code.
+
+In legalese:
+
+The authors make NO WARRANTY or representation, either express or implied,
+with respect to this software, its quality, accuracy, merchantability, or
+fitness for a particular purpose. This software is provided "AS IS", and you,
+its user, assume the entire risk as to its quality and accuracy.
+
+This software is copyright (C) 1991-2011, Thomas G. Lane, Guido Vollbeding.
+All Rights Reserved except as specified below.
+
+Permission is hereby granted to use, copy, modify, and distribute this
+software (or portions thereof) for any purpose, without fee, subject to these
+conditions:
+(1) If any part of the source code for this software is distributed, then this
+README file must be included, with this copyright and no-warranty notice
+unaltered; and any additions, deletions, or changes to the original files
+must be clearly indicated in accompanying documentation.
+(2) If only executable code is distributed, then the accompanying
+documentation must state that "this software is based in part on the work of
+the Independent JPEG Group".
+(3) Permission for use of this software is granted only if the user accepts
+full responsibility for any undesirable consequences; the authors accept
+NO LIABILITY for damages of any kind.
+
+These conditions apply to any software derived from or based on the IJG code,
+not just to the unmodified library. If you use our work, you ought to
+acknowledge us.
+
+Permission is NOT granted for the use of any IJG author's name or company name
+in advertising or publicity relating to this software or products derived from
+it. This software may be referred to only as "the Independent JPEG Group's
+software".
+
+We specifically permit and encourage the use of this software as the basis of
+commercial products, provided that all warranty or liability claims are
+assumed by the product vendor.
+
+
+ansi2knr.c is included in this distribution by permission of L. Peter Deutsch,
+sole proprietor of its copyright holder, Aladdin Enterprises of Menlo Park, CA.
+ansi2knr.c is NOT covered by the above copyright and conditions, but instead
+by the usual distribution terms of the Free Software Foundation; principally,
+that you must include source code if you redistribute it. (See the file
+ansi2knr.c for full details.) However, since ansi2knr.c is not needed as part
+of any program generated from the IJG code, this does not limit you more than
+the foregoing paragraphs do.
+
+The Unix configuration script "configure" was produced with GNU Autoconf.
+It is copyright by the Free Software Foundation but is freely distributable.
+The same holds for its supporting scripts (config.guess, config.sub,
+ltmain.sh). Another support script, install-sh, is copyright by X Consortium
+but is also freely distributable.
+
+The IJG distribution formerly included code to read and write GIF files.
+To avoid entanglement with the Unisys LZW patent, GIF reading support has
+been removed altogether, and the GIF writer has been simplified to produce
+"uncompressed GIFs". This technique does not use the LZW algorithm; the
+resulting GIF files are larger than usual, but are readable by all standard
+GIF decoders.
+
+We are required to state that
+ "The Graphics Interchange Format(c) is the Copyright property of
+ CompuServe Incorporated. GIF(sm) is a Service Mark property of
+ CompuServe Incorporated."
+
+
+REFERENCES
+==========
+
+We recommend reading one or more of these references before trying to
+understand the innards of the JPEG software.
+
+The best short technical introduction to the JPEG compression algorithm is
+ Wallace, Gregory K. "The JPEG Still Picture Compression Standard",
+ Communications of the ACM, April 1991 (vol. 34 no. 4), pp. 30-44.
+(Adjacent articles in that issue discuss MPEG motion picture compression,
+applications of JPEG, and related topics.) If you don't have the CACM issue
+handy, a PostScript file containing a revised version of Wallace's article is
+available at http://www.ijg.org/files/wallace.ps.gz. The file (actually
+a preprint for an article that appeared in IEEE Trans. Consumer Electronics)
+omits the sample images that appeared in CACM, but it includes corrections
+and some added material. Note: the Wallace article is copyright ACM and IEEE,
+and it may not be used for commercial purposes.
+
+A somewhat less technical, more leisurely introduction to JPEG can be found in
+"The Data Compression Book" by Mark Nelson and Jean-loup Gailly, published by
+M&T Books (New York), 2nd ed. 1996, ISBN 1-55851-434-1. This book provides
+good explanations and example C code for a multitude of compression methods
+including JPEG. It is an excellent source if you are comfortable reading C
+code but don't know much about data compression in general. The book's JPEG
+sample code is far from industrial-strength, but when you are ready to look
+at a full implementation, you've got one here...
+
+The best currently available description of JPEG is the textbook "JPEG Still
+Image Data Compression Standard" by William B. Pennebaker and Joan L.
+Mitchell, published by Van Nostrand Reinhold, 1993, ISBN 0-442-01272-1.
+Price US$59.95, 638 pp. The book includes the complete text of the ISO JPEG
+standards (DIS 10918-1 and draft DIS 10918-2).
+Although this is by far the most detailed and comprehensive exposition of
+JPEG publicly available, we point out that it is still missing an explanation
+of the most essential properties and algorithms of the underlying DCT
+technology.
+If you think that you know about DCT-based JPEG after reading this book,
+then you are in delusion. The real fundamentals and corresponding potential
+of DCT-based JPEG are not publicly known so far, and that is the reason for
+all the mistaken developments taking place in the image coding domain.
+
+The original JPEG standard is divided into two parts, Part 1 being the actual
+specification, while Part 2 covers compliance testing methods. Part 1 is
+titled "Digital Compression and Coding of Continuous-tone Still Images,
+Part 1: Requirements and guidelines" and has document numbers ISO/IEC IS
+10918-1, ITU-T T.81. Part 2 is titled "Digital Compression and Coding of
+Continuous-tone Still Images, Part 2: Compliance testing" and has document
+numbers ISO/IEC IS 10918-2, ITU-T T.83.
+IJG JPEG 8 introduces an implementation of the JPEG SmartScale extension
+which is specified in a contributed document at ITU and ISO with title "ITU-T
+JPEG-Plus Proposal for Extending ITU-T T.81 for Advanced Image Coding", April
+2006, Geneva, Switzerland. The latest version of the document is Revision 3.
+
+The JPEG standard does not specify all details of an interchangeable file
+format. For the omitted details we follow the "JFIF" conventions, revision
+1.02. JFIF 1.02 has been adopted as an Ecma International Technical Report
+and thus received a formal publication status. It is available as a free
+download in PDF format from
+http://www.ecma-international.org/publications/techreports/E-TR-098.htm.
+A PostScript version of the JFIF document is available at
+http://www.ijg.org/files/jfif.ps.gz. There is also a plain text version at
+http://www.ijg.org/files/jfif.txt.gz, but it is missing the figures.
+
+The TIFF 6.0 file format specification can be obtained by FTP from
+ftp://ftp.sgi.com/graphics/tiff/TIFF6.ps.gz. The JPEG incorporation scheme
+found in the TIFF 6.0 spec of 3-June-92 has a number of serious problems.
+IJG does not recommend use of the TIFF 6.0 design (TIFF Compression tag 6).
+Instead, we recommend the JPEG design proposed by TIFF Technical Note #2
+(Compression tag 7). Copies of this Note can be obtained from
+http://www.ijg.org/files/. It is expected that the next revision
+of the TIFF spec will replace the 6.0 JPEG design with the Note's design.
+Although IJG's own code does not support TIFF/JPEG, the free libtiff library
+uses our library to implement TIFF/JPEG per the Note.
+
+
+ARCHIVE LOCATIONS
+=================
+
+The "official" archive site for this software is www.ijg.org.
+The most recent released version can always be found there in
+directory "files". This particular version will be archived as
+http://www.ijg.org/files/jpegsrc.v8c.tar.gz, and in Windows-compatible
+"zip" archive format as http://www.ijg.org/files/jpegsr8c.zip.
+
+The JPEG FAQ (Frequently Asked Questions) article is a source of some
+general information about JPEG.
+It is available on the World Wide Web at http://www.faqs.org/faqs/jpeg-faq/
+and other news.answers archive sites, including the official news.answers
+archive at rtfm.mit.edu: ftp://rtfm.mit.edu/pub/usenet/news.answers/jpeg-faq/.
+If you don't have Web or FTP access, send e-mail to mail-server@rtfm.mit.edu
+with body
+ send usenet/news.answers/jpeg-faq/part1
+ send usenet/news.answers/jpeg-faq/part2
+
+
+ACKNOWLEDGMENTS
+===============
+
+Thank to Juergen Bruder for providing me with a copy of the common DCT
+algorithm article, only to find out that I had come to the same result
+in a more direct and comprehensible way with a more generative approach.
+
+Thank to Istvan Sebestyen and Joan L. Mitchell for inviting me to the
+ITU JPEG (Study Group 16) meeting in Geneva, Switzerland.
+
+Thank to Thomas Wiegand and Gary Sullivan for inviting me to the
+Joint Video Team (MPEG & ITU) meeting in Geneva, Switzerland.
+
+Thank to John Korejwa and Massimo Ballerini for inviting me to
+fruitful consultations in Boston, MA and Milan, Italy.
+
+Thank to Hendrik Elstner, Roland Fassauer, Simone Zuck, Guenther
+Maier-Gerber, Walter Stoeber, Fred Schmitz, and Norbert Braunagel
+for corresponding business development.
+
+Thank to Nico Zschach and Dirk Stelling of the technical support team
+at the Digital Images company in Halle for providing me with extra
+equipment for configuration tests.
+
+Thank to Richard F. Lyon (then of Foveon Inc.) for fruitful
+communication about JPEG configuration in Sigma Photo Pro software.
+
+Thank to Andrew Finkenstadt for hosting the ijg.org site.
+
+Last but not least special thank to Thomas G. Lane for the original
+design and development of this singular software package.
+
+
+FILE FORMAT WARS
+================
+
+The ISO JPEG standards committee actually promotes different formats like
+"JPEG 2000" or "JPEG XR" which are incompatible with original DCT-based
+JPEG and which are based on faulty technologies. IJG therefore does not
+and will not support such momentary mistakes (see REFERENCES).
+We have little or no sympathy for the promotion of these formats. Indeed,
+one of the original reasons for developing this free software was to help
+force convergence on common, interoperable format standards for JPEG files.
+Don't use an incompatible file format!
+(In any case, our decoder will remain capable of reading existing JPEG
+image files indefinitely.)
+
+
+TO DO
+=====
+
+Version 8 is the first release of a new generation JPEG standard
+to overcome the limitations of the original JPEG specification.
+More features are being prepared for coming releases...
+
+Please send bug reports, offers of help, etc. to jpeg-info@uc.ag.
--- /dev/null
+/*
+ * cderror.h
+ *
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file defines the error and message codes for the cjpeg/djpeg
+ * applications. These strings are not needed as part of the JPEG library
+ * proper.
+ * Edit this file to add new codes, or to translate the message strings to
+ * some other language.
+ */
+
+/*
+ * To define the enum list of message codes, include this file without
+ * defining macro JMESSAGE. To create a message string table, include it
+ * again with a suitable JMESSAGE definition (see jerror.c for an example).
+ */
+#ifndef JMESSAGE
+#ifndef CDERROR_H
+#define CDERROR_H
+/* First time through, define the enum list */
+#define JMAKE_ENUM_LIST
+#else
+/* Repeated inclusions of this file are no-ops unless JMESSAGE is defined */
+#define JMESSAGE(code,string)
+#endif /* CDERROR_H */
+#endif /* JMESSAGE */
+
+#ifdef JMAKE_ENUM_LIST
+
+typedef enum {
+
+#define JMESSAGE(code,string) code ,
+
+#endif /* JMAKE_ENUM_LIST */
+
+JMESSAGE(JMSG_FIRSTADDONCODE=1000, NULL) /* Must be first entry! */
+
+#ifdef BMP_SUPPORTED
+JMESSAGE(JERR_BMP_BADCMAP, "Unsupported BMP colormap format")
+JMESSAGE(JERR_BMP_BADDEPTH, "Only 8- and 24-bit BMP files are supported")
+JMESSAGE(JERR_BMP_BADHEADER, "Invalid BMP file: bad header length")
+JMESSAGE(JERR_BMP_BADPLANES, "Invalid BMP file: biPlanes not equal to 1")
+JMESSAGE(JERR_BMP_COLORSPACE, "BMP output must be grayscale or RGB")
+JMESSAGE(JERR_BMP_COMPRESSED, "Sorry, compressed BMPs not yet supported")
+JMESSAGE(JERR_BMP_NOT, "Not a BMP file - does not start with BM")
+JMESSAGE(JTRC_BMP, "%ux%u 24-bit BMP image")
+JMESSAGE(JTRC_BMP_MAPPED, "%ux%u 8-bit colormapped BMP image")
+JMESSAGE(JTRC_BMP_OS2, "%ux%u 24-bit OS2 BMP image")
+JMESSAGE(JTRC_BMP_OS2_MAPPED, "%ux%u 8-bit colormapped OS2 BMP image")
+#endif /* BMP_SUPPORTED */
+
+#ifdef GIF_SUPPORTED
+JMESSAGE(JERR_GIF_BUG, "GIF output got confused")
+JMESSAGE(JERR_GIF_CODESIZE, "Bogus GIF codesize %d")
+JMESSAGE(JERR_GIF_COLORSPACE, "GIF output must be grayscale or RGB")
+JMESSAGE(JERR_GIF_IMAGENOTFOUND, "Too few images in GIF file")
+JMESSAGE(JERR_GIF_NOT, "Not a GIF file")
+JMESSAGE(JTRC_GIF, "%ux%ux%d GIF image")
+JMESSAGE(JTRC_GIF_BADVERSION,
+ "Warning: unexpected GIF version number '%c%c%c'")
+JMESSAGE(JTRC_GIF_EXTENSION, "Ignoring GIF extension block of type 0x%02x")
+JMESSAGE(JTRC_GIF_NONSQUARE, "Caution: nonsquare pixels in input")
+JMESSAGE(JWRN_GIF_BADDATA, "Corrupt data in GIF file")
+JMESSAGE(JWRN_GIF_CHAR, "Bogus char 0x%02x in GIF file, ignoring")
+JMESSAGE(JWRN_GIF_ENDCODE, "Premature end of GIF image")
+JMESSAGE(JWRN_GIF_NOMOREDATA, "Ran out of GIF bits")
+#endif /* GIF_SUPPORTED */
+
+#ifdef PPM_SUPPORTED
+JMESSAGE(JERR_PPM_COLORSPACE, "PPM output must be grayscale or RGB")
+JMESSAGE(JERR_PPM_NONNUMERIC, "Nonnumeric data in PPM file")
+JMESSAGE(JERR_PPM_NOT, "Not a PPM/PGM file")
+JMESSAGE(JTRC_PGM, "%ux%u PGM image")
+JMESSAGE(JTRC_PGM_TEXT, "%ux%u text PGM image")
+JMESSAGE(JTRC_PPM, "%ux%u PPM image")
+JMESSAGE(JTRC_PPM_TEXT, "%ux%u text PPM image")
+#endif /* PPM_SUPPORTED */
+
+#ifdef RLE_SUPPORTED
+JMESSAGE(JERR_RLE_BADERROR, "Bogus error code from RLE library")
+JMESSAGE(JERR_RLE_COLORSPACE, "RLE output must be grayscale or RGB")
+JMESSAGE(JERR_RLE_DIMENSIONS, "Image dimensions (%ux%u) too large for RLE")
+JMESSAGE(JERR_RLE_EMPTY, "Empty RLE file")
+JMESSAGE(JERR_RLE_EOF, "Premature EOF in RLE header")
+JMESSAGE(JERR_RLE_MEM, "Insufficient memory for RLE header")
+JMESSAGE(JERR_RLE_NOT, "Not an RLE file")
+JMESSAGE(JERR_RLE_TOOMANYCHANNELS, "Cannot handle %d output channels for RLE")
+JMESSAGE(JERR_RLE_UNSUPPORTED, "Cannot handle this RLE setup")
+JMESSAGE(JTRC_RLE, "%ux%u full-color RLE file")
+JMESSAGE(JTRC_RLE_FULLMAP, "%ux%u full-color RLE file with map of length %d")
+JMESSAGE(JTRC_RLE_GRAY, "%ux%u grayscale RLE file")
+JMESSAGE(JTRC_RLE_MAPGRAY, "%ux%u grayscale RLE file with map of length %d")
+JMESSAGE(JTRC_RLE_MAPPED, "%ux%u colormapped RLE file with map of length %d")
+#endif /* RLE_SUPPORTED */
+
+#ifdef TARGA_SUPPORTED
+JMESSAGE(JERR_TGA_BADCMAP, "Unsupported Targa colormap format")
+JMESSAGE(JERR_TGA_BADPARMS, "Invalid or unsupported Targa file")
+JMESSAGE(JERR_TGA_COLORSPACE, "Targa output must be grayscale or RGB")
+JMESSAGE(JTRC_TGA, "%ux%u RGB Targa image")
+JMESSAGE(JTRC_TGA_GRAY, "%ux%u grayscale Targa image")
+JMESSAGE(JTRC_TGA_MAPPED, "%ux%u colormapped Targa image")
+#else
+JMESSAGE(JERR_TGA_NOTCOMP, "Targa support was not compiled")
+#endif /* TARGA_SUPPORTED */
+
+JMESSAGE(JERR_BAD_CMAP_FILE,
+ "Color map file is invalid or of unsupported format")
+JMESSAGE(JERR_TOO_MANY_COLORS,
+ "Output file format cannot handle %d colormap entries")
+JMESSAGE(JERR_UNGETC_FAILED, "ungetc failed")
+#ifdef TARGA_SUPPORTED
+JMESSAGE(JERR_UNKNOWN_FORMAT,
+ "Unrecognized input file format --- perhaps you need -targa")
+#else
+JMESSAGE(JERR_UNKNOWN_FORMAT, "Unrecognized input file format")
+#endif
+JMESSAGE(JERR_UNSUPPORTED_FORMAT, "Unsupported output file format")
+
+#ifdef JMAKE_ENUM_LIST
+
+ JMSG_LASTADDONCODE
+} ADDON_MESSAGE_CODE;
+
+#undef JMAKE_ENUM_LIST
+#endif /* JMAKE_ENUM_LIST */
+
+/* Zap JMESSAGE macro so that future re-inclusions do nothing by default */
+#undef JMESSAGE
--- /dev/null
+/*
+ * jcapimin.c
+ *
+ * Copyright (C) 1994-1998, Thomas G. Lane.
+ * 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 code for the compression half
+ * of the JPEG library. These are the "minimum" API routines that may be
+ * needed in either the normal full-compression case or the transcoding-only
+ * case.
+ *
+ * Most of the routines intended to be called directly by an application
+ * are in this file or in jcapistd.c. But also see jcparam.c for
+ * parameter-setup helper routines, jcomapi.c for routines shared by
+ * compression and decompression, and jctrans.c for the transcoding case.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Initialization of a JPEG compression object.
+ * The error manager must already be set up (in case memory manager fails).
+ */
+
+GLOBAL(void)
+jpeg_CreateCompress (j_compress_ptr cinfo, int version, size_t structsize)
+{
+ int i;
+
+ /* Guard against version mismatches between library and caller. */
+ cinfo->mem = NULL; /* so jpeg_destroy knows mem mgr not called */
+ if (version != JPEG_LIB_VERSION)
+ ERREXIT2(cinfo, JERR_BAD_LIB_VERSION, JPEG_LIB_VERSION, version);
+ if (structsize != SIZEOF(struct jpeg_compress_struct))
+ ERREXIT2(cinfo, JERR_BAD_STRUCT_SIZE,
+ (int) SIZEOF(struct jpeg_compress_struct), (int) structsize);
+
+ /* For debugging purposes, we zero the whole master structure.
+ * But the application has already set the err pointer, and may have set
+ * client_data, so we have to save and restore those fields.
+ * Note: if application hasn't set client_data, tools like Purify may
+ * complain here.
+ */
+ {
+ struct jpeg_error_mgr * err = cinfo->err;
+ void * client_data = cinfo->client_data; /* ignore Purify complaint here */
+ MEMZERO(cinfo, SIZEOF(struct jpeg_compress_struct));
+ cinfo->err = err;
+ cinfo->client_data = client_data;
+ }
+ cinfo->is_decompressor = FALSE;
+
+ /* Initialize a memory manager instance for this object */
+ jinit_memory_mgr((j_common_ptr) cinfo);
+
+ /* Zero out pointers to permanent structures. */
+ cinfo->progress = NULL;
+ cinfo->dest = NULL;
+
+ cinfo->comp_info = NULL;
+
+ for (i = 0; i < NUM_QUANT_TBLS; i++)
+ cinfo->quant_tbl_ptrs[i] = NULL;
+
+ for (i = 0; i < NUM_HUFF_TBLS; i++) {
+ cinfo->dc_huff_tbl_ptrs[i] = NULL;
+ cinfo->ac_huff_tbl_ptrs[i] = NULL;
+ }
+
+ cinfo->script_space = NULL;
+
+ cinfo->input_gamma = 1.0; /* in case application forgets */
+
+ /* OK, I'm ready */
+ cinfo->global_state = CSTATE_START;
+}
+
+
+/*
+ * Destruction of a JPEG compression object
+ */
+
+GLOBAL(void)
+jpeg_destroy_compress (j_compress_ptr cinfo)
+{
+ jpeg_destroy((j_common_ptr) cinfo); /* use common routine */
+}
+
+
+/*
+ * Abort processing of a JPEG compression operation,
+ * but don't destroy the object itself.
+ */
+
+GLOBAL(void)
+jpeg_abort_compress (j_compress_ptr cinfo)
+{
+ jpeg_abort((j_common_ptr) cinfo); /* use common routine */
+}
+
+
+/*
+ * Forcibly suppress or un-suppress all quantization and Huffman tables.
+ * Marks all currently defined tables as already written (if suppress)
+ * or not written (if !suppress). This will control whether they get emitted
+ * by a subsequent jpeg_start_compress call.
+ *
+ * This routine is exported for use by applications that want to produce
+ * abbreviated JPEG datastreams. It logically belongs in jcparam.c, but
+ * since it is called by jpeg_start_compress, we put it here --- otherwise
+ * jcparam.o would be linked whether the application used it or not.
+ */
+
+GLOBAL(void)
+jpeg_suppress_tables (j_compress_ptr cinfo, boolean suppress)
+{
+ int i;
+ JQUANT_TBL * qtbl;
+ JHUFF_TBL * htbl;
+
+ for (i = 0; i < NUM_QUANT_TBLS; i++) {
+ if ((qtbl = cinfo->quant_tbl_ptrs[i]) != NULL)
+ qtbl->sent_table = suppress;
+ }
+
+ for (i = 0; i < NUM_HUFF_TBLS; i++) {
+ if ((htbl = cinfo->dc_huff_tbl_ptrs[i]) != NULL)
+ htbl->sent_table = suppress;
+ if ((htbl = cinfo->ac_huff_tbl_ptrs[i]) != NULL)
+ htbl->sent_table = suppress;
+ }
+}
+
+
+/*
+ * Finish JPEG compression.
+ *
+ * If a multipass operating mode was selected, this may do a great deal of
+ * work including most of the actual output.
+ */
+
+GLOBAL(void)
+jpeg_finish_compress (j_compress_ptr cinfo)
+{
+ JDIMENSION iMCU_row;
+
+ if (cinfo->global_state == CSTATE_SCANNING ||
+ cinfo->global_state == CSTATE_RAW_OK) {
+ /* Terminate first pass */
+ if (cinfo->next_scanline < cinfo->image_height)
+ ERREXIT(cinfo, JERR_TOO_LITTLE_DATA);
+ (*cinfo->master->finish_pass) (cinfo);
+ } else if (cinfo->global_state != CSTATE_WRCOEFS)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+ /* Perform any remaining passes */
+ while (! cinfo->master->is_last_pass) {
+ (*cinfo->master->prepare_for_pass) (cinfo);
+ for (iMCU_row = 0; iMCU_row < cinfo->total_iMCU_rows; iMCU_row++) {
+ if (cinfo->progress != NULL) {
+ cinfo->progress->pass_counter = (long) iMCU_row;
+ cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows;
+ (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+ }
+ /* We bypass the main controller and invoke coef controller directly;
+ * all work is being done from the coefficient buffer.
+ */
+ if (! (*cinfo->coef->compress_data) (cinfo, (JSAMPIMAGE) NULL))
+ ERREXIT(cinfo, JERR_CANT_SUSPEND);
+ }
+ (*cinfo->master->finish_pass) (cinfo);
+ }
+ /* Write EOI, do final cleanup */
+ (*cinfo->marker->write_file_trailer) (cinfo);
+ (*cinfo->dest->term_destination) (cinfo);
+ /* We can use jpeg_abort to release memory and reset global_state */
+ jpeg_abort((j_common_ptr) cinfo);
+}
+
+
+/*
+ * Write a special marker.
+ * This is only recommended for writing COM or APPn markers.
+ * Must be called after jpeg_start_compress() and before
+ * first call to jpeg_write_scanlines() or jpeg_write_raw_data().
+ */
+
+GLOBAL(void)
+jpeg_write_marker (j_compress_ptr cinfo, int marker,
+ const JOCTET *dataptr, unsigned int datalen)
+{
+ JMETHOD(void, write_marker_byte, (j_compress_ptr info, int val));
+
+ if (cinfo->next_scanline != 0 ||
+ (cinfo->global_state != CSTATE_SCANNING &&
+ cinfo->global_state != CSTATE_RAW_OK &&
+ cinfo->global_state != CSTATE_WRCOEFS))
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+ (*cinfo->marker->write_marker_header) (cinfo, marker, datalen);
+ write_marker_byte = cinfo->marker->write_marker_byte; /* copy for speed */
+ while (datalen--) {
+ (*write_marker_byte) (cinfo, *dataptr);
+ dataptr++;
+ }
+}
+
+/* Same, but piecemeal. */
+
+GLOBAL(void)
+jpeg_write_m_header (j_compress_ptr cinfo, int marker, unsigned int datalen)
+{
+ if (cinfo->next_scanline != 0 ||
+ (cinfo->global_state != CSTATE_SCANNING &&
+ cinfo->global_state != CSTATE_RAW_OK &&
+ cinfo->global_state != CSTATE_WRCOEFS))
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+ (*cinfo->marker->write_marker_header) (cinfo, marker, datalen);
+}
+
+GLOBAL(void)
+jpeg_write_m_byte (j_compress_ptr cinfo, int val)
+{
+ (*cinfo->marker->write_marker_byte) (cinfo, val);
+}
+
+
+/*
+ * Alternate compression function: just write an abbreviated table file.
+ * Before calling this, all parameters and a data destination must be set up.
+ *
+ * To produce a pair of files containing abbreviated tables and abbreviated
+ * image data, one would proceed as follows:
+ *
+ * initialize JPEG object
+ * set JPEG parameters
+ * set destination to table file
+ * jpeg_write_tables(cinfo);
+ * set destination to image file
+ * jpeg_start_compress(cinfo, FALSE);
+ * write data...
+ * jpeg_finish_compress(cinfo);
+ *
+ * jpeg_write_tables has the side effect of marking all tables written
+ * (same as jpeg_suppress_tables(..., TRUE)). Thus a subsequent start_compress
+ * will not re-emit the tables unless it is passed write_all_tables=TRUE.
+ */
+
+GLOBAL(void)
+jpeg_write_tables (j_compress_ptr cinfo)
+{
+ if (cinfo->global_state != CSTATE_START)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+ /* (Re)initialize error mgr and destination modules */
+ (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
+ (*cinfo->dest->init_destination) (cinfo);
+ /* Initialize the marker writer ... bit of a crock to do it here. */
+ jinit_marker_writer(cinfo);
+ /* Write them tables! */
+ (*cinfo->marker->write_tables_only) (cinfo);
+ /* And clean up. */
+ (*cinfo->dest->term_destination) (cinfo);
+ /*
+ * In library releases up through v6a, we called jpeg_abort() here to free
+ * any working memory allocated by the destination manager and marker
+ * writer. Some applications had a problem with that: they allocated space
+ * of their own from the library memory manager, and didn't want it to go
+ * away during write_tables. So now we do nothing. This will cause a
+ * memory leak if an app calls write_tables repeatedly without doing a full
+ * compression cycle or otherwise resetting the JPEG object. However, that
+ * seems less bad than unexpectedly freeing memory in the normal case.
+ * An app that prefers the old behavior can call jpeg_abort for itself after
+ * each call to jpeg_write_tables().
+ */
+}
--- /dev/null
+/*
+ * jcapistd.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * 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 code for the compression half
+ * of the JPEG library. These are the "standard" API routines that are
+ * used in the normal full-compression case. They are not used by a
+ * transcoding-only application. Note that if an application links in
+ * jpeg_start_compress, it will end up linking in the entire compressor.
+ * We thus must separate this file from jcapimin.c to avoid linking the
+ * whole compression library into a transcoder.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Compression initialization.
+ * Before calling this, all parameters and a data destination must be set up.
+ *
+ * We require a write_all_tables parameter as a failsafe check when writing
+ * multiple datastreams from the same compression object. Since prior runs
+ * will have left all the tables marked sent_table=TRUE, a subsequent run
+ * would emit an abbreviated stream (no tables) by default. This may be what
+ * is wanted, but for safety's sake it should not be the default behavior:
+ * programmers should have to make a deliberate choice to emit abbreviated
+ * images. Therefore the documentation and examples should encourage people
+ * to pass write_all_tables=TRUE; then it will take active thought to do the
+ * wrong thing.
+ */
+
+GLOBAL(void)
+jpeg_start_compress (j_compress_ptr cinfo, boolean write_all_tables)
+{
+ if (cinfo->global_state != CSTATE_START)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+ if (write_all_tables)
+ jpeg_suppress_tables(cinfo, FALSE); /* mark all tables to be written */
+
+ /* (Re)initialize error mgr and destination modules */
+ (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
+ (*cinfo->dest->init_destination) (cinfo);
+ /* Perform master selection of active modules */
+ jinit_compress_master(cinfo);
+ /* Set up for the first pass */
+ (*cinfo->master->prepare_for_pass) (cinfo);
+ /* Ready for application to drive first pass through jpeg_write_scanlines
+ * or jpeg_write_raw_data.
+ */
+ cinfo->next_scanline = 0;
+ cinfo->global_state = (cinfo->raw_data_in ? CSTATE_RAW_OK : CSTATE_SCANNING);
+}
+
+
+/*
+ * Write some scanlines of data to the JPEG compressor.
+ *
+ * The return value will be the number of lines actually written.
+ * This should be less than the supplied num_lines only in case that
+ * the data destination module has requested suspension of the compressor,
+ * or if more than image_height scanlines are passed in.
+ *
+ * Note: we warn about excess calls to jpeg_write_scanlines() since
+ * this likely signals an application programmer error. However,
+ * excess scanlines passed in the last valid call are *silently* ignored,
+ * so that the application need not adjust num_lines for end-of-image
+ * when using a multiple-scanline buffer.
+ */
+
+GLOBAL(JDIMENSION)
+jpeg_write_scanlines (j_compress_ptr cinfo, JSAMPARRAY scanlines,
+ JDIMENSION num_lines)
+{
+ JDIMENSION row_ctr, rows_left;
+
+ if (cinfo->global_state != CSTATE_SCANNING)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+ if (cinfo->next_scanline >= cinfo->image_height)
+ WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
+
+ /* Call progress monitor hook if present */
+ if (cinfo->progress != NULL) {
+ cinfo->progress->pass_counter = (long) cinfo->next_scanline;
+ cinfo->progress->pass_limit = (long) cinfo->image_height;
+ (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+ }
+
+ /* Give master control module another chance if this is first call to
+ * jpeg_write_scanlines. This lets output of the frame/scan headers be
+ * delayed so that application can write COM, etc, markers between
+ * jpeg_start_compress and jpeg_write_scanlines.
+ */
+ if (cinfo->master->call_pass_startup)
+ (*cinfo->master->pass_startup) (cinfo);
+
+ /* Ignore any extra scanlines at bottom of image. */
+ rows_left = cinfo->image_height - cinfo->next_scanline;
+ if (num_lines > rows_left)
+ num_lines = rows_left;
+
+ row_ctr = 0;
+ (*cinfo->main->process_data) (cinfo, scanlines, &row_ctr, num_lines);
+ cinfo->next_scanline += row_ctr;
+ return row_ctr;
+}
+
+
+/*
+ * Alternate entry point to write raw data.
+ * Processes exactly one iMCU row per call, unless suspended.
+ */
+
+GLOBAL(JDIMENSION)
+jpeg_write_raw_data (j_compress_ptr cinfo, JSAMPIMAGE data,
+ JDIMENSION num_lines)
+{
+ JDIMENSION lines_per_iMCU_row;
+
+ if (cinfo->global_state != CSTATE_RAW_OK)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+ if (cinfo->next_scanline >= cinfo->image_height) {
+ WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
+ return 0;
+ }
+
+ /* Call progress monitor hook if present */
+ if (cinfo->progress != NULL) {
+ cinfo->progress->pass_counter = (long) cinfo->next_scanline;
+ cinfo->progress->pass_limit = (long) cinfo->image_height;
+ (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+ }
+
+ /* Give master control module another chance if this is first call to
+ * jpeg_write_raw_data. This lets output of the frame/scan headers be
+ * delayed so that application can write COM, etc, markers between
+ * jpeg_start_compress and jpeg_write_raw_data.
+ */
+ if (cinfo->master->call_pass_startup)
+ (*cinfo->master->pass_startup) (cinfo);
+
+ /* Verify that at least one iMCU row has been passed. */
+ lines_per_iMCU_row = cinfo->max_v_samp_factor * DCTSIZE;
+ if (num_lines < lines_per_iMCU_row)
+ ERREXIT(cinfo, JERR_BUFFER_SIZE);
+
+ /* Directly compress the row. */
+ if (! (*cinfo->coef->compress_data) (cinfo, data)) {
+ /* If compressor did not consume the whole row, suspend processing. */
+ return 0;
+ }
+
+ /* OK, we processed one iMCU row. */
+ cinfo->next_scanline += lines_per_iMCU_row;
+ return lines_per_iMCU_row;
+}
--- /dev/null
+/*
+ * jccoefct.c
+ *
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * 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 the coefficient buffer controller for compression.
+ * This controller is the top level of the JPEG compressor proper.
+ * The coefficient buffer lies between forward-DCT and entropy encoding steps.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* We use a full-image coefficient buffer when doing Huffman optimization,
+ * and also for writing multiple-scan JPEG files. In all cases, the DCT
+ * step is run during the first pass, and subsequent passes need only read
+ * the buffered coefficients.
+ */
+#ifdef ENTROPY_OPT_SUPPORTED
+#define FULL_COEF_BUFFER_SUPPORTED
+#else
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+#define FULL_COEF_BUFFER_SUPPORTED
+#endif
+#endif
+
+
+/* Private buffer controller object */
+
+typedef struct {
+ struct jpeg_c_coef_controller pub; /* public fields */
+
+ JDIMENSION iMCU_row_num; /* iMCU row # within image */
+ JDIMENSION mcu_ctr; /* counts MCUs processed in current row */
+ int MCU_vert_offset; /* counts MCU rows within iMCU row */
+ int MCU_rows_per_iMCU_row; /* number of such rows needed */
+
+ /* For single-pass compression, it's sufficient to buffer just one MCU
+ * (although this may prove a bit slow in practice). We allocate a
+ * workspace of C_MAX_BLOCKS_IN_MCU coefficient blocks, and reuse it for each
+ * MCU constructed and sent. (On 80x86, the workspace is FAR even though
+ * it's not really very big; this is to keep the module interfaces unchanged
+ * when a large coefficient buffer is necessary.)
+ * In multi-pass modes, this array points to the current MCU's blocks
+ * within the virtual arrays.
+ */
+ JBLOCKROW MCU_buffer[C_MAX_BLOCKS_IN_MCU];
+
+ /* In multi-pass modes, we need a virtual block array for each component. */
+ jvirt_barray_ptr whole_image[MAX_COMPONENTS];
+} my_coef_controller;
+
+typedef my_coef_controller * my_coef_ptr;
+
+
+/* Forward declarations */
+METHODDEF(boolean) compress_data
+ JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
+#ifdef FULL_COEF_BUFFER_SUPPORTED
+METHODDEF(boolean) compress_first_pass
+ JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
+METHODDEF(boolean) compress_output
+ JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
+#endif
+
+
+LOCAL(void)
+start_iMCU_row (j_compress_ptr cinfo)
+/* Reset within-iMCU-row counters for a new row */
+{
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+ /* In an interleaved scan, an MCU row is the same as an iMCU row.
+ * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
+ * But at the bottom of the image, process only what's left.
+ */
+ if (cinfo->comps_in_scan > 1) {
+ coef->MCU_rows_per_iMCU_row = 1;
+ } else {
+ if (coef->iMCU_row_num < (cinfo->total_iMCU_rows-1))
+ coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
+ else
+ coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
+ }
+
+ coef->mcu_ctr = 0;
+ coef->MCU_vert_offset = 0;
+}
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF(void)
+start_pass_coef (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+ coef->iMCU_row_num = 0;
+ start_iMCU_row(cinfo);
+
+ switch (pass_mode) {
+ case JBUF_PASS_THRU:
+ if (coef->whole_image[0] != NULL)
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+ coef->pub.compress_data = compress_data;
+ break;
+#ifdef FULL_COEF_BUFFER_SUPPORTED
+ case JBUF_SAVE_AND_PASS:
+ if (coef->whole_image[0] == NULL)
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+ coef->pub.compress_data = compress_first_pass;
+ break;
+ case JBUF_CRANK_DEST:
+ if (coef->whole_image[0] == NULL)
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+ coef->pub.compress_data = compress_output;
+ break;
+#endif
+ default:
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+ break;
+ }
+}
+
+
+/*
+ * Process some data in the single-pass case.
+ * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
+ * per call, ie, v_samp_factor block rows for each component in the image.
+ * Returns TRUE if the iMCU row is completed, FALSE if suspended.
+ *
+ * NB: input_buf contains a plane for each component in image,
+ * which we index according to the component's SOF position.
+ */
+
+METHODDEF(boolean)
+compress_data (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+{
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+ JDIMENSION MCU_col_num; /* index of current MCU within row */
+ JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
+ JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+ int blkn, bi, ci, yindex, yoffset, blockcnt;
+ JDIMENSION ypos, xpos;
+ jpeg_component_info *compptr;
+
+ /* Loop to write as much as one whole iMCU row */
+ for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+ yoffset++) {
+ for (MCU_col_num = coef->mcu_ctr; MCU_col_num <= last_MCU_col;
+ MCU_col_num++) {
+ /* Determine where data comes from in input_buf and do the DCT thing.
+ * Each call on forward_DCT processes a horizontal row of DCT blocks
+ * as wide as an MCU; we rely on having allocated the MCU_buffer[] blocks
+ * sequentially. Dummy blocks at the right or bottom edge are filled in
+ * specially. The data in them does not matter for image reconstruction,
+ * so we fill them with values that will encode to the smallest amount of
+ * data, viz: all zeroes in the AC entries, DC entries equal to previous
+ * block's DC value. (Thanks to Thomas Kinsman for this idea.)
+ */
+ blkn = 0;
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
+ : compptr->last_col_width;
+ xpos = MCU_col_num * compptr->MCU_sample_width;
+ ypos = yoffset * DCTSIZE; /* ypos == (yoffset+yindex) * DCTSIZE */
+ for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+ if (coef->iMCU_row_num < last_iMCU_row ||
+ yoffset+yindex < compptr->last_row_height) {
+ (*cinfo->fdct->forward_DCT) (cinfo, compptr,
+ input_buf[compptr->component_index],
+ coef->MCU_buffer[blkn],
+ ypos, xpos, (JDIMENSION) blockcnt);
+ if (blockcnt < compptr->MCU_width) {
+ /* Create some dummy blocks at the right edge of the image. */
+ jzero_far((void FAR *) coef->MCU_buffer[blkn + blockcnt],
+ (compptr->MCU_width - blockcnt) * SIZEOF(JBLOCK));
+ for (bi = blockcnt; bi < compptr->MCU_width; bi++) {
+ coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn+bi-1][0][0];
+ }
+ }
+ } else {
+ /* Create a row of dummy blocks at the bottom of the image. */
+ jzero_far((void FAR *) coef->MCU_buffer[blkn],
+ compptr->MCU_width * SIZEOF(JBLOCK));
+ for (bi = 0; bi < compptr->MCU_width; bi++) {
+ coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn-1][0][0];
+ }
+ }
+ blkn += compptr->MCU_width;
+ ypos += DCTSIZE;
+ }
+ }
+ /* Try to write the MCU. In event of a suspension failure, we will
+ * re-DCT the MCU on restart (a bit inefficient, could be fixed...)
+ */
+ if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
+ /* Suspension forced; update state counters and exit */
+ coef->MCU_vert_offset = yoffset;
+ coef->mcu_ctr = MCU_col_num;
+ return FALSE;
+ }
+ }
+ /* Completed an MCU row, but perhaps not an iMCU row */
+ coef->mcu_ctr = 0;
+ }
+ /* Completed the iMCU row, advance counters for next one */
+ coef->iMCU_row_num++;
+ start_iMCU_row(cinfo);
+ return TRUE;
+}
+
+
+#ifdef FULL_COEF_BUFFER_SUPPORTED
+
+/*
+ * Process some data in the first pass of a multi-pass case.
+ * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
+ * per call, ie, v_samp_factor block rows for each component in the image.
+ * This amount of data is read from the source buffer, DCT'd and quantized,
+ * and saved into the virtual arrays. We also generate suitable dummy blocks
+ * as needed at the right and lower edges. (The dummy blocks are constructed
+ * in the virtual arrays, which have been padded appropriately.) This makes
+ * it possible for subsequent passes not to worry about real vs. dummy blocks.
+ *
+ * We must also emit the data to the entropy encoder. This is conveniently
+ * done by calling compress_output() after we've loaded the current strip
+ * of the virtual arrays.
+ *
+ * NB: input_buf contains a plane for each component in image. All
+ * components are DCT'd and loaded into the virtual arrays in this pass.
+ * However, it may be that only a subset of the components are emitted to
+ * the entropy encoder during this first pass; be careful about looking
+ * at the scan-dependent variables (MCU dimensions, etc).
+ */
+
+METHODDEF(boolean)
+compress_first_pass (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+{
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+ JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+ JDIMENSION blocks_across, MCUs_across, MCUindex;
+ int bi, ci, h_samp_factor, block_row, block_rows, ndummy;
+ JCOEF lastDC;
+ jpeg_component_info *compptr;
+ JBLOCKARRAY buffer;
+ JBLOCKROW thisblockrow, lastblockrow;
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ /* Align the virtual buffer for this component. */
+ buffer = (*cinfo->mem->access_virt_barray)
+ ((j_common_ptr) cinfo, coef->whole_image[ci],
+ coef->iMCU_row_num * compptr->v_samp_factor,
+ (JDIMENSION) compptr->v_samp_factor, TRUE);
+ /* Count non-dummy DCT block rows in this iMCU row. */
+ if (coef->iMCU_row_num < last_iMCU_row)
+ block_rows = compptr->v_samp_factor;
+ else {
+ /* NB: can't use last_row_height here, since may not be set! */
+ block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
+ if (block_rows == 0) block_rows = compptr->v_samp_factor;
+ }
+ blocks_across = compptr->width_in_blocks;
+ h_samp_factor = compptr->h_samp_factor;
+ /* Count number of dummy blocks to be added at the right margin. */
+ ndummy = (int) (blocks_across % h_samp_factor);
+ if (ndummy > 0)
+ ndummy = h_samp_factor - ndummy;
+ /* Perform DCT for all non-dummy blocks in this iMCU row. Each call
+ * on forward_DCT processes a complete horizontal row of DCT blocks.
+ */
+ for (block_row = 0; block_row < block_rows; block_row++) {
+ thisblockrow = buffer[block_row];
+ (*cinfo->fdct->forward_DCT) (cinfo, compptr,
+ input_buf[ci], thisblockrow,
+ (JDIMENSION) (block_row * DCTSIZE),
+ (JDIMENSION) 0, blocks_across);
+ if (ndummy > 0) {
+ /* Create dummy blocks at the right edge of the image. */
+ thisblockrow += blocks_across; /* => first dummy block */
+ jzero_far((void FAR *) thisblockrow, ndummy * SIZEOF(JBLOCK));
+ lastDC = thisblockrow[-1][0];
+ for (bi = 0; bi < ndummy; bi++) {
+ thisblockrow[bi][0] = lastDC;
+ }
+ }
+ }
+ /* If at end of image, create dummy block rows as needed.
+ * The tricky part here is that within each MCU, we want the DC values
+ * of the dummy blocks to match the last real block's DC value.
+ * This squeezes a few more bytes out of the resulting file...
+ */
+ if (coef->iMCU_row_num == last_iMCU_row) {
+ blocks_across += ndummy; /* include lower right corner */
+ MCUs_across = blocks_across / h_samp_factor;
+ for (block_row = block_rows; block_row < compptr->v_samp_factor;
+ block_row++) {
+ thisblockrow = buffer[block_row];
+ lastblockrow = buffer[block_row-1];
+ jzero_far((void FAR *) thisblockrow,
+ (size_t) (blocks_across * SIZEOF(JBLOCK)));
+ for (MCUindex = 0; MCUindex < MCUs_across; MCUindex++) {
+ lastDC = lastblockrow[h_samp_factor-1][0];
+ for (bi = 0; bi < h_samp_factor; bi++) {
+ thisblockrow[bi][0] = lastDC;
+ }
+ thisblockrow += h_samp_factor; /* advance to next MCU in row */
+ lastblockrow += h_samp_factor;
+ }
+ }
+ }
+ }
+ /* NB: compress_output will increment iMCU_row_num if successful.
+ * A suspension return will result in redoing all the work above next time.
+ */
+
+ /* Emit data to the entropy encoder, sharing code with subsequent passes */
+ return compress_output(cinfo, input_buf);
+}
+
+
+/*
+ * Process some data in subsequent passes of a multi-pass case.
+ * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
+ * per call, ie, v_samp_factor block rows for each component in the scan.
+ * The data is obtained from the virtual arrays and fed to the entropy coder.
+ * Returns TRUE if the iMCU row is completed, FALSE if suspended.
+ *
+ * NB: input_buf is ignored; it is likely to be a NULL pointer.
+ */
+
+METHODDEF(boolean)
+compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+{
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+ JDIMENSION MCU_col_num; /* index of current MCU within row */
+ int blkn, ci, xindex, yindex, yoffset;
+ JDIMENSION start_col;
+ JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
+ JBLOCKROW buffer_ptr;
+ jpeg_component_info *compptr;
+
+ /* Align the virtual buffers for the components used in this scan.
+ * NB: during first pass, this is safe only because the buffers will
+ * already be aligned properly, so jmemmgr.c won't need to do any I/O.
+ */
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ buffer[ci] = (*cinfo->mem->access_virt_barray)
+ ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index],
+ coef->iMCU_row_num * compptr->v_samp_factor,
+ (JDIMENSION) compptr->v_samp_factor, FALSE);
+ }
+
+ /* Loop to process one whole iMCU row */
+ for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+ yoffset++) {
+ for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row;
+ MCU_col_num++) {
+ /* Construct list of pointers to DCT blocks belonging to this MCU */
+ blkn = 0; /* index of current DCT block within MCU */
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ start_col = MCU_col_num * compptr->MCU_width;
+ for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+ buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
+ for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
+ coef->MCU_buffer[blkn++] = buffer_ptr++;
+ }
+ }
+ }
+ /* Try to write the MCU. */
+ if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
+ /* Suspension forced; update state counters and exit */
+ coef->MCU_vert_offset = yoffset;
+ coef->mcu_ctr = MCU_col_num;
+ return FALSE;
+ }
+ }
+ /* Completed an MCU row, but perhaps not an iMCU row */
+ coef->mcu_ctr = 0;
+ }
+ /* Completed the iMCU row, advance counters for next one */
+ coef->iMCU_row_num++;
+ start_iMCU_row(cinfo);
+ return TRUE;
+}
+
+#endif /* FULL_COEF_BUFFER_SUPPORTED */
+
+
+/*
+ * Initialize coefficient buffer controller.
+ */
+
+GLOBAL(void)
+jinit_c_coef_controller (j_compress_ptr cinfo, boolean need_full_buffer)
+{
+ my_coef_ptr coef;
+
+ coef = (my_coef_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_coef_controller));
+ cinfo->coef = (struct jpeg_c_coef_controller *) coef;
+ coef->pub.start_pass = start_pass_coef;
+
+ /* Create the coefficient buffer. */
+ if (need_full_buffer) {
+#ifdef FULL_COEF_BUFFER_SUPPORTED
+ /* Allocate a full-image virtual array for each component, */
+ /* padded to a multiple of samp_factor DCT blocks in each direction. */
+ int ci;
+ jpeg_component_info *compptr;
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
+ (JDIMENSION) jround_up((long) compptr->width_in_blocks,
+ (long) compptr->h_samp_factor),
+ (JDIMENSION) jround_up((long) compptr->height_in_blocks,
+ (long) compptr->v_samp_factor),
+ (JDIMENSION) compptr->v_samp_factor);
+ }
+#else
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+#endif
+ } else {
+ /* We only need a single-MCU buffer. */
+ JBLOCKROW buffer;
+ int i;
+
+ buffer = (JBLOCKROW)
+ (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+ for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
+ coef->MCU_buffer[i] = buffer + i;
+ }
+ coef->whole_image[0] = NULL; /* flag for no virtual arrays */
+ }
+}
--- /dev/null
+/*
+ * jccolor.c
+ *
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * 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 input colorspace conversion routines.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private subobject */
+
+typedef struct {
+ struct jpeg_color_converter pub; /* public fields */
+
+ /* Private state for RGB->YCC conversion */
+ INT32 * rgb_ycc_tab; /* => table for RGB to YCbCr conversion */
+} my_color_converter;
+
+typedef my_color_converter * my_cconvert_ptr;
+
+
+/**************** RGB -> YCbCr conversion: most common case **************/
+
+/*
+ * YCbCr is defined per CCIR 601-1, except that Cb and Cr are
+ * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
+ * The conversion equations to be implemented are therefore
+ * Y = 0.29900 * R + 0.58700 * G + 0.11400 * B
+ * Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B + CENTERJSAMPLE
+ * Cr = 0.50000 * R - 0.41869 * G - 0.08131 * B + CENTERJSAMPLE
+ * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.)
+ * Note: older versions of the IJG code used a zero offset of MAXJSAMPLE/2,
+ * rather than CENTERJSAMPLE, for Cb and Cr. This gave equal positive and
+ * negative swings for Cb/Cr, but meant that grayscale values (Cb=Cr=0)
+ * were not represented exactly. Now we sacrifice exact representation of
+ * maximum red and maximum blue in order to get exact grayscales.
+ *
+ * To avoid floating-point arithmetic, we represent the fractional constants
+ * as integers scaled up by 2^16 (about 4 digits precision); we have to divide
+ * the products by 2^16, with appropriate rounding, to get the correct answer.
+ *
+ * For even more speed, we avoid doing any multiplications in the inner loop
+ * by precalculating the constants times R,G,B for all possible values.
+ * For 8-bit JSAMPLEs this is very reasonable (only 256 entries per table);
+ * for 12-bit samples it is still acceptable. It's not very reasonable for
+ * 16-bit samples, but if you want lossless storage you shouldn't be changing
+ * colorspace anyway.
+ * The CENTERJSAMPLE offsets and the rounding fudge-factor of 0.5 are included
+ * in the tables to save adding them separately in the inner loop.
+ */
+
+#define SCALEBITS 16 /* speediest right-shift on some machines */
+#define CBCR_OFFSET ((INT32) CENTERJSAMPLE << SCALEBITS)
+#define ONE_HALF ((INT32) 1 << (SCALEBITS-1))
+#define FIX(x) ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
+
+/* We allocate one big table and divide it up into eight parts, instead of
+ * doing eight alloc_small requests. This lets us use a single table base
+ * address, which can be held in a register in the inner loops on many
+ * machines (more than can hold all eight addresses, anyway).
+ */
+
+#define R_Y_OFF 0 /* offset to R => Y section */
+#define G_Y_OFF (1*(MAXJSAMPLE+1)) /* offset to G => Y section */
+#define B_Y_OFF (2*(MAXJSAMPLE+1)) /* etc. */
+#define R_CB_OFF (3*(MAXJSAMPLE+1))
+#define G_CB_OFF (4*(MAXJSAMPLE+1))
+#define B_CB_OFF (5*(MAXJSAMPLE+1))
+#define R_CR_OFF B_CB_OFF /* B=>Cb, R=>Cr are the same */
+#define G_CR_OFF (6*(MAXJSAMPLE+1))
+#define B_CR_OFF (7*(MAXJSAMPLE+1))
+#define TABLE_SIZE (8*(MAXJSAMPLE+1))
+
+
+/*
+ * Initialize for RGB->YCC colorspace conversion.
+ */
+
+METHODDEF(void)
+rgb_ycc_start (j_compress_ptr cinfo)
+{
+ my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+ INT32 * rgb_ycc_tab;
+ INT32 i;
+
+ /* Allocate and fill in the conversion tables. */
+ cconvert->rgb_ycc_tab = rgb_ycc_tab = (INT32 *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (TABLE_SIZE * SIZEOF(INT32)));
+
+ for (i = 0; i <= MAXJSAMPLE; i++) {
+ rgb_ycc_tab[i+R_Y_OFF] = FIX(0.29900) * i;
+ rgb_ycc_tab[i+G_Y_OFF] = FIX(0.58700) * i;
+ rgb_ycc_tab[i+B_Y_OFF] = FIX(0.11400) * i + ONE_HALF;
+ rgb_ycc_tab[i+R_CB_OFF] = (-FIX(0.16874)) * i;
+ rgb_ycc_tab[i+G_CB_OFF] = (-FIX(0.33126)) * i;
+ /* We use a rounding fudge-factor of 0.5-epsilon for Cb and Cr.
+ * This ensures that the maximum output will round to MAXJSAMPLE
+ * not MAXJSAMPLE+1, and thus that we don't have to range-limit.
+ */
+ rgb_ycc_tab[i+B_CB_OFF] = FIX(0.50000) * i + CBCR_OFFSET + ONE_HALF-1;
+/* B=>Cb and R=>Cr tables are the same
+ rgb_ycc_tab[i+R_CR_OFF] = FIX(0.50000) * i + CBCR_OFFSET + ONE_HALF-1;
+*/
+ rgb_ycc_tab[i+G_CR_OFF] = (-FIX(0.41869)) * i;
+ rgb_ycc_tab[i+B_CR_OFF] = (-FIX(0.08131)) * i;
+ }
+}
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ *
+ * Note that we change from the application's interleaved-pixel format
+ * to our internal noninterleaved, one-plane-per-component format.
+ * The input buffer is therefore three times as wide as the output buffer.
+ *
+ * A starting row offset is provided only for the output buffer. The caller
+ * can easily adjust the passed input_buf value to accommodate any row
+ * offset required on that side.
+ */
+
+METHODDEF(void)
+rgb_ycc_convert (j_compress_ptr cinfo,
+ JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+ JDIMENSION output_row, int num_rows)
+{
+ my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+ register int r, g, b;
+ register INT32 * ctab = cconvert->rgb_ycc_tab;
+ register JSAMPROW inptr;
+ register JSAMPROW outptr0, outptr1, outptr2;
+ register JDIMENSION col;
+ JDIMENSION num_cols = cinfo->image_width;
+
+ while (--num_rows >= 0) {
+ inptr = *input_buf++;
+ outptr0 = output_buf[0][output_row];
+ outptr1 = output_buf[1][output_row];
+ outptr2 = output_buf[2][output_row];
+ output_row++;
+ for (col = 0; col < num_cols; col++) {
+ r = GETJSAMPLE(inptr[RGB_RED]);
+ g = GETJSAMPLE(inptr[RGB_GREEN]);
+ b = GETJSAMPLE(inptr[RGB_BLUE]);
+ inptr += RGB_PIXELSIZE;
+ /* If the inputs are 0..MAXJSAMPLE, the outputs of these equations
+ * must be too; we do not need an explicit range-limiting operation.
+ * Hence the value being shifted is never negative, and we don't
+ * need the general RIGHT_SHIFT macro.
+ */
+ /* Y */
+ outptr0[col] = (JSAMPLE)
+ ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
+ >> SCALEBITS);
+ /* Cb */
+ outptr1[col] = (JSAMPLE)
+ ((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF])
+ >> SCALEBITS);
+ /* Cr */
+ outptr2[col] = (JSAMPLE)
+ ((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
+ >> SCALEBITS);
+ }
+ }
+}
+
+
+/**************** Cases other than RGB -> YCbCr **************/
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ * This version handles RGB->grayscale conversion, which is the same
+ * as the RGB->Y portion of RGB->YCbCr.
+ * We assume rgb_ycc_start has been called (we only use the Y tables).
+ */
+
+METHODDEF(void)
+rgb_gray_convert (j_compress_ptr cinfo,
+ JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+ JDIMENSION output_row, int num_rows)
+{
+ my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+ register int r, g, b;
+ register INT32 * ctab = cconvert->rgb_ycc_tab;
+ register JSAMPROW inptr;
+ register JSAMPROW outptr;
+ register JDIMENSION col;
+ JDIMENSION num_cols = cinfo->image_width;
+
+ while (--num_rows >= 0) {
+ inptr = *input_buf++;
+ outptr = output_buf[0][output_row];
+ output_row++;
+ for (col = 0; col < num_cols; col++) {
+ r = GETJSAMPLE(inptr[RGB_RED]);
+ g = GETJSAMPLE(inptr[RGB_GREEN]);
+ b = GETJSAMPLE(inptr[RGB_BLUE]);
+ inptr += RGB_PIXELSIZE;
+ /* Y */
+ outptr[col] = (JSAMPLE)
+ ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
+ >> SCALEBITS);
+ }
+ }
+}
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ * This version handles Adobe-style CMYK->YCCK conversion,
+ * where we convert R=1-C, G=1-M, and B=1-Y to YCbCr using the same
+ * conversion as above, while passing K (black) unchanged.
+ * We assume rgb_ycc_start has been called.
+ */
+
+METHODDEF(void)
+cmyk_ycck_convert (j_compress_ptr cinfo,
+ JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+ JDIMENSION output_row, int num_rows)
+{
+ my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+ register int r, g, b;
+ register INT32 * ctab = cconvert->rgb_ycc_tab;
+ register JSAMPROW inptr;
+ register JSAMPROW outptr0, outptr1, outptr2, outptr3;
+ register JDIMENSION col;
+ JDIMENSION num_cols = cinfo->image_width;
+
+ while (--num_rows >= 0) {
+ inptr = *input_buf++;
+ outptr0 = output_buf[0][output_row];
+ outptr1 = output_buf[1][output_row];
+ outptr2 = output_buf[2][output_row];
+ outptr3 = output_buf[3][output_row];
+ output_row++;
+ for (col = 0; col < num_cols; col++) {
+ r = MAXJSAMPLE - GETJSAMPLE(inptr[0]);
+ g = MAXJSAMPLE - GETJSAMPLE(inptr[1]);
+ b = MAXJSAMPLE - GETJSAMPLE(inptr[2]);
+ /* K passes through as-is */
+ outptr3[col] = inptr[3]; /* don't need GETJSAMPLE here */
+ inptr += 4;
+ /* If the inputs are 0..MAXJSAMPLE, the outputs of these equations
+ * must be too; we do not need an explicit range-limiting operation.
+ * Hence the value being shifted is never negative, and we don't
+ * need the general RIGHT_SHIFT macro.
+ */
+ /* Y */
+ outptr0[col] = (JSAMPLE)
+ ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
+ >> SCALEBITS);
+ /* Cb */
+ outptr1[col] = (JSAMPLE)
+ ((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF])
+ >> SCALEBITS);
+ /* Cr */
+ outptr2[col] = (JSAMPLE)
+ ((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
+ >> SCALEBITS);
+ }
+ }
+}
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ * This version handles grayscale output with no conversion.
+ * The source can be either plain grayscale or YCbCr (since Y == gray).
+ */
+
+METHODDEF(void)
+grayscale_convert (j_compress_ptr cinfo,
+ JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+ JDIMENSION output_row, int num_rows)
+{
+ register JSAMPROW inptr;
+ register JSAMPROW outptr;
+ register JDIMENSION col;
+ JDIMENSION num_cols = cinfo->image_width;
+ int instride = cinfo->input_components;
+
+ while (--num_rows >= 0) {
+ inptr = *input_buf++;
+ outptr = output_buf[0][output_row];
+ output_row++;
+ for (col = 0; col < num_cols; col++) {
+ outptr[col] = inptr[0]; /* don't need GETJSAMPLE() here */
+ inptr += instride;
+ }
+ }
+}
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ * This version handles multi-component colorspaces without conversion.
+ * We assume input_components == num_components.
+ */
+
+METHODDEF(void)
+null_convert (j_compress_ptr cinfo,
+ JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+ JDIMENSION output_row, int num_rows)
+{
+ register JSAMPROW inptr;
+ register JSAMPROW outptr;
+ register JDIMENSION col;
+ register int ci;
+ int nc = cinfo->num_components;
+ JDIMENSION num_cols = cinfo->image_width;
+
+ while (--num_rows >= 0) {
+ /* It seems fastest to make a separate pass for each component. */
+ for (ci = 0; ci < nc; ci++) {
+ inptr = *input_buf;
+ outptr = output_buf[ci][output_row];
+ for (col = 0; col < num_cols; col++) {
+ outptr[col] = inptr[ci]; /* don't need GETJSAMPLE() here */
+ inptr += nc;
+ }
+ }
+ input_buf++;
+ output_row++;
+ }
+}
+
+
+/*
+ * Empty method for start_pass.
+ */
+
+METHODDEF(void)
+null_method (j_compress_ptr cinfo)
+{
+ /* no work needed */
+}
+
+
+/*
+ * Module initialization routine for input colorspace conversion.
+ */
+
+GLOBAL(void)
+jinit_color_converter (j_compress_ptr cinfo)
+{
+ my_cconvert_ptr cconvert;
+
+ cconvert = (my_cconvert_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_color_converter));
+ cinfo->cconvert = (struct jpeg_color_converter *) cconvert;
+ /* set start_pass to null method until we find out differently */
+ cconvert->pub.start_pass = null_method;
+
+ /* Make sure input_components agrees with in_color_space */
+ switch (cinfo->in_color_space) {
+ case JCS_GRAYSCALE:
+ if (cinfo->input_components != 1)
+ ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+ break;
+
+ case JCS_RGB:
+#if RGB_PIXELSIZE != 3
+ if (cinfo->input_components != RGB_PIXELSIZE)
+ ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+ break;
+#endif /* else share code with YCbCr */
+
+ case JCS_YCbCr:
+ if (cinfo->input_components != 3)
+ ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+ break;
+
+ case JCS_CMYK:
+ case JCS_YCCK:
+ if (cinfo->input_components != 4)
+ ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+ break;
+
+ default: /* JCS_UNKNOWN can be anything */
+ if (cinfo->input_components < 1)
+ ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+ break;
+ }
+
+ /* Check num_components, set conversion method based on requested space */
+ switch (cinfo->jpeg_color_space) {
+ case JCS_GRAYSCALE:
+ if (cinfo->num_components != 1)
+ ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+ if (cinfo->in_color_space == JCS_GRAYSCALE)
+ cconvert->pub.color_convert = grayscale_convert;
+ else if (cinfo->in_color_space == JCS_RGB) {
+ cconvert->pub.start_pass = rgb_ycc_start;
+ cconvert->pub.color_convert = rgb_gray_convert;
+ } else if (cinfo->in_color_space == JCS_YCbCr)
+ cconvert->pub.color_convert = grayscale_convert;
+ else
+ ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+ break;
+
+ case JCS_RGB:
+ if (cinfo->num_components != 3)
+ ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+ if (cinfo->in_color_space == JCS_RGB && RGB_PIXELSIZE == 3)
+ cconvert->pub.color_convert = null_convert;
+ else
+ ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+ break;
+
+ case JCS_YCbCr:
+ if (cinfo->num_components != 3)
+ ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+ if (cinfo->in_color_space == JCS_RGB) {
+ cconvert->pub.start_pass = rgb_ycc_start;
+ cconvert->pub.color_convert = rgb_ycc_convert;
+ } else if (cinfo->in_color_space == JCS_YCbCr)
+ cconvert->pub.color_convert = null_convert;
+ else
+ ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+ break;
+
+ case JCS_CMYK:
+ if (cinfo->num_components != 4)
+ ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+ if (cinfo->in_color_space == JCS_CMYK)
+ cconvert->pub.color_convert = null_convert;
+ else
+ ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+ break;
+
+ case JCS_YCCK:
+ if (cinfo->num_components != 4)
+ ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+ if (cinfo->in_color_space == JCS_CMYK) {
+ cconvert->pub.start_pass = rgb_ycc_start;
+ cconvert->pub.color_convert = cmyk_ycck_convert;
+ } else if (cinfo->in_color_space == JCS_YCCK)
+ cconvert->pub.color_convert = null_convert;
+ else
+ ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+ break;
+
+ default: /* allow null conversion of JCS_UNKNOWN */
+ if (cinfo->jpeg_color_space != cinfo->in_color_space ||
+ cinfo->num_components != cinfo->input_components)
+ ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+ cconvert->pub.color_convert = null_convert;
+ break;
+ }
+}
--- /dev/null
+/*
+ * jcdctmgr.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * 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 the forward-DCT management logic.
+ * This code selects a particular DCT implementation to be used,
+ * and it performs related housekeeping chores including coefficient
+ * quantization.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h" /* Private declarations for DCT subsystem */
+
+
+/* Private subobject for this module */
+
+typedef struct {
+ struct jpeg_forward_dct pub; /* public fields */
+
+ /* Pointer to the DCT routine actually in use */
+ forward_DCT_method_ptr do_dct;
+
+ /* The actual post-DCT divisors --- not identical to the quant table
+ * entries, because of scaling (especially for an unnormalized DCT).
+ * Each table is given in normal array order.
+ */
+ DCTELEM * divisors[NUM_QUANT_TBLS];
+
+#ifdef DCT_FLOAT_SUPPORTED
+ /* Same as above for the floating-point case. */
+ float_DCT_method_ptr do_float_dct;
+ FAST_FLOAT * float_divisors[NUM_QUANT_TBLS];
+#endif
+} my_fdct_controller;
+
+typedef my_fdct_controller * my_fdct_ptr;
+
+
+/*
+ * Initialize for a processing pass.
+ * Verify that all referenced Q-tables are present, and set up
+ * the divisor table for each one.
+ * In the current implementation, DCT of all components is done during
+ * the first pass, even if only some components will be output in the
+ * first scan. Hence all components should be examined here.
+ */
+
+METHODDEF(void)
+start_pass_fdctmgr (j_compress_ptr cinfo)
+{
+ my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
+ int ci, qtblno, i;
+ jpeg_component_info *compptr;
+ JQUANT_TBL * qtbl;
+ DCTELEM * dtbl;
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ qtblno = compptr->quant_tbl_no;
+ /* Make sure specified quantization table is present */
+ if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS ||
+ cinfo->quant_tbl_ptrs[qtblno] == NULL)
+ ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno);
+ qtbl = cinfo->quant_tbl_ptrs[qtblno];
+ /* Compute divisors for this quant table */
+ /* We may do this more than once for same table, but it's not a big deal */
+ switch (cinfo->dct_method) {
+#ifdef DCT_ISLOW_SUPPORTED
+ case JDCT_ISLOW:
+ /* For LL&M IDCT method, divisors are equal to raw quantization
+ * coefficients multiplied by 8 (to counteract scaling).
+ */
+ if (fdct->divisors[qtblno] == NULL) {
+ fdct->divisors[qtblno] = (DCTELEM *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ DCTSIZE2 * SIZEOF(DCTELEM));
+ }
+ dtbl = fdct->divisors[qtblno];
+ for (i = 0; i < DCTSIZE2; i++) {
+ dtbl[i] = ((DCTELEM) qtbl->quantval[i]) << 3;
+ }
+ break;
+#endif
+#ifdef DCT_IFAST_SUPPORTED
+ case JDCT_IFAST:
+ {
+ /* For AA&N IDCT method, divisors are equal to quantization
+ * coefficients scaled by scalefactor[row]*scalefactor[col], where
+ * scalefactor[0] = 1
+ * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7
+ * We apply a further scale factor of 8.
+ */
+#define CONST_BITS 14
+ static const INT16 aanscales[DCTSIZE2] = {
+ /* precomputed values scaled up by 14 bits */
+ 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
+ 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
+ 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
+ 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
+ 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
+ 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
+ 8867, 12299, 11585, 10426, 8867, 6967, 4799, 2446,
+ 4520, 6270, 5906, 5315, 4520, 3552, 2446, 1247
+ };
+ SHIFT_TEMPS
+
+ if (fdct->divisors[qtblno] == NULL) {
+ fdct->divisors[qtblno] = (DCTELEM *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ DCTSIZE2 * SIZEOF(DCTELEM));
+ }
+ dtbl = fdct->divisors[qtblno];
+ for (i = 0; i < DCTSIZE2; i++) {
+ dtbl[i] = (DCTELEM)
+ DESCALE(MULTIPLY16V16((INT32) qtbl->quantval[i],
+ (INT32) aanscales[i]),
+ CONST_BITS-3);
+ }
+ }
+ break;
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+ case JDCT_FLOAT:
+ {
+ /* For float AA&N IDCT method, divisors are equal to quantization
+ * coefficients scaled by scalefactor[row]*scalefactor[col], where
+ * scalefactor[0] = 1
+ * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7
+ * We apply a further scale factor of 8.
+ * What's actually stored is 1/divisor so that the inner loop can
+ * use a multiplication rather than a division.
+ */
+ FAST_FLOAT * fdtbl;
+ int row, col;
+ static const double aanscalefactor[DCTSIZE] = {
+ 1.0, 1.387039845, 1.306562965, 1.175875602,
+ 1.0, 0.785694958, 0.541196100, 0.275899379
+ };
+
+ if (fdct->float_divisors[qtblno] == NULL) {
+ fdct->float_divisors[qtblno] = (FAST_FLOAT *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ DCTSIZE2 * SIZEOF(FAST_FLOAT));
+ }
+ fdtbl = fdct->float_divisors[qtblno];
+ i = 0;
+ for (row = 0; row < DCTSIZE; row++) {
+ for (col = 0; col < DCTSIZE; col++) {
+ fdtbl[i] = (FAST_FLOAT)
+ (1.0 / (((double) qtbl->quantval[i] *
+ aanscalefactor[row] * aanscalefactor[col] * 8.0)));
+ i++;
+ }
+ }
+ }
+ break;
+#endif
+ default:
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+ break;
+ }
+ }
+}
+
+
+/*
+ * Perform forward DCT on one or more blocks of a component.
+ *
+ * The input samples are taken from the sample_data[] array starting at
+ * position start_row/start_col, and moving to the right for any additional
+ * blocks. The quantized coefficients are returned in coef_blocks[].
+ */
+
+METHODDEF(void)
+forward_DCT (j_compress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
+ JDIMENSION start_row, JDIMENSION start_col,
+ JDIMENSION num_blocks)
+/* This version is used for integer DCT implementations. */
+{
+ /* This routine is heavily used, so it's worth coding it tightly. */
+ my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
+ forward_DCT_method_ptr do_dct = fdct->do_dct;
+ DCTELEM * divisors = fdct->divisors[compptr->quant_tbl_no];
+ DCTELEM workspace[DCTSIZE2]; /* work area for FDCT subroutine */
+ JDIMENSION bi;
+
+ sample_data += start_row; /* fold in the vertical offset once */
+
+ for (bi = 0; bi < num_blocks; bi++, start_col += DCTSIZE) {
+ /* Load data into workspace, applying unsigned->signed conversion */
+ { register DCTELEM *workspaceptr;
+ register JSAMPROW elemptr;
+ register int elemr;
+
+ workspaceptr = workspace;
+ for (elemr = 0; elemr < DCTSIZE; elemr++) {
+ elemptr = sample_data[elemr] + start_col;
+#if DCTSIZE == 8 /* unroll the inner loop */
+ *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+ *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+ *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+ *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+ *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+ *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+ *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+ *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+#else
+ { register int elemc;
+ for (elemc = DCTSIZE; elemc > 0; elemc--) {
+ *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+ }
+ }
+#endif
+ }
+ }
+
+ /* Perform the DCT */
+ (*do_dct) (workspace);
+
+ /* Quantize/descale the coefficients, and store into coef_blocks[] */
+ { register DCTELEM temp, qval;
+ register int i;
+ register JCOEFPTR output_ptr = coef_blocks[bi];
+
+ for (i = 0; i < DCTSIZE2; i++) {
+ qval = divisors[i];
+ temp = workspace[i];
+ /* Divide the coefficient value by qval, ensuring proper rounding.
+ * Since C does not specify the direction of rounding for negative
+ * quotients, we have to force the dividend positive for portability.
+ *
+ * In most files, at least half of the output values will be zero
+ * (at default quantization settings, more like three-quarters...)
+ * so we should ensure that this case is fast. On many machines,
+ * a comparison is enough cheaper than a divide to make a special test
+ * a win. Since both inputs will be nonnegative, we need only test
+ * for a < b to discover whether a/b is 0.
+ * If your machine's division is fast enough, define FAST_DIVIDE.
+ */
+#ifdef FAST_DIVIDE
+#define DIVIDE_BY(a,b) a /= b
+#else
+#define DIVIDE_BY(a,b) if (a >= b) a /= b; else a = 0
+#endif
+ if (temp < 0) {
+ temp = -temp;
+ temp += qval>>1; /* for rounding */
+ DIVIDE_BY(temp, qval);
+ temp = -temp;
+ } else {
+ temp += qval>>1; /* for rounding */
+ DIVIDE_BY(temp, qval);
+ }
+ output_ptr[i] = (JCOEF) temp;
+ }
+ }
+ }
+}
+
+
+#ifdef DCT_FLOAT_SUPPORTED
+
+METHODDEF(void)
+forward_DCT_float (j_compress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
+ JDIMENSION start_row, JDIMENSION start_col,
+ JDIMENSION num_blocks)
+/* This version is used for floating-point DCT implementations. */
+{
+ /* This routine is heavily used, so it's worth coding it tightly. */
+ my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
+ float_DCT_method_ptr do_dct = fdct->do_float_dct;
+ FAST_FLOAT * divisors = fdct->float_divisors[compptr->quant_tbl_no];
+ FAST_FLOAT workspace[DCTSIZE2]; /* work area for FDCT subroutine */
+ JDIMENSION bi;
+
+ sample_data += start_row; /* fold in the vertical offset once */
+
+ for (bi = 0; bi < num_blocks; bi++, start_col += DCTSIZE) {
+ /* Load data into workspace, applying unsigned->signed conversion */
+ { register FAST_FLOAT *workspaceptr;
+ register JSAMPROW elemptr;
+ register int elemr;
+
+ workspaceptr = workspace;
+ for (elemr = 0; elemr < DCTSIZE; elemr++) {
+ elemptr = sample_data[elemr] + start_col;
+#if DCTSIZE == 8 /* unroll the inner loop */
+ *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+ *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+ *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+ *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+ *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+ *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+ *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+ *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+#else
+ { register int elemc;
+ for (elemc = DCTSIZE; elemc > 0; elemc--) {
+ *workspaceptr++ = (FAST_FLOAT)
+ (GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+ }
+ }
+#endif
+ }
+ }
+
+ /* Perform the DCT */
+ (*do_dct) (workspace);
+
+ /* Quantize/descale the coefficients, and store into coef_blocks[] */
+ { register FAST_FLOAT temp;
+ register int i;
+ register JCOEFPTR output_ptr = coef_blocks[bi];
+
+ for (i = 0; i < DCTSIZE2; i++) {
+ /* Apply the quantization and scaling factor */
+ temp = workspace[i] * divisors[i];
+ /* Round to nearest integer.
+ * Since C does not specify the direction of rounding for negative
+ * quotients, we have to force the dividend positive for portability.
+ * The maximum coefficient size is +-16K (for 12-bit data), so this
+ * code should work for either 16-bit or 32-bit ints.
+ */
+ output_ptr[i] = (JCOEF) ((int) (temp + (FAST_FLOAT) 16384.5) - 16384);
+ }
+ }
+ }
+}
+
+#endif /* DCT_FLOAT_SUPPORTED */
+
+
+/*
+ * Initialize FDCT manager.
+ */
+
+GLOBAL(void)
+jinit_forward_dct (j_compress_ptr cinfo)
+{
+ my_fdct_ptr fdct;
+ int i;
+
+ fdct = (my_fdct_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_fdct_controller));
+ cinfo->fdct = (struct jpeg_forward_dct *) fdct;
+ fdct->pub.start_pass = start_pass_fdctmgr;
+
+ switch (cinfo->dct_method) {
+#ifdef DCT_ISLOW_SUPPORTED
+ case JDCT_ISLOW:
+ fdct->pub.forward_DCT = forward_DCT;
+ fdct->do_dct = jpeg_fdct_islow;
+ break;
+#endif
+#ifdef DCT_IFAST_SUPPORTED
+ case JDCT_IFAST:
+ fdct->pub.forward_DCT = forward_DCT;
+ fdct->do_dct = jpeg_fdct_ifast;
+ break;
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+ case JDCT_FLOAT:
+ fdct->pub.forward_DCT = forward_DCT_float;
+ fdct->do_float_dct = jpeg_fdct_float;
+ break;
+#endif
+ default:
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+ break;
+ }
+
+ /* Mark divisor tables unallocated */
+ for (i = 0; i < NUM_QUANT_TBLS; i++) {
+ fdct->divisors[i] = NULL;
+#ifdef DCT_FLOAT_SUPPORTED
+ fdct->float_divisors[i] = NULL;
+#endif
+ }
+}
--- /dev/null
+/*
+ * jchuff.c
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * 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 Huffman entropy encoding routines.
+ *
+ * Much of the complexity here has to do with supporting output suspension.
+ * If the data destination module demands suspension, we want to be able to
+ * back up to the start of the current MCU. To do this, we copy state
+ * variables into local working storage, and update them back to the
+ * permanent JPEG objects only upon successful completion of an MCU.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jchuff.h" /* Declarations shared with jcphuff.c */
+
+
+/* Expanded entropy encoder object for Huffman encoding.
+ *
+ * The savable_state subrecord contains fields that change within an MCU,
+ * but must not be updated permanently until we complete the MCU.
+ */
+
+typedef struct {
+ INT32 put_buffer; /* current bit-accumulation buffer */
+ int put_bits; /* # of bits now in it */
+ int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
+} savable_state;
+
+/* This macro is to work around compilers with missing or broken
+ * structure assignment. You'll need to fix this code if you have
+ * such a compiler and you change MAX_COMPS_IN_SCAN.
+ */
+
+#ifndef NO_STRUCT_ASSIGN
+#define ASSIGN_STATE(dest,src) ((dest) = (src))
+#else
+#if MAX_COMPS_IN_SCAN == 4
+#define ASSIGN_STATE(dest,src) \
+ ((dest).put_buffer = (src).put_buffer, \
+ (dest).put_bits = (src).put_bits, \
+ (dest).last_dc_val[0] = (src).last_dc_val[0], \
+ (dest).last_dc_val[1] = (src).last_dc_val[1], \
+ (dest).last_dc_val[2] = (src).last_dc_val[2], \
+ (dest).last_dc_val[3] = (src).last_dc_val[3])
+#endif
+#endif
+
+
+typedef struct {
+ struct jpeg_entropy_encoder pub; /* public fields */
+
+ savable_state saved; /* Bit buffer & DC state at start of MCU */
+
+ /* These fields are NOT loaded into local working state. */
+ unsigned int restarts_to_go; /* MCUs left in this restart interval */
+ int next_restart_num; /* next restart number to write (0-7) */
+
+ /* Pointers to derived tables (these workspaces have image lifespan) */
+ c_derived_tbl * dc_derived_tbls[NUM_HUFF_TBLS];
+ c_derived_tbl * ac_derived_tbls[NUM_HUFF_TBLS];
+
+#ifdef ENTROPY_OPT_SUPPORTED /* Statistics tables for optimization */
+ long * dc_count_ptrs[NUM_HUFF_TBLS];
+ long * ac_count_ptrs[NUM_HUFF_TBLS];
+#endif
+} huff_entropy_encoder;
+
+typedef huff_entropy_encoder * huff_entropy_ptr;
+
+/* Working state while writing an MCU.
+ * This struct contains all the fields that are needed by subroutines.
+ */
+
+typedef struct {
+ JOCTET * next_output_byte; /* => next byte to write in buffer */
+ size_t free_in_buffer; /* # of byte spaces remaining in buffer */
+ savable_state cur; /* Current bit buffer & DC state */
+ j_compress_ptr cinfo; /* dump_buffer needs access to this */
+} working_state;
+
+
+/* Forward declarations */
+METHODDEF(boolean) encode_mcu_huff JPP((j_compress_ptr cinfo,
+ JBLOCKROW *MCU_data));
+METHODDEF(void) finish_pass_huff JPP((j_compress_ptr cinfo));
+#ifdef ENTROPY_OPT_SUPPORTED
+METHODDEF(boolean) encode_mcu_gather JPP((j_compress_ptr cinfo,
+ JBLOCKROW *MCU_data));
+METHODDEF(void) finish_pass_gather JPP((j_compress_ptr cinfo));
+#endif
+
+
+/*
+ * Initialize for a Huffman-compressed scan.
+ * If gather_statistics is TRUE, we do not output anything during the scan,
+ * just count the Huffman symbols used and generate Huffman code tables.
+ */
+
+METHODDEF(void)
+start_pass_huff (j_compress_ptr cinfo, boolean gather_statistics)
+{
+ huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+ int ci, dctbl, actbl;
+ jpeg_component_info * compptr;
+
+ if (gather_statistics) {
+#ifdef ENTROPY_OPT_SUPPORTED
+ entropy->pub.encode_mcu = encode_mcu_gather;
+ entropy->pub.finish_pass = finish_pass_gather;
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+ } else {
+ entropy->pub.encode_mcu = encode_mcu_huff;
+ entropy->pub.finish_pass = finish_pass_huff;
+ }
+
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ dctbl = compptr->dc_tbl_no;
+ actbl = compptr->ac_tbl_no;
+ if (gather_statistics) {
+#ifdef ENTROPY_OPT_SUPPORTED
+ /* Check for invalid table indexes */
+ /* (make_c_derived_tbl does this in the other path) */
+ if (dctbl < 0 || dctbl >= NUM_HUFF_TBLS)
+ ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, dctbl);
+ if (actbl < 0 || actbl >= NUM_HUFF_TBLS)
+ ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, actbl);
+ /* Allocate and zero the statistics tables */
+ /* Note that jpeg_gen_optimal_table expects 257 entries in each table! */
+ if (entropy->dc_count_ptrs[dctbl] == NULL)
+ entropy->dc_count_ptrs[dctbl] = (long *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ 257 * SIZEOF(long));
+ MEMZERO(entropy->dc_count_ptrs[dctbl], 257 * SIZEOF(long));
+ if (entropy->ac_count_ptrs[actbl] == NULL)
+ entropy->ac_count_ptrs[actbl] = (long *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ 257 * SIZEOF(long));
+ MEMZERO(entropy->ac_count_ptrs[actbl], 257 * SIZEOF(long));
+#endif
+ } else {
+ /* Compute derived values for Huffman tables */
+ /* We may do this more than once for a table, but it's not expensive */
+ jpeg_make_c_derived_tbl(cinfo, TRUE, dctbl,
+ & entropy->dc_derived_tbls[dctbl]);
+ jpeg_make_c_derived_tbl(cinfo, FALSE, actbl,
+ & entropy->ac_derived_tbls[actbl]);
+ }
+ /* Initialize DC predictions to 0 */
+ entropy->saved.last_dc_val[ci] = 0;
+ }
+
+ /* Initialize bit buffer to empty */
+ entropy->saved.put_buffer = 0;
+ entropy->saved.put_bits = 0;
+
+ /* Initialize restart stuff */
+ entropy->restarts_to_go = cinfo->restart_interval;
+ entropy->next_restart_num = 0;
+}
+
+
+/*
+ * Compute the derived values for a Huffman table.
+ * This routine also performs some validation checks on the table.
+ *
+ * Note this is also used by jcphuff.c.
+ */
+
+GLOBAL(void)
+jpeg_make_c_derived_tbl (j_compress_ptr cinfo, boolean isDC, int tblno,
+ c_derived_tbl ** pdtbl)
+{
+ JHUFF_TBL *htbl;
+ c_derived_tbl *dtbl;
+ int p, i, l, lastp, si, maxsymbol;
+ char huffsize[257];
+ unsigned int huffcode[257];
+ unsigned int code;
+
+ /* Note that huffsize[] and huffcode[] are filled in code-length order,
+ * paralleling the order of the symbols themselves in htbl->huffval[].
+ */
+
+ /* Find the input Huffman table */
+ if (tblno < 0 || tblno >= NUM_HUFF_TBLS)
+ ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
+ htbl =
+ isDC ? cinfo->dc_huff_tbl_ptrs[tblno] : cinfo->ac_huff_tbl_ptrs[tblno];
+ if (htbl == NULL)
+ ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
+
+ /* Allocate a workspace if we haven't already done so. */
+ if (*pdtbl == NULL)
+ *pdtbl = (c_derived_tbl *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(c_derived_tbl));
+ dtbl = *pdtbl;
+
+ /* Figure C.1: make table of Huffman code length for each symbol */
+
+ p = 0;
+ for (l = 1; l <= 16; l++) {
+ i = (int) htbl->bits[l];
+ if (i < 0 || p + i > 256) /* protect against table overrun */
+ ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+ while (i--)
+ huffsize[p++] = (char) l;
+ }
+ huffsize[p] = 0;
+ lastp = p;
+
+ /* Figure C.2: generate the codes themselves */
+ /* We also validate that the counts represent a legal Huffman code tree. */
+
+ code = 0;
+ si = huffsize[0];
+ p = 0;
+ while (huffsize[p]) {
+ while (((int) huffsize[p]) == si) {
+ huffcode[p++] = code;
+ code++;
+ }
+ /* code is now 1 more than the last code used for codelength si; but
+ * it must still fit in si bits, since no code is allowed to be all ones.
+ */
+ if (((INT32) code) >= (((INT32) 1) << si))
+ ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+ code <<= 1;
+ si++;
+ }
+
+ /* Figure C.3: generate encoding tables */
+ /* These are code and size indexed by symbol value */
+
+ /* Set all codeless symbols to have code length 0;
+ * this lets us detect duplicate VAL entries here, and later
+ * allows emit_bits to detect any attempt to emit such symbols.
+ */
+ MEMZERO(dtbl->ehufsi, SIZEOF(dtbl->ehufsi));
+
+ /* This is also a convenient place to check for out-of-range
+ * and duplicated VAL entries. We allow 0..255 for AC symbols
+ * but only 0..15 for DC. (We could constrain them further
+ * based on data depth and mode, but this seems enough.)
+ */
+ maxsymbol = isDC ? 15 : 255;
+
+ for (p = 0; p < lastp; p++) {
+ i = htbl->huffval[p];
+ if (i < 0 || i > maxsymbol || dtbl->ehufsi[i])
+ ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+ dtbl->ehufco[i] = huffcode[p];
+ dtbl->ehufsi[i] = huffsize[p];
+ }
+}
+
+
+/* Outputting bytes to the file */
+
+/* Emit a byte, taking 'action' if must suspend. */
+#define emit_byte(state,val,action) \
+ { *(state)->next_output_byte++ = (JOCTET) (val); \
+ if (--(state)->free_in_buffer == 0) \
+ if (! dump_buffer(state)) \
+ { action; } }
+
+
+LOCAL(boolean)
+dump_buffer (working_state * state)
+/* Empty the output buffer; return TRUE if successful, FALSE if must suspend */
+{
+ struct jpeg_destination_mgr * dest = state->cinfo->dest;
+
+ if (! (*dest->empty_output_buffer) (state->cinfo))
+ return FALSE;
+ /* After a successful buffer dump, must reset buffer pointers */
+ state->next_output_byte = dest->next_output_byte;
+ state->free_in_buffer = dest->free_in_buffer;
+ return TRUE;
+}
+
+
+/* Outputting bits to the file */
+
+/* Only the right 24 bits of put_buffer are used; the valid bits are
+ * left-justified in this part. At most 16 bits can be passed to emit_bits
+ * in one call, and we never retain more than 7 bits in put_buffer
+ * between calls, so 24 bits are sufficient.
+ */
+
+INLINE
+LOCAL(boolean)
+emit_bits (working_state * state, unsigned int code, int size)
+/* Emit some bits; return TRUE if successful, FALSE if must suspend */
+{
+ /* This routine is heavily used, so it's worth coding tightly. */
+ register INT32 put_buffer = (INT32) code;
+ register int put_bits = state->cur.put_bits;
+
+ /* if size is 0, caller used an invalid Huffman table entry */
+ if (size == 0)
+ ERREXIT(state->cinfo, JERR_HUFF_MISSING_CODE);
+
+ put_buffer &= (((INT32) 1)<<size) - 1; /* mask off any extra bits in code */
+
+ put_bits += size; /* new number of bits in buffer */
+
+ put_buffer <<= 24 - put_bits; /* align incoming bits */
+
+ put_buffer |= state->cur.put_buffer; /* and merge with old buffer contents */
+
+ while (put_bits >= 8) {
+ int c = (int) ((put_buffer >> 16) & 0xFF);
+
+ emit_byte(state, c, return FALSE);
+ if (c == 0xFF) { /* need to stuff a zero byte? */
+ emit_byte(state, 0, return FALSE);
+ }
+ put_buffer <<= 8;
+ put_bits -= 8;
+ }
+
+ state->cur.put_buffer = put_buffer; /* update state variables */
+ state->cur.put_bits = put_bits;
+
+ return TRUE;
+}
+
+
+LOCAL(boolean)
+flush_bits (working_state * state)
+{
+ if (! emit_bits(state, 0x7F, 7)) /* fill any partial byte with ones */
+ return FALSE;
+ state->cur.put_buffer = 0; /* and reset bit-buffer to empty */
+ state->cur.put_bits = 0;
+ return TRUE;
+}
+
+
+/* Encode a single block's worth of coefficients */
+
+LOCAL(boolean)
+encode_one_block (working_state * state, JCOEFPTR block, int last_dc_val,
+ c_derived_tbl *dctbl, c_derived_tbl *actbl)
+{
+ register int temp, temp2;
+ register int nbits;
+ register int k, r, i;
+
+ /* Encode the DC coefficient difference per section F.1.2.1 */
+
+ temp = temp2 = block[0] - last_dc_val;
+
+ if (temp < 0) {
+ temp = -temp; /* temp is abs value of input */
+ /* For a negative input, want temp2 = bitwise complement of abs(input) */
+ /* This code assumes we are on a two's complement machine */
+ temp2--;
+ }
+
+ /* Find the number of bits needed for the magnitude of the coefficient */
+ nbits = 0;
+ while (temp) {
+ nbits++;
+ temp >>= 1;
+ }
+ /* Check for out-of-range coefficient values.
+ * Since we're encoding a difference, the range limit is twice as much.
+ */
+ if (nbits > MAX_COEF_BITS+1)
+ ERREXIT(state->cinfo, JERR_BAD_DCT_COEF);
+
+ /* Emit the Huffman-coded symbol for the number of bits */
+ if (! emit_bits(state, dctbl->ehufco[nbits], dctbl->ehufsi[nbits]))
+ return FALSE;
+
+ /* Emit that number of bits of the value, if positive, */
+ /* or the complement of its magnitude, if negative. */
+ if (nbits) /* emit_bits rejects calls with size 0 */
+ if (! emit_bits(state, (unsigned int) temp2, nbits))
+ return FALSE;
+
+ /* Encode the AC coefficients per section F.1.2.2 */
+
+ r = 0; /* r = run length of zeros */
+
+ for (k = 1; k < DCTSIZE2; k++) {
+ if ((temp = block[jpeg_natural_order[k]]) == 0) {
+ r++;
+ } else {
+ /* if run length > 15, must emit special run-length-16 codes (0xF0) */
+ while (r > 15) {
+ if (! emit_bits(state, actbl->ehufco[0xF0], actbl->ehufsi[0xF0]))
+ return FALSE;
+ r -= 16;
+ }
+
+ temp2 = temp;
+ if (temp < 0) {
+ temp = -temp; /* temp is abs value of input */
+ /* This code assumes we are on a two's complement machine */
+ temp2--;
+ }
+
+ /* Find the number of bits needed for the magnitude of the coefficient */
+ nbits = 1; /* there must be at least one 1 bit */
+ while ((temp >>= 1))
+ nbits++;
+ /* Check for out-of-range coefficient values */
+ if (nbits > MAX_COEF_BITS)
+ ERREXIT(state->cinfo, JERR_BAD_DCT_COEF);
+
+ /* Emit Huffman symbol for run length / number of bits */
+ i = (r << 4) + nbits;
+ if (! emit_bits(state, actbl->ehufco[i], actbl->ehufsi[i]))
+ return FALSE;
+
+ /* Emit that number of bits of the value, if positive, */
+ /* or the complement of its magnitude, if negative. */
+ if (! emit_bits(state, (unsigned int) temp2, nbits))
+ return FALSE;
+
+ r = 0;
+ }
+ }
+
+ /* If the last coef(s) were zero, emit an end-of-block code */
+ if (r > 0)
+ if (! emit_bits(state, actbl->ehufco[0], actbl->ehufsi[0]))
+ return FALSE;
+
+ return TRUE;
+}
+
+
+/*
+ * Emit a restart marker & resynchronize predictions.
+ */
+
+LOCAL(boolean)
+emit_restart (working_state * state, int restart_num)
+{
+ int ci;
+
+ if (! flush_bits(state))
+ return FALSE;
+
+ emit_byte(state, 0xFF, return FALSE);
+ emit_byte(state, JPEG_RST0 + restart_num, return FALSE);
+
+ /* Re-initialize DC predictions to 0 */
+ for (ci = 0; ci < state->cinfo->comps_in_scan; ci++)
+ state->cur.last_dc_val[ci] = 0;
+
+ /* The restart counter is not updated until we successfully write the MCU. */
+
+ return TRUE;
+}
+
+
+/*
+ * Encode and output one MCU's worth of Huffman-compressed coefficients.
+ */
+
+METHODDEF(boolean)
+encode_mcu_huff (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+ huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+ working_state state;
+ int blkn, ci;
+ jpeg_component_info * compptr;
+
+ /* Load up working state */
+ state.next_output_byte = cinfo->dest->next_output_byte;
+ state.free_in_buffer = cinfo->dest->free_in_buffer;
+ ASSIGN_STATE(state.cur, entropy->saved);
+ state.cinfo = cinfo;
+
+ /* Emit restart marker if needed */
+ if (cinfo->restart_interval) {
+ if (entropy->restarts_to_go == 0)
+ if (! emit_restart(&state, entropy->next_restart_num))
+ return FALSE;
+ }
+
+ /* Encode the MCU data blocks */
+ for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+ ci = cinfo->MCU_membership[blkn];
+ compptr = cinfo->cur_comp_info[ci];
+ if (! encode_one_block(&state,
+ MCU_data[blkn][0], state.cur.last_dc_val[ci],
+ entropy->dc_derived_tbls[compptr->dc_tbl_no],
+ entropy->ac_derived_tbls[compptr->ac_tbl_no]))
+ return FALSE;
+ /* Update last_dc_val */
+ state.cur.last_dc_val[ci] = MCU_data[blkn][0][0];
+ }
+
+ /* Completed MCU, so update state */
+ cinfo->dest->next_output_byte = state.next_output_byte;
+ cinfo->dest->free_in_buffer = state.free_in_buffer;
+ ASSIGN_STATE(entropy->saved, state.cur);
+
+ /* Update restart-interval state too */
+ if (cinfo->restart_interval) {
+ if (entropy->restarts_to_go == 0) {
+ entropy->restarts_to_go = cinfo->restart_interval;
+ entropy->next_restart_num++;
+ entropy->next_restart_num &= 7;
+ }
+ entropy->restarts_to_go--;
+ }
+
+ return TRUE;
+}
+
+
+/*
+ * Finish up at the end of a Huffman-compressed scan.
+ */
+
+METHODDEF(void)
+finish_pass_huff (j_compress_ptr cinfo)
+{
+ huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+ working_state state;
+
+ /* Load up working state ... flush_bits needs it */
+ state.next_output_byte = cinfo->dest->next_output_byte;
+ state.free_in_buffer = cinfo->dest->free_in_buffer;
+ ASSIGN_STATE(state.cur, entropy->saved);
+ state.cinfo = cinfo;
+
+ /* Flush out the last data */
+ if (! flush_bits(&state))
+ ERREXIT(cinfo, JERR_CANT_SUSPEND);
+
+ /* Update state */
+ cinfo->dest->next_output_byte = state.next_output_byte;
+ cinfo->dest->free_in_buffer = state.free_in_buffer;
+ ASSIGN_STATE(entropy->saved, state.cur);
+}
+
+
+/*
+ * Huffman coding optimization.
+ *
+ * We first scan the supplied data and count the number of uses of each symbol
+ * that is to be Huffman-coded. (This process MUST agree with the code above.)
+ * Then we build a Huffman coding tree for the observed counts.
+ * Symbols which are not needed at all for the particular image are not
+ * assigned any code, which saves space in the DHT marker as well as in
+ * the compressed data.
+ */
+
+#ifdef ENTROPY_OPT_SUPPORTED
+
+
+/* Process a single block's worth of coefficients */
+
+LOCAL(void)
+htest_one_block (j_compress_ptr cinfo, JCOEFPTR block, int last_dc_val,
+ long dc_counts[], long ac_counts[])
+{
+ register int temp;
+ register int nbits;
+ register int k, r;
+
+ /* Encode the DC coefficient difference per section F.1.2.1 */
+
+ temp = block[0] - last_dc_val;
+ if (temp < 0)
+ temp = -temp;
+
+ /* Find the number of bits needed for the magnitude of the coefficient */
+ nbits = 0;
+ while (temp) {
+ nbits++;
+ temp >>= 1;
+ }
+ /* Check for out-of-range coefficient values.
+ * Since we're encoding a difference, the range limit is twice as much.
+ */
+ if (nbits > MAX_COEF_BITS+1)
+ ERREXIT(cinfo, JERR_BAD_DCT_COEF);
+
+ /* Count the Huffman symbol for the number of bits */
+ dc_counts[nbits]++;
+
+ /* Encode the AC coefficients per section F.1.2.2 */
+
+ r = 0; /* r = run length of zeros */
+
+ for (k = 1; k < DCTSIZE2; k++) {
+ if ((temp = block[jpeg_natural_order[k]]) == 0) {
+ r++;
+ } else {
+ /* if run length > 15, must emit special run-length-16 codes (0xF0) */
+ while (r > 15) {
+ ac_counts[0xF0]++;
+ r -= 16;
+ }
+
+ /* Find the number of bits needed for the magnitude of the coefficient */
+ if (temp < 0)
+ temp = -temp;
+
+ /* Find the number of bits needed for the magnitude of the coefficient */
+ nbits = 1; /* there must be at least one 1 bit */
+ while ((temp >>= 1))
+ nbits++;
+ /* Check for out-of-range coefficient values */
+ if (nbits > MAX_COEF_BITS)
+ ERREXIT(cinfo, JERR_BAD_DCT_COEF);
+
+ /* Count Huffman symbol for run length / number of bits */
+ ac_counts[(r << 4) + nbits]++;
+
+ r = 0;
+ }
+ }
+
+ /* If the last coef(s) were zero, emit an end-of-block code */
+ if (r > 0)
+ ac_counts[0]++;
+}
+
+
+/*
+ * Trial-encode one MCU's worth of Huffman-compressed coefficients.
+ * No data is actually output, so no suspension return is possible.
+ */
+
+METHODDEF(boolean)
+encode_mcu_gather (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+ huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+ int blkn, ci;
+ jpeg_component_info * compptr;
+
+ /* Take care of restart intervals if needed */
+ if (cinfo->restart_interval) {
+ if (entropy->restarts_to_go == 0) {
+ /* Re-initialize DC predictions to 0 */
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++)
+ entropy->saved.last_dc_val[ci] = 0;
+ /* Update restart state */
+ entropy->restarts_to_go = cinfo->restart_interval;
+ }
+ entropy->restarts_to_go--;
+ }
+
+ for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+ ci = cinfo->MCU_membership[blkn];
+ compptr = cinfo->cur_comp_info[ci];
+ htest_one_block(cinfo, MCU_data[blkn][0], entropy->saved.last_dc_val[ci],
+ entropy->dc_count_ptrs[compptr->dc_tbl_no],
+ entropy->ac_count_ptrs[compptr->ac_tbl_no]);
+ entropy->saved.last_dc_val[ci] = MCU_data[blkn][0][0];
+ }
+
+ return TRUE;
+}
+
+
+/*
+ * Generate the best Huffman code table for the given counts, fill htbl.
+ * Note this is also used by jcphuff.c.
+ *
+ * The JPEG standard requires that no symbol be assigned a codeword of all
+ * one bits (so that padding bits added at the end of a compressed segment
+ * can't look like a valid code). Because of the canonical ordering of
+ * codewords, this just means that there must be an unused slot in the
+ * longest codeword length category. Section K.2 of the JPEG spec suggests
+ * reserving such a slot by pretending that symbol 256 is a valid symbol
+ * with count 1. In theory that's not optimal; giving it count zero but
+ * including it in the symbol set anyway should give a better Huffman code.
+ * But the theoretically better code actually seems to come out worse in
+ * practice, because it produces more all-ones bytes (which incur stuffed
+ * zero bytes in the final file). In any case the difference is tiny.
+ *
+ * The JPEG standard requires Huffman codes to be no more than 16 bits long.
+ * If some symbols have a very small but nonzero probability, the Huffman tree
+ * must be adjusted to meet the code length restriction. We currently use
+ * the adjustment method suggested in JPEG section K.2. This method is *not*
+ * optimal; it may not choose the best possible limited-length code. But
+ * typically only very-low-frequency symbols will be given less-than-optimal
+ * lengths, so the code is almost optimal. Experimental comparisons against
+ * an optimal limited-length-code algorithm indicate that the difference is
+ * microscopic --- usually less than a hundredth of a percent of total size.
+ * So the extra complexity of an optimal algorithm doesn't seem worthwhile.
+ */
+
+GLOBAL(void)
+jpeg_gen_optimal_table (j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[])
+{
+#define MAX_CLEN 32 /* assumed maximum initial code length */
+ UINT8 bits[MAX_CLEN+1]; /* bits[k] = # of symbols with code length k */
+ int codesize[257]; /* codesize[k] = code length of symbol k */
+ int others[257]; /* next symbol in current branch of tree */
+ int c1, c2;
+ int p, i, j;
+ long v;
+
+ /* This algorithm is explained in section K.2 of the JPEG standard */
+
+ MEMZERO(bits, SIZEOF(bits));
+ MEMZERO(codesize, SIZEOF(codesize));
+ for (i = 0; i < 257; i++)
+ others[i] = -1; /* init links to empty */
+
+ freq[256] = 1; /* make sure 256 has a nonzero count */
+ /* Including the pseudo-symbol 256 in the Huffman procedure guarantees
+ * that no real symbol is given code-value of all ones, because 256
+ * will be placed last in the largest codeword category.
+ */
+
+ /* Huffman's basic algorithm to assign optimal code lengths to symbols */
+
+ for (;;) {
+ /* Find the smallest nonzero frequency, set c1 = its symbol */
+ /* In case of ties, take the larger symbol number */
+ c1 = -1;
+ v = 1000000000L;
+ for (i = 0; i <= 256; i++) {
+ if (freq[i] && freq[i] <= v) {
+ v = freq[i];
+ c1 = i;
+ }
+ }
+
+ /* Find the next smallest nonzero frequency, set c2 = its symbol */
+ /* In case of ties, take the larger symbol number */
+ c2 = -1;
+ v = 1000000000L;
+ for (i = 0; i <= 256; i++) {
+ if (freq[i] && freq[i] <= v && i != c1) {
+ v = freq[i];
+ c2 = i;
+ }
+ }
+
+ /* Done if we've merged everything into one frequency */
+ if (c2 < 0)
+ break;
+
+ /* Else merge the two counts/trees */
+ freq[c1] += freq[c2];
+ freq[c2] = 0;
+
+ /* Increment the codesize of everything in c1's tree branch */
+ codesize[c1]++;
+ while (others[c1] >= 0) {
+ c1 = others[c1];
+ codesize[c1]++;
+ }
+
+ others[c1] = c2; /* chain c2 onto c1's tree branch */
+
+ /* Increment the codesize of everything in c2's tree branch */
+ codesize[c2]++;
+ while (others[c2] >= 0) {
+ c2 = others[c2];
+ codesize[c2]++;
+ }
+ }
+
+ /* Now count the number of symbols of each code length */
+ for (i = 0; i <= 256; i++) {
+ if (codesize[i]) {
+ /* The JPEG standard seems to think that this can't happen, */
+ /* but I'm paranoid... */
+ if (codesize[i] > MAX_CLEN)
+ ERREXIT(cinfo, JERR_HUFF_CLEN_OVERFLOW);
+
+ bits[codesize[i]]++;
+ }
+ }
+
+ /* JPEG doesn't allow symbols with code lengths over 16 bits, so if the pure
+ * Huffman procedure assigned any such lengths, we must adjust the coding.
+ * Here is what the JPEG spec says about how this next bit works:
+ * Since symbols are paired for the longest Huffman code, the symbols are
+ * removed from this length category two at a time. The prefix for the pair
+ * (which is one bit shorter) is allocated to one of the pair; then,
+ * skipping the BITS entry for that prefix length, a code word from the next
+ * shortest nonzero BITS entry is converted into a prefix for two code words
+ * one bit longer.
+ */
+
+ for (i = MAX_CLEN; i > 16; i--) {
+ while (bits[i] > 0) {
+ j = i - 2; /* find length of new prefix to be used */
+ while (bits[j] == 0)
+ j--;
+
+ bits[i] -= 2; /* remove two symbols */
+ bits[i-1]++; /* one goes in this length */
+ bits[j+1] += 2; /* two new symbols in this length */
+ bits[j]--; /* symbol of this length is now a prefix */
+ }
+ }
+
+ /* Remove the count for the pseudo-symbol 256 from the largest codelength */
+ while (bits[i] == 0) /* find largest codelength still in use */
+ i--;
+ bits[i]--;
+
+ /* Return final symbol counts (only for lengths 0..16) */
+ MEMCOPY(htbl->bits, bits, SIZEOF(htbl->bits));
+
+ /* Return a list of the symbols sorted by code length */
+ /* It's not real clear to me why we don't need to consider the codelength
+ * changes made above, but the JPEG spec seems to think this works.
+ */
+ p = 0;
+ for (i = 1; i <= MAX_CLEN; i++) {
+ for (j = 0; j <= 255; j++) {
+ if (codesize[j] == i) {
+ htbl->huffval[p] = (UINT8) j;
+ p++;
+ }
+ }
+ }
+
+ /* Set sent_table FALSE so updated table will be written to JPEG file. */
+ htbl->sent_table = FALSE;
+}
+
+
+/*
+ * Finish up a statistics-gathering pass and create the new Huffman tables.
+ */
+
+METHODDEF(void)
+finish_pass_gather (j_compress_ptr cinfo)
+{
+ huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+ int ci, dctbl, actbl;
+ jpeg_component_info * compptr;
+ JHUFF_TBL **htblptr;
+ boolean did_dc[NUM_HUFF_TBLS];
+ boolean did_ac[NUM_HUFF_TBLS];
+
+ /* It's important not to apply jpeg_gen_optimal_table more than once
+ * per table, because it clobbers the input frequency counts!
+ */
+ MEMZERO(did_dc, SIZEOF(did_dc));
+ MEMZERO(did_ac, SIZEOF(did_ac));
+
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ dctbl = compptr->dc_tbl_no;
+ actbl = compptr->ac_tbl_no;
+ if (! did_dc[dctbl]) {
+ htblptr = & cinfo->dc_huff_tbl_ptrs[dctbl];
+ if (*htblptr == NULL)
+ *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
+ jpeg_gen_optimal_table(cinfo, *htblptr, entropy->dc_count_ptrs[dctbl]);
+ did_dc[dctbl] = TRUE;
+ }
+ if (! did_ac[actbl]) {
+ htblptr = & cinfo->ac_huff_tbl_ptrs[actbl];
+ if (*htblptr == NULL)
+ *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
+ jpeg_gen_optimal_table(cinfo, *htblptr, entropy->ac_count_ptrs[actbl]);
+ did_ac[actbl] = TRUE;
+ }
+ }
+}
+
+
+#endif /* ENTROPY_OPT_SUPPORTED */
+
+
+/*
+ * Module initialization routine for Huffman entropy encoding.
+ */
+
+GLOBAL(void)
+jinit_huff_encoder (j_compress_ptr cinfo)
+{
+ huff_entropy_ptr entropy;
+ int i;
+
+ entropy = (huff_entropy_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(huff_entropy_encoder));
+ cinfo->entropy = (struct jpeg_entropy_encoder *) entropy;
+ entropy->pub.start_pass = start_pass_huff;
+
+ /* Mark tables unallocated */
+ for (i = 0; i < NUM_HUFF_TBLS; i++) {
+ entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL;
+#ifdef ENTROPY_OPT_SUPPORTED
+ entropy->dc_count_ptrs[i] = entropy->ac_count_ptrs[i] = NULL;
+#endif
+ }
+}
--- /dev/null
+/*
+ * jchuff.h
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * 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 declarations for Huffman entropy encoding routines
+ * that are shared between the sequential encoder (jchuff.c) and the
+ * progressive encoder (jcphuff.c). No other modules need to see these.
+ */
+
+/* The legal range of a DCT coefficient is
+ * -1024 .. +1023 for 8-bit data;
+ * -16384 .. +16383 for 12-bit data.
+ * Hence the magnitude should always fit in 10 or 14 bits respectively.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+#define MAX_COEF_BITS 10
+#else
+#define MAX_COEF_BITS 14
+#endif
+
+/* Derived data constructed for each Huffman table */
+
+typedef struct {
+ unsigned int ehufco[256]; /* code for each symbol */
+ char ehufsi[256]; /* length of code for each symbol */
+ /* If no code has been allocated for a symbol S, ehufsi[S] contains 0 */
+} c_derived_tbl;
+
+/* Short forms of external names for systems with brain-damaged linkers. */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_make_c_derived_tbl jMkCDerived
+#define jpeg_gen_optimal_table jGenOptTbl
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+/* Expand a Huffman table definition into the derived format */
+EXTERN(void) jpeg_make_c_derived_tbl
+ JPP((j_compress_ptr cinfo, boolean isDC, int tblno,
+ c_derived_tbl ** pdtbl));
+
+/* Generate an optimal table definition given the specified counts */
+EXTERN(void) jpeg_gen_optimal_table
+ JPP((j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[]));
--- /dev/null
+/*
+ * jcinit.c
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * 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 initialization logic for the JPEG compressor.
+ * This routine is in charge of selecting the modules to be executed and
+ * making an initialization call to each one.
+ *
+ * Logically, this code belongs in jcmaster.c. It's split out because
+ * linking this routine implies linking the entire compression library.
+ * For a transcoding-only application, we want to be able to use jcmaster.c
+ * without linking in the whole library.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Master selection of compression modules.
+ * This is done once at the start of processing an image. We determine
+ * which modules will be used and give them appropriate initialization calls.
+ */
+
+GLOBAL(void)
+jinit_compress_master (j_compress_ptr cinfo)
+{
+ /* Initialize master control (includes parameter checking/processing) */
+ jinit_c_master_control(cinfo, FALSE /* full compression */);
+
+ /* Preprocessing */
+ if (! cinfo->raw_data_in) {
+ jinit_color_converter(cinfo);
+ jinit_downsampler(cinfo);
+ jinit_c_prep_controller(cinfo, FALSE /* never need full buffer here */);
+ }
+ /* Forward DCT */
+ jinit_forward_dct(cinfo);
+ /* Entropy encoding: either Huffman or arithmetic coding. */
+ if (cinfo->arith_code) {
+ ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
+ } else {
+ if (cinfo->progressive_mode) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+ jinit_phuff_encoder(cinfo);
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+ } else
+ jinit_huff_encoder(cinfo);
+ }
+
+ /* Need a full-image coefficient buffer in any multi-pass mode. */
+ jinit_c_coef_controller(cinfo,
+ (boolean) (cinfo->num_scans > 1 || cinfo->optimize_coding));
+ jinit_c_main_controller(cinfo, FALSE /* never need full buffer here */);
+
+ jinit_marker_writer(cinfo);
+
+ /* We can now tell the memory manager to allocate virtual arrays. */
+ (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo);
+
+ /* Write the datastream header (SOI) immediately.
+ * Frame and scan headers are postponed till later.
+ * This lets application insert special markers after the SOI.
+ */
+ (*cinfo->marker->write_file_header) (cinfo);
+}
--- /dev/null
+/*
+ * jcmainct.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * 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 the main buffer controller for compression.
+ * The main buffer lies between the pre-processor and the JPEG
+ * compressor proper; it holds downsampled data in the JPEG colorspace.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Note: currently, there is no operating mode in which a full-image buffer
+ * is needed at this step. If there were, that mode could not be used with
+ * "raw data" input, since this module is bypassed in that case. However,
+ * we've left the code here for possible use in special applications.
+ */
+#undef FULL_MAIN_BUFFER_SUPPORTED
+
+
+/* Private buffer controller object */
+
+typedef struct {
+ struct jpeg_c_main_controller pub; /* public fields */
+
+ JDIMENSION cur_iMCU_row; /* number of current iMCU row */
+ JDIMENSION rowgroup_ctr; /* counts row groups received in iMCU row */
+ boolean suspended; /* remember if we suspended output */
+ J_BUF_MODE pass_mode; /* current operating mode */
+
+ /* If using just a strip buffer, this points to the entire set of buffers
+ * (we allocate one for each component). In the full-image case, this
+ * points to the currently accessible strips of the virtual arrays.
+ */
+ JSAMPARRAY buffer[MAX_COMPONENTS];
+
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+ /* If using full-image storage, this array holds pointers to virtual-array
+ * control blocks for each component. Unused if not full-image storage.
+ */
+ jvirt_sarray_ptr whole_image[MAX_COMPONENTS];
+#endif
+} my_main_controller;
+
+typedef my_main_controller * my_main_ptr;
+
+
+/* Forward declarations */
+METHODDEF(void) process_data_simple_main
+ JPP((j_compress_ptr cinfo, JSAMPARRAY input_buf,
+ JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail));
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+METHODDEF(void) process_data_buffer_main
+ JPP((j_compress_ptr cinfo, JSAMPARRAY input_buf,
+ JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail));
+#endif
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF(void)
+start_pass_main (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+ my_main_ptr main = (my_main_ptr) cinfo->main;
+
+ /* Do nothing in raw-data mode. */
+ if (cinfo->raw_data_in)
+ return;
+
+ main->cur_iMCU_row = 0; /* initialize counters */
+ main->rowgroup_ctr = 0;
+ main->suspended = FALSE;
+ main->pass_mode = pass_mode; /* save mode for use by process_data */
+
+ switch (pass_mode) {
+ case JBUF_PASS_THRU:
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+ if (main->whole_image[0] != NULL)
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+#endif
+ main->pub.process_data = process_data_simple_main;
+ break;
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+ case JBUF_SAVE_SOURCE:
+ case JBUF_CRANK_DEST:
+ case JBUF_SAVE_AND_PASS:
+ if (main->whole_image[0] == NULL)
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+ main->pub.process_data = process_data_buffer_main;
+ break;
+#endif
+ default:
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+ break;
+ }
+}
+
+
+/*
+ * Process some data.
+ * This routine handles the simple pass-through mode,
+ * where we have only a strip buffer.
+ */
+
+METHODDEF(void)
+process_data_simple_main (j_compress_ptr cinfo,
+ JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+ JDIMENSION in_rows_avail)
+{
+ my_main_ptr main = (my_main_ptr) cinfo->main;
+
+ while (main->cur_iMCU_row < cinfo->total_iMCU_rows) {
+ /* Read input data if we haven't filled the main buffer yet */
+ if (main->rowgroup_ctr < DCTSIZE)
+ (*cinfo->prep->pre_process_data) (cinfo,
+ input_buf, in_row_ctr, in_rows_avail,
+ main->buffer, &main->rowgroup_ctr,
+ (JDIMENSION) DCTSIZE);
+
+ /* If we don't have a full iMCU row buffered, return to application for
+ * more data. Note that preprocessor will always pad to fill the iMCU row
+ * at the bottom of the image.
+ */
+ if (main->rowgroup_ctr != DCTSIZE)
+ return;
+
+ /* Send the completed row to the compressor */
+ if (! (*cinfo->coef->compress_data) (cinfo, main->buffer)) {
+ /* If compressor did not consume the whole row, then we must need to
+ * suspend processing and return to the application. In this situation
+ * we pretend we didn't yet consume the last input row; otherwise, if
+ * it happened to be the last row of the image, the application would
+ * think we were done.
+ */
+ if (! main->suspended) {
+ (*in_row_ctr)--;
+ main->suspended = TRUE;
+ }
+ return;
+ }
+ /* We did finish the row. Undo our little suspension hack if a previous
+ * call suspended; then mark the main buffer empty.
+ */
+ if (main->suspended) {
+ (*in_row_ctr)++;
+ main->suspended = FALSE;
+ }
+ main->rowgroup_ctr = 0;
+ main->cur_iMCU_row++;
+ }
+}
+
+
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+
+/*
+ * Process some data.
+ * This routine handles all of the modes that use a full-size buffer.
+ */
+
+METHODDEF(void)
+process_data_buffer_main (j_compress_ptr cinfo,
+ JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+ JDIMENSION in_rows_avail)
+{
+ my_main_ptr main = (my_main_ptr) cinfo->main;
+ int ci;
+ jpeg_component_info *compptr;
+ boolean writing = (main->pass_mode != JBUF_CRANK_DEST);
+
+ while (main->cur_iMCU_row < cinfo->total_iMCU_rows) {
+ /* Realign the virtual buffers if at the start of an iMCU row. */
+ if (main->rowgroup_ctr == 0) {
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ main->buffer[ci] = (*cinfo->mem->access_virt_sarray)
+ ((j_common_ptr) cinfo, main->whole_image[ci],
+ main->cur_iMCU_row * (compptr->v_samp_factor * DCTSIZE),
+ (JDIMENSION) (compptr->v_samp_factor * DCTSIZE), writing);
+ }
+ /* In a read pass, pretend we just read some source data. */
+ if (! writing) {
+ *in_row_ctr += cinfo->max_v_samp_factor * DCTSIZE;
+ main->rowgroup_ctr = DCTSIZE;
+ }
+ }
+
+ /* If a write pass, read input data until the current iMCU row is full. */
+ /* Note: preprocessor will pad if necessary to fill the last iMCU row. */
+ if (writing) {
+ (*cinfo->prep->pre_process_data) (cinfo,
+ input_buf, in_row_ctr, in_rows_avail,
+ main->buffer, &main->rowgroup_ctr,
+ (JDIMENSION) DCTSIZE);
+ /* Return to application if we need more data to fill the iMCU row. */
+ if (main->rowgroup_ctr < DCTSIZE)
+ return;
+ }
+
+ /* Emit data, unless this is a sink-only pass. */
+ if (main->pass_mode != JBUF_SAVE_SOURCE) {
+ if (! (*cinfo->coef->compress_data) (cinfo, main->buffer)) {
+ /* If compressor did not consume the whole row, then we must need to
+ * suspend processing and return to the application. In this situation
+ * we pretend we didn't yet consume the last input row; otherwise, if
+ * it happened to be the last row of the image, the application would
+ * think we were done.
+ */
+ if (! main->suspended) {
+ (*in_row_ctr)--;
+ main->suspended = TRUE;
+ }
+ return;
+ }
+ /* We did finish the row. Undo our little suspension hack if a previous
+ * call suspended; then mark the main buffer empty.
+ */
+ if (main->suspended) {
+ (*in_row_ctr)++;
+ main->suspended = FALSE;
+ }
+ }
+
+ /* If get here, we are done with this iMCU row. Mark buffer empty. */
+ main->rowgroup_ctr = 0;
+ main->cur_iMCU_row++;
+ }
+}
+
+#endif /* FULL_MAIN_BUFFER_SUPPORTED */
+
+
+/*
+ * Initialize main buffer controller.
+ */
+
+GLOBAL(void)
+jinit_c_main_controller (j_compress_ptr cinfo, boolean need_full_buffer)
+{
+ my_main_ptr main;
+ int ci;
+ jpeg_component_info *compptr;
+
+ main = (my_main_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_main_controller));
+ cinfo->main = (struct jpeg_c_main_controller *) main;
+ main->pub.start_pass = start_pass_main;
+
+ /* We don't need to create a buffer in raw-data mode. */
+ if (cinfo->raw_data_in)
+ return;
+
+ /* Create the buffer. It holds downsampled data, so each component
+ * may be of a different size.
+ */
+ if (need_full_buffer) {
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+ /* Allocate a full-image virtual array for each component */
+ /* Note we pad the bottom to a multiple of the iMCU height */
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ main->whole_image[ci] = (*cinfo->mem->request_virt_sarray)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
+ compptr->width_in_blocks * DCTSIZE,
+ (JDIMENSION) jround_up((long) compptr->height_in_blocks,
+ (long) compptr->v_samp_factor) * DCTSIZE,
+ (JDIMENSION) (compptr->v_samp_factor * DCTSIZE));
+ }
+#else
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+#endif
+ } else {
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+ main->whole_image[0] = NULL; /* flag for no virtual arrays */
+#endif
+ /* Allocate a strip buffer for each component */
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ main->buffer[ci] = (*cinfo->mem->alloc_sarray)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ compptr->width_in_blocks * DCTSIZE,
+ (JDIMENSION) (compptr->v_samp_factor * DCTSIZE));
+ }
+ }
+}
--- /dev/null
+/*
+ * jcmarker.c
+ *
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * 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 routines to write JPEG datastream markers.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+typedef enum { /* JPEG marker codes */
+ M_SOF0 = 0xc0,
+ M_SOF1 = 0xc1,
+ M_SOF2 = 0xc2,
+ M_SOF3 = 0xc3,
+
+ M_SOF5 = 0xc5,
+ M_SOF6 = 0xc6,
+ M_SOF7 = 0xc7,
+
+ M_JPG = 0xc8,
+ M_SOF9 = 0xc9,
+ M_SOF10 = 0xca,
+ M_SOF11 = 0xcb,
+
+ M_SOF13 = 0xcd,
+ M_SOF14 = 0xce,
+ M_SOF15 = 0xcf,
+
+ M_DHT = 0xc4,
+
+ M_DAC = 0xcc,
+
+ M_RST0 = 0xd0,
+ M_RST1 = 0xd1,
+ M_RST2 = 0xd2,
+ M_RST3 = 0xd3,
+ M_RST4 = 0xd4,
+ M_RST5 = 0xd5,
+ M_RST6 = 0xd6,
+ M_RST7 = 0xd7,
+
+ M_SOI = 0xd8,
+ M_EOI = 0xd9,
+ M_SOS = 0xda,
+ M_DQT = 0xdb,
+ M_DNL = 0xdc,
+ M_DRI = 0xdd,
+ M_DHP = 0xde,
+ M_EXP = 0xdf,
+
+ M_APP0 = 0xe0,
+ M_APP1 = 0xe1,
+ M_APP2 = 0xe2,
+ M_APP3 = 0xe3,
+ M_APP4 = 0xe4,
+ M_APP5 = 0xe5,
+ M_APP6 = 0xe6,
+ M_APP7 = 0xe7,
+ M_APP8 = 0xe8,
+ M_APP9 = 0xe9,
+ M_APP10 = 0xea,
+ M_APP11 = 0xeb,
+ M_APP12 = 0xec,
+ M_APP13 = 0xed,
+ M_APP14 = 0xee,
+ M_APP15 = 0xef,
+
+ M_JPG0 = 0xf0,
+ M_JPG13 = 0xfd,
+ M_COM = 0xfe,
+
+ M_TEM = 0x01,
+
+ M_ERROR = 0x100
+} JPEG_MARKER;
+
+
+/* Private state */
+
+typedef struct {
+ struct jpeg_marker_writer pub; /* public fields */
+
+ unsigned int last_restart_interval; /* last DRI value emitted; 0 after SOI */
+} my_marker_writer;
+
+typedef my_marker_writer * my_marker_ptr;
+
+
+/*
+ * Basic output routines.
+ *
+ * Note that we do not support suspension while writing a marker.
+ * Therefore, an application using suspension must ensure that there is
+ * enough buffer space for the initial markers (typ. 600-700 bytes) before
+ * calling jpeg_start_compress, and enough space to write the trailing EOI
+ * (a few bytes) before calling jpeg_finish_compress. Multipass compression
+ * modes are not supported at all with suspension, so those two are the only
+ * points where markers will be written.
+ */
+
+LOCAL(void)
+emit_byte (j_compress_ptr cinfo, int val)
+/* Emit a byte */
+{
+ struct jpeg_destination_mgr * dest = cinfo->dest;
+
+ *(dest->next_output_byte)++ = (JOCTET) val;
+ if (--dest->free_in_buffer == 0) {
+ if (! (*dest->empty_output_buffer) (cinfo))
+ ERREXIT(cinfo, JERR_CANT_SUSPEND);
+ }
+}
+
+
+LOCAL(void)
+emit_marker (j_compress_ptr cinfo, JPEG_MARKER mark)
+/* Emit a marker code */
+{
+ emit_byte(cinfo, 0xFF);
+ emit_byte(cinfo, (int) mark);
+}
+
+
+LOCAL(void)
+emit_2bytes (j_compress_ptr cinfo, int value)
+/* Emit a 2-byte integer; these are always MSB first in JPEG files */
+{
+ emit_byte(cinfo, (value >> 8) & 0xFF);
+ emit_byte(cinfo, value & 0xFF);
+}
+
+
+/*
+ * Routines to write specific marker types.
+ */
+
+LOCAL(int)
+emit_dqt (j_compress_ptr cinfo, int index)
+/* Emit a DQT marker */
+/* Returns the precision used (0 = 8bits, 1 = 16bits) for baseline checking */
+{
+ JQUANT_TBL * qtbl = cinfo->quant_tbl_ptrs[index];
+ int prec;
+ int i;
+
+ if (qtbl == NULL)
+ ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, index);
+
+ prec = 0;
+ for (i = 0; i < DCTSIZE2; i++) {
+ if (qtbl->quantval[i] > 255)
+ prec = 1;
+ }
+
+ if (! qtbl->sent_table) {
+ emit_marker(cinfo, M_DQT);
+
+ emit_2bytes(cinfo, prec ? DCTSIZE2*2 + 1 + 2 : DCTSIZE2 + 1 + 2);
+
+ emit_byte(cinfo, index + (prec<<4));
+
+ for (i = 0; i < DCTSIZE2; i++) {
+ /* The table entries must be emitted in zigzag order. */
+ unsigned int qval = qtbl->quantval[jpeg_natural_order[i]];
+ if (prec)
+ emit_byte(cinfo, (int) (qval >> 8));
+ emit_byte(cinfo, (int) (qval & 0xFF));
+ }
+
+ qtbl->sent_table = TRUE;
+ }
+
+ return prec;
+}
+
+
+LOCAL(void)
+emit_dht (j_compress_ptr cinfo, int index, boolean is_ac)
+/* Emit a DHT marker */
+{
+ JHUFF_TBL * htbl;
+ int length, i;
+
+ if (is_ac) {
+ htbl = cinfo->ac_huff_tbl_ptrs[index];
+ index += 0x10; /* output index has AC bit set */
+ } else {
+ htbl = cinfo->dc_huff_tbl_ptrs[index];
+ }
+
+ if (htbl == NULL)
+ ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, index);
+
+ if (! htbl->sent_table) {
+ emit_marker(cinfo, M_DHT);
+
+ length = 0;
+ for (i = 1; i <= 16; i++)
+ length += htbl->bits[i];
+
+ emit_2bytes(cinfo, length + 2 + 1 + 16);
+ emit_byte(cinfo, index);
+
+ for (i = 1; i <= 16; i++)
+ emit_byte(cinfo, htbl->bits[i]);
+
+ for (i = 0; i < length; i++)
+ emit_byte(cinfo, htbl->huffval[i]);
+
+ htbl->sent_table = TRUE;
+ }
+}
+
+
+LOCAL(void)
+emit_dac (j_compress_ptr cinfo)
+/* Emit a DAC marker */
+/* Since the useful info is so small, we want to emit all the tables in */
+/* one DAC marker. Therefore this routine does its own scan of the table. */
+{
+#ifdef C_ARITH_CODING_SUPPORTED
+ char dc_in_use[NUM_ARITH_TBLS];
+ char ac_in_use[NUM_ARITH_TBLS];
+ int length, i;
+ jpeg_component_info *compptr;
+
+ for (i = 0; i < NUM_ARITH_TBLS; i++)
+ dc_in_use[i] = ac_in_use[i] = 0;
+
+ for (i = 0; i < cinfo->comps_in_scan; i++) {
+ compptr = cinfo->cur_comp_info[i];
+ dc_in_use[compptr->dc_tbl_no] = 1;
+ ac_in_use[compptr->ac_tbl_no] = 1;
+ }
+
+ length = 0;
+ for (i = 0; i < NUM_ARITH_TBLS; i++)
+ length += dc_in_use[i] + ac_in_use[i];
+
+ emit_marker(cinfo, M_DAC);
+
+ emit_2bytes(cinfo, length*2 + 2);
+
+ for (i = 0; i < NUM_ARITH_TBLS; i++) {
+ if (dc_in_use[i]) {
+ emit_byte(cinfo, i);
+ emit_byte(cinfo, cinfo->arith_dc_L[i] + (cinfo->arith_dc_U[i]<<4));
+ }
+ if (ac_in_use[i]) {
+ emit_byte(cinfo, i + 0x10);
+ emit_byte(cinfo, cinfo->arith_ac_K[i]);
+ }
+ }
+#endif /* C_ARITH_CODING_SUPPORTED */
+}
+
+
+LOCAL(void)
+emit_dri (j_compress_ptr cinfo)
+/* Emit a DRI marker */
+{
+ emit_marker(cinfo, M_DRI);
+
+ emit_2bytes(cinfo, 4); /* fixed length */
+
+ emit_2bytes(cinfo, (int) cinfo->restart_interval);
+}
+
+
+LOCAL(void)
+emit_sof (j_compress_ptr cinfo, JPEG_MARKER code)
+/* Emit a SOF marker */
+{
+ int ci;
+ jpeg_component_info *compptr;
+
+ emit_marker(cinfo, code);
+
+ emit_2bytes(cinfo, 3 * cinfo->num_components + 2 + 5 + 1); /* length */
+
+ /* Make sure image isn't bigger than SOF field can handle */
+ if ((long) cinfo->image_height > 65535L ||
+ (long) cinfo->image_width > 65535L)
+ ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) 65535);
+
+ emit_byte(cinfo, cinfo->data_precision);
+ emit_2bytes(cinfo, (int) cinfo->image_height);
+ emit_2bytes(cinfo, (int) cinfo->image_width);
+
+ emit_byte(cinfo, cinfo->num_components);
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ emit_byte(cinfo, compptr->component_id);
+ emit_byte(cinfo, (compptr->h_samp_factor << 4) + compptr->v_samp_factor);
+ emit_byte(cinfo, compptr->quant_tbl_no);
+ }
+}
+
+
+LOCAL(void)
+emit_sos (j_compress_ptr cinfo)
+/* Emit a SOS marker */
+{
+ int i, td, ta;
+ jpeg_component_info *compptr;
+
+ emit_marker(cinfo, M_SOS);
+
+ emit_2bytes(cinfo, 2 * cinfo->comps_in_scan + 2 + 1 + 3); /* length */
+
+ emit_byte(cinfo, cinfo->comps_in_scan);
+
+ for (i = 0; i < cinfo->comps_in_scan; i++) {
+ compptr = cinfo->cur_comp_info[i];
+ emit_byte(cinfo, compptr->component_id);
+ td = compptr->dc_tbl_no;
+ ta = compptr->ac_tbl_no;
+ if (cinfo->progressive_mode) {
+ /* Progressive mode: only DC or only AC tables are used in one scan;
+ * furthermore, Huffman coding of DC refinement uses no table at all.
+ * We emit 0 for unused field(s); this is recommended by the P&M text
+ * but does not seem to be specified in the standard.
+ */
+ if (cinfo->Ss == 0) {
+ ta = 0; /* DC scan */
+ if (cinfo->Ah != 0 && !cinfo->arith_code)
+ td = 0; /* no DC table either */
+ } else {
+ td = 0; /* AC scan */
+ }
+ }
+ emit_byte(cinfo, (td << 4) + ta);
+ }
+
+ emit_byte(cinfo, cinfo->Ss);
+ emit_byte(cinfo, cinfo->Se);
+ emit_byte(cinfo, (cinfo->Ah << 4) + cinfo->Al);
+}
+
+
+LOCAL(void)
+emit_jfif_app0 (j_compress_ptr cinfo)
+/* Emit a JFIF-compliant APP0 marker */
+{
+ /*
+ * Length of APP0 block (2 bytes)
+ * Block ID (4 bytes - ASCII "JFIF")
+ * Zero byte (1 byte to terminate the ID string)
+ * Version Major, Minor (2 bytes - major first)
+ * Units (1 byte - 0x00 = none, 0x01 = inch, 0x02 = cm)
+ * Xdpu (2 bytes - dots per unit horizontal)
+ * Ydpu (2 bytes - dots per unit vertical)
+ * Thumbnail X size (1 byte)
+ * Thumbnail Y size (1 byte)
+ */
+
+ emit_marker(cinfo, M_APP0);
+
+ emit_2bytes(cinfo, 2 + 4 + 1 + 2 + 1 + 2 + 2 + 1 + 1); /* length */
+
+ emit_byte(cinfo, 0x4A); /* Identifier: ASCII "JFIF" */
+ emit_byte(cinfo, 0x46);
+ emit_byte(cinfo, 0x49);
+ emit_byte(cinfo, 0x46);
+ emit_byte(cinfo, 0);
+ emit_byte(cinfo, cinfo->JFIF_major_version); /* Version fields */
+ emit_byte(cinfo, cinfo->JFIF_minor_version);
+ emit_byte(cinfo, cinfo->density_unit); /* Pixel size information */
+ emit_2bytes(cinfo, (int) cinfo->X_density);
+ emit_2bytes(cinfo, (int) cinfo->Y_density);
+ emit_byte(cinfo, 0); /* No thumbnail image */
+ emit_byte(cinfo, 0);
+}
+
+
+LOCAL(void)
+emit_adobe_app14 (j_compress_ptr cinfo)
+/* Emit an Adobe APP14 marker */
+{
+ /*
+ * Length of APP14 block (2 bytes)
+ * Block ID (5 bytes - ASCII "Adobe")
+ * Version Number (2 bytes - currently 100)
+ * Flags0 (2 bytes - currently 0)
+ * Flags1 (2 bytes - currently 0)
+ * Color transform (1 byte)
+ *
+ * Although Adobe TN 5116 mentions Version = 101, all the Adobe files
+ * now in circulation seem to use Version = 100, so that's what we write.
+ *
+ * We write the color transform byte as 1 if the JPEG color space is
+ * YCbCr, 2 if it's YCCK, 0 otherwise. Adobe's definition has to do with
+ * whether the encoder performed a transformation, which is pretty useless.
+ */
+
+ emit_marker(cinfo, M_APP14);
+
+ emit_2bytes(cinfo, 2 + 5 + 2 + 2 + 2 + 1); /* length */
+
+ emit_byte(cinfo, 0x41); /* Identifier: ASCII "Adobe" */
+ emit_byte(cinfo, 0x64);
+ emit_byte(cinfo, 0x6F);
+ emit_byte(cinfo, 0x62);
+ emit_byte(cinfo, 0x65);
+ emit_2bytes(cinfo, 100); /* Version */
+ emit_2bytes(cinfo, 0); /* Flags0 */
+ emit_2bytes(cinfo, 0); /* Flags1 */
+ switch (cinfo->jpeg_color_space) {
+ case JCS_YCbCr:
+ emit_byte(cinfo, 1); /* Color transform = 1 */
+ break;
+ case JCS_YCCK:
+ emit_byte(cinfo, 2); /* Color transform = 2 */
+ break;
+ default:
+ emit_byte(cinfo, 0); /* Color transform = 0 */
+ break;
+ }
+}
+
+
+/*
+ * These routines allow writing an arbitrary marker with parameters.
+ * The only intended use is to emit COM or APPn markers after calling
+ * write_file_header and before calling write_frame_header.
+ * Other uses are not guaranteed to produce desirable results.
+ * Counting the parameter bytes properly is the caller's responsibility.
+ */
+
+METHODDEF(void)
+write_marker_header (j_compress_ptr cinfo, int marker, unsigned int datalen)
+/* Emit an arbitrary marker header */
+{
+ if (datalen > (unsigned int) 65533) /* safety check */
+ ERREXIT(cinfo, JERR_BAD_LENGTH);
+
+ emit_marker(cinfo, (JPEG_MARKER) marker);
+
+ emit_2bytes(cinfo, (int) (datalen + 2)); /* total length */
+}
+
+METHODDEF(void)
+write_marker_byte (j_compress_ptr cinfo, int val)
+/* Emit one byte of marker parameters following write_marker_header */
+{
+ emit_byte(cinfo, val);
+}
+
+
+/*
+ * Write datastream header.
+ * This consists of an SOI and optional APPn markers.
+ * We recommend use of the JFIF marker, but not the Adobe marker,
+ * when using YCbCr or grayscale data. The JFIF marker should NOT
+ * be used for any other JPEG colorspace. The Adobe marker is helpful
+ * to distinguish RGB, CMYK, and YCCK colorspaces.
+ * Note that an application can write additional header markers after
+ * jpeg_start_compress returns.
+ */
+
+METHODDEF(void)
+write_file_header (j_compress_ptr cinfo)
+{
+ my_marker_ptr marker = (my_marker_ptr) cinfo->marker;
+
+ emit_marker(cinfo, M_SOI); /* first the SOI */
+
+ /* SOI is defined to reset restart interval to 0 */
+ marker->last_restart_interval = 0;
+
+ if (cinfo->write_JFIF_header) /* next an optional JFIF APP0 */
+ emit_jfif_app0(cinfo);
+ if (cinfo->write_Adobe_marker) /* next an optional Adobe APP14 */
+ emit_adobe_app14(cinfo);
+}
+
+
+/*
+ * Write frame header.
+ * This consists of DQT and SOFn markers.
+ * Note that we do not emit the SOF until we have emitted the DQT(s).
+ * This avoids compatibility problems with incorrect implementations that
+ * try to error-check the quant table numbers as soon as they see the SOF.
+ */
+
+METHODDEF(void)
+write_frame_header (j_compress_ptr cinfo)
+{
+ int ci, prec;
+ boolean is_baseline;
+ jpeg_component_info *compptr;
+
+ /* Emit DQT for each quantization table.
+ * Note that emit_dqt() suppresses any duplicate tables.
+ */
+ prec = 0;
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ prec += emit_dqt(cinfo, compptr->quant_tbl_no);
+ }
+ /* now prec is nonzero iff there are any 16-bit quant tables. */
+
+ /* Check for a non-baseline specification.
+ * Note we assume that Huffman table numbers won't be changed later.
+ */
+ if (cinfo->arith_code || cinfo->progressive_mode ||
+ cinfo->data_precision != 8) {
+ is_baseline = FALSE;
+ } else {
+ is_baseline = TRUE;
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ if (compptr->dc_tbl_no > 1 || compptr->ac_tbl_no > 1)
+ is_baseline = FALSE;
+ }
+ if (prec && is_baseline) {
+ is_baseline = FALSE;
+ /* If it's baseline except for quantizer size, warn the user */
+ TRACEMS(cinfo, 0, JTRC_16BIT_TABLES);
+ }
+ }
+
+ /* Emit the proper SOF marker */
+ if (cinfo->arith_code) {
+ emit_sof(cinfo, M_SOF9); /* SOF code for arithmetic coding */
+ } else {
+ if (cinfo->progressive_mode)
+ emit_sof(cinfo, M_SOF2); /* SOF code for progressive Huffman */
+ else if (is_baseline)
+ emit_sof(cinfo, M_SOF0); /* SOF code for baseline implementation */
+ else
+ emit_sof(cinfo, M_SOF1); /* SOF code for non-baseline Huffman file */
+ }
+}
+
+
+/*
+ * Write scan header.
+ * This consists of DHT or DAC markers, optional DRI, and SOS.
+ * Compressed data will be written following the SOS.
+ */
+
+METHODDEF(void)
+write_scan_header (j_compress_ptr cinfo)
+{
+ my_marker_ptr marker = (my_marker_ptr) cinfo->marker;
+ int i;
+ jpeg_component_info *compptr;
+
+ if (cinfo->arith_code) {
+ /* Emit arith conditioning info. We may have some duplication
+ * if the file has multiple scans, but it's so small it's hardly
+ * worth worrying about.
+ */
+ emit_dac(cinfo);
+ } else {
+ /* Emit Huffman tables.
+ * Note that emit_dht() suppresses any duplicate tables.
+ */
+ for (i = 0; i < cinfo->comps_in_scan; i++) {
+ compptr = cinfo->cur_comp_info[i];
+ if (cinfo->progressive_mode) {
+ /* Progressive mode: only DC or only AC tables are used in one scan */
+ if (cinfo->Ss == 0) {
+ if (cinfo->Ah == 0) /* DC needs no table for refinement scan */
+ emit_dht(cinfo, compptr->dc_tbl_no, FALSE);
+ } else {
+ emit_dht(cinfo, compptr->ac_tbl_no, TRUE);
+ }
+ } else {
+ /* Sequential mode: need both DC and AC tables */
+ emit_dht(cinfo, compptr->dc_tbl_no, FALSE);
+ emit_dht(cinfo, compptr->ac_tbl_no, TRUE);
+ }
+ }
+ }
+
+ /* Emit DRI if required --- note that DRI value could change for each scan.
+ * We avoid wasting space with unnecessary DRIs, however.
+ */
+ if (cinfo->restart_interval != marker->last_restart_interval) {
+ emit_dri(cinfo);
+ marker->last_restart_interval = cinfo->restart_interval;
+ }
+
+ emit_sos(cinfo);
+}
+
+
+/*
+ * Write datastream trailer.
+ */
+
+METHODDEF(void)
+write_file_trailer (j_compress_ptr cinfo)
+{
+ emit_marker(cinfo, M_EOI);
+}
+
+
+/*
+ * Write an abbreviated table-specification datastream.
+ * This consists of SOI, DQT and DHT tables, and EOI.
+ * Any table that is defined and not marked sent_table = TRUE will be
+ * emitted. Note that all tables will be marked sent_table = TRUE at exit.
+ */
+
+METHODDEF(void)
+write_tables_only (j_compress_ptr cinfo)
+{
+ int i;
+
+ emit_marker(cinfo, M_SOI);
+
+ for (i = 0; i < NUM_QUANT_TBLS; i++) {
+ if (cinfo->quant_tbl_ptrs[i] != NULL)
+ (void) emit_dqt(cinfo, i);
+ }
+
+ if (! cinfo->arith_code) {
+ for (i = 0; i < NUM_HUFF_TBLS; i++) {
+ if (cinfo->dc_huff_tbl_ptrs[i] != NULL)
+ emit_dht(cinfo, i, FALSE);
+ if (cinfo->ac_huff_tbl_ptrs[i] != NULL)
+ emit_dht(cinfo, i, TRUE);
+ }
+ }
+
+ emit_marker(cinfo, M_EOI);
+}
+
+
+/*
+ * Initialize the marker writer module.
+ */
+
+GLOBAL(void)
+jinit_marker_writer (j_compress_ptr cinfo)
+{
+ my_marker_ptr marker;
+
+ /* Create the subobject */
+ marker = (my_marker_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_marker_writer));
+ cinfo->marker = (struct jpeg_marker_writer *) marker;
+ /* Initialize method pointers */
+ marker->pub.write_file_header = write_file_header;
+ marker->pub.write_frame_header = write_frame_header;
+ marker->pub.write_scan_header = write_scan_header;
+ marker->pub.write_file_trailer = write_file_trailer;
+ marker->pub.write_tables_only = write_tables_only;
+ marker->pub.write_marker_header = write_marker_header;
+ marker->pub.write_marker_byte = write_marker_byte;
+ /* Initialize private state */
+ marker->last_restart_interval = 0;
+}
--- /dev/null
+/*
+ * jcmaster.c
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * 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 master control logic for the JPEG compressor.
+ * These routines are concerned with parameter validation, initial setup,
+ * and inter-pass control (determining the number of passes and the work
+ * to be done in each pass).
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private state */
+
+typedef enum {
+ main_pass, /* input data, also do first output step */
+ huff_opt_pass, /* Huffman code optimization pass */
+ output_pass /* data output pass */
+} c_pass_type;
+
+typedef struct {
+ struct jpeg_comp_master pub; /* public fields */
+
+ c_pass_type pass_type; /* the type of the current pass */
+
+ int pass_number; /* # of passes completed */
+ int total_passes; /* total # of passes needed */
+
+ int scan_number; /* current index in scan_info[] */
+} my_comp_master;
+
+typedef my_comp_master * my_master_ptr;
+
+
+/*
+ * Support routines that do various essential calculations.
+ */
+
+LOCAL(void)
+initial_setup (j_compress_ptr cinfo)
+/* Do computations that are needed before master selection phase */
+{
+ int ci;
+ jpeg_component_info *compptr;
+ long samplesperrow;
+ JDIMENSION jd_samplesperrow;
+
+ /* Sanity check on image dimensions */
+ if (cinfo->image_height <= 0 || cinfo->image_width <= 0
+ || cinfo->num_components <= 0 || cinfo->input_components <= 0)
+ ERREXIT(cinfo, JERR_EMPTY_IMAGE);
+
+ /* Make sure image isn't bigger than I can handle */
+ if ((long) cinfo->image_height > (long) JPEG_MAX_DIMENSION ||
+ (long) cinfo->image_width > (long) JPEG_MAX_DIMENSION)
+ ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) JPEG_MAX_DIMENSION);
+
+ /* Width of an input scanline must be representable as JDIMENSION. */
+ samplesperrow = (long) cinfo->image_width * (long) cinfo->input_components;
+ jd_samplesperrow = (JDIMENSION) samplesperrow;
+ if ((long) jd_samplesperrow != samplesperrow)
+ ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
+
+ /* For now, precision must match compiled-in value... */
+ if (cinfo->data_precision != BITS_IN_JSAMPLE)
+ ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
+
+ /* Check that number of components won't exceed internal array sizes */
+ if (cinfo->num_components > MAX_COMPONENTS)
+ ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
+ MAX_COMPONENTS);
+
+ /* Compute maximum sampling factors; check factor validity */
+ cinfo->max_h_samp_factor = 1;
+ cinfo->max_v_samp_factor = 1;
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ if (compptr->h_samp_factor<=0 || compptr->h_samp_factor>MAX_SAMP_FACTOR ||
+ compptr->v_samp_factor<=0 || compptr->v_samp_factor>MAX_SAMP_FACTOR)
+ ERREXIT(cinfo, JERR_BAD_SAMPLING);
+ cinfo->max_h_samp_factor = MAX(cinfo->max_h_samp_factor,
+ compptr->h_samp_factor);
+ cinfo->max_v_samp_factor = MAX(cinfo->max_v_samp_factor,
+ compptr->v_samp_factor);
+ }
+
+ /* Compute dimensions of components */
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ /* Fill in the correct component_index value; don't rely on application */
+ compptr->component_index = ci;
+ /* For compression, we never do DCT scaling. */
+ compptr->DCT_scaled_size = DCTSIZE;
+ /* Size in DCT blocks */
+ compptr->width_in_blocks = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,
+ (long) (cinfo->max_h_samp_factor * DCTSIZE));
+ compptr->height_in_blocks = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,
+ (long) (cinfo->max_v_samp_factor * DCTSIZE));
+ /* Size in samples */
+ compptr->downsampled_width = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,
+ (long) cinfo->max_h_samp_factor);
+ compptr->downsampled_height = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,
+ (long) cinfo->max_v_samp_factor);
+ /* Mark component needed (this flag isn't actually used for compression) */
+ compptr->component_needed = TRUE;
+ }
+
+ /* Compute number of fully interleaved MCU rows (number of times that
+ * main controller will call coefficient controller).
+ */
+ cinfo->total_iMCU_rows = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_height,
+ (long) (cinfo->max_v_samp_factor*DCTSIZE));
+}
+
+
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+
+LOCAL(void)
+validate_script (j_compress_ptr cinfo)
+/* Verify that the scan script in cinfo->scan_info[] is valid; also
+ * determine whether it uses progressive JPEG, and set cinfo->progressive_mode.
+ */
+{
+ const jpeg_scan_info * scanptr;
+ int scanno, ncomps, ci, coefi, thisi;
+ int Ss, Se, Ah, Al;
+ boolean component_sent[MAX_COMPONENTS];
+#ifdef C_PROGRESSIVE_SUPPORTED
+ int * last_bitpos_ptr;
+ int last_bitpos[MAX_COMPONENTS][DCTSIZE2];
+ /* -1 until that coefficient has been seen; then last Al for it */
+#endif
+
+ if (cinfo->num_scans <= 0)
+ ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, 0);
+
+ /* For sequential JPEG, all scans must have Ss=0, Se=DCTSIZE2-1;
+ * for progressive JPEG, no scan can have this.
+ */
+ scanptr = cinfo->scan_info;
+ if (scanptr->Ss != 0 || scanptr->Se != DCTSIZE2-1) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+ cinfo->progressive_mode = TRUE;
+ last_bitpos_ptr = & last_bitpos[0][0];
+ for (ci = 0; ci < cinfo->num_components; ci++)
+ for (coefi = 0; coefi < DCTSIZE2; coefi++)
+ *last_bitpos_ptr++ = -1;
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+ } else {
+ cinfo->progressive_mode = FALSE;
+ for (ci = 0; ci < cinfo->num_components; ci++)
+ component_sent[ci] = FALSE;
+ }
+
+ for (scanno = 1; scanno <= cinfo->num_scans; scanptr++, scanno++) {
+ /* Validate component indexes */
+ ncomps = scanptr->comps_in_scan;
+ if (ncomps <= 0 || ncomps > MAX_COMPS_IN_SCAN)
+ ERREXIT2(cinfo, JERR_COMPONENT_COUNT, ncomps, MAX_COMPS_IN_SCAN);
+ for (ci = 0; ci < ncomps; ci++) {
+ thisi = scanptr->component_index[ci];
+ if (thisi < 0 || thisi >= cinfo->num_components)
+ ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno);
+ /* Components must appear in SOF order within each scan */
+ if (ci > 0 && thisi <= scanptr->component_index[ci-1])
+ ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno);
+ }
+ /* Validate progression parameters */
+ Ss = scanptr->Ss;
+ Se = scanptr->Se;
+ Ah = scanptr->Ah;
+ Al = scanptr->Al;
+ if (cinfo->progressive_mode) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+ /* The JPEG spec simply gives the ranges 0..13 for Ah and Al, but that
+ * seems wrong: the upper bound ought to depend on data precision.
+ * Perhaps they really meant 0..N+1 for N-bit precision.
+ * Here we allow 0..10 for 8-bit data; Al larger than 10 results in
+ * out-of-range reconstructed DC values during the first DC scan,
+ * which might cause problems for some decoders.
+ */
+#if BITS_IN_JSAMPLE == 8
+#define MAX_AH_AL 10
+#else
+#define MAX_AH_AL 13
+#endif
+ if (Ss < 0 || Ss >= DCTSIZE2 || Se < Ss || Se >= DCTSIZE2 ||
+ Ah < 0 || Ah > MAX_AH_AL || Al < 0 || Al > MAX_AH_AL)
+ ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+ if (Ss == 0) {
+ if (Se != 0) /* DC and AC together not OK */
+ ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+ } else {
+ if (ncomps != 1) /* AC scans must be for only one component */
+ ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+ }
+ for (ci = 0; ci < ncomps; ci++) {
+ last_bitpos_ptr = & last_bitpos[scanptr->component_index[ci]][0];
+ if (Ss != 0 && last_bitpos_ptr[0] < 0) /* AC without prior DC scan */
+ ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+ for (coefi = Ss; coefi <= Se; coefi++) {
+ if (last_bitpos_ptr[coefi] < 0) {
+ /* first scan of this coefficient */
+ if (Ah != 0)
+ ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+ } else {
+ /* not first scan */
+ if (Ah != last_bitpos_ptr[coefi] || Al != Ah-1)
+ ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+ }
+ last_bitpos_ptr[coefi] = Al;
+ }
+ }
+#endif
+ } else {
+ /* For sequential JPEG, all progression parameters must be these: */
+ if (Ss != 0 || Se != DCTSIZE2-1 || Ah != 0 || Al != 0)
+ ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+ /* Make sure components are not sent twice */
+ for (ci = 0; ci < ncomps; ci++) {
+ thisi = scanptr->component_index[ci];
+ if (component_sent[thisi])
+ ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno);
+ component_sent[thisi] = TRUE;
+ }
+ }
+ }
+
+ /* Now verify that everything got sent. */
+ if (cinfo->progressive_mode) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+ /* For progressive mode, we only check that at least some DC data
+ * got sent for each component; the spec does not require that all bits
+ * of all coefficients be transmitted. Would it be wiser to enforce
+ * transmission of all coefficient bits??
+ */
+ for (ci = 0; ci < cinfo->num_components; ci++) {
+ if (last_bitpos[ci][0] < 0)
+ ERREXIT(cinfo, JERR_MISSING_DATA);
+ }
+#endif
+ } else {
+ for (ci = 0; ci < cinfo->num_components; ci++) {
+ if (! component_sent[ci])
+ ERREXIT(cinfo, JERR_MISSING_DATA);
+ }
+ }
+}
+
+#endif /* C_MULTISCAN_FILES_SUPPORTED */
+
+
+LOCAL(void)
+select_scan_parameters (j_compress_ptr cinfo)
+/* Set up the scan parameters for the current scan */
+{
+ int ci;
+
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+ if (cinfo->scan_info != NULL) {
+ /* Prepare for current scan --- the script is already validated */
+ my_master_ptr master = (my_master_ptr) cinfo->master;
+ const jpeg_scan_info * scanptr = cinfo->scan_info + master->scan_number;
+
+ cinfo->comps_in_scan = scanptr->comps_in_scan;
+ for (ci = 0; ci < scanptr->comps_in_scan; ci++) {
+ cinfo->cur_comp_info[ci] =
+ &cinfo->comp_info[scanptr->component_index[ci]];
+ }
+ cinfo->Ss = scanptr->Ss;
+ cinfo->Se = scanptr->Se;
+ cinfo->Ah = scanptr->Ah;
+ cinfo->Al = scanptr->Al;
+ }
+ else
+#endif
+ {
+ /* Prepare for single sequential-JPEG scan containing all components */
+ if (cinfo->num_components > MAX_COMPS_IN_SCAN)
+ ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
+ MAX_COMPS_IN_SCAN);
+ cinfo->comps_in_scan = cinfo->num_components;
+ for (ci = 0; ci < cinfo->num_components; ci++) {
+ cinfo->cur_comp_info[ci] = &cinfo->comp_info[ci];
+ }
+ cinfo->Ss = 0;
+ cinfo->Se = DCTSIZE2-1;
+ cinfo->Ah = 0;
+ cinfo->Al = 0;
+ }
+}
+
+
+LOCAL(void)
+per_scan_setup (j_compress_ptr cinfo)
+/* Do computations that are needed before processing a JPEG scan */
+/* cinfo->comps_in_scan and cinfo->cur_comp_info[] are already set */
+{
+ int ci, mcublks, tmp;
+ jpeg_component_info *compptr;
+
+ if (cinfo->comps_in_scan == 1) {
+
+ /* Noninterleaved (single-component) scan */
+ compptr = cinfo->cur_comp_info[0];
+
+ /* Overall image size in MCUs */
+ cinfo->MCUs_per_row = compptr->width_in_blocks;
+ cinfo->MCU_rows_in_scan = compptr->height_in_blocks;
+
+ /* For noninterleaved scan, always one block per MCU */
+ compptr->MCU_width = 1;
+ compptr->MCU_height = 1;
+ compptr->MCU_blocks = 1;
+ compptr->MCU_sample_width = DCTSIZE;
+ compptr->last_col_width = 1;
+ /* For noninterleaved scans, it is convenient to define last_row_height
+ * as the number of block rows present in the last iMCU row.
+ */
+ tmp = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
+ if (tmp == 0) tmp = compptr->v_samp_factor;
+ compptr->last_row_height = tmp;
+
+ /* Prepare array describing MCU composition */
+ cinfo->blocks_in_MCU = 1;
+ cinfo->MCU_membership[0] = 0;
+
+ } else {
+
+ /* Interleaved (multi-component) scan */
+ if (cinfo->comps_in_scan <= 0 || cinfo->comps_in_scan > MAX_COMPS_IN_SCAN)
+ ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->comps_in_scan,
+ MAX_COMPS_IN_SCAN);
+
+ /* Overall image size in MCUs */
+ cinfo->MCUs_per_row = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_width,
+ (long) (cinfo->max_h_samp_factor*DCTSIZE));
+ cinfo->MCU_rows_in_scan = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_height,
+ (long) (cinfo->max_v_samp_factor*DCTSIZE));
+
+ cinfo->blocks_in_MCU = 0;
+
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ /* Sampling factors give # of blocks of component in each MCU */
+ compptr->MCU_width = compptr->h_samp_factor;
+ compptr->MCU_height = compptr->v_samp_factor;
+ compptr->MCU_blocks = compptr->MCU_width * compptr->MCU_height;
+ compptr->MCU_sample_width = compptr->MCU_width * DCTSIZE;
+ /* Figure number of non-dummy blocks in last MCU column & row */
+ tmp = (int) (compptr->width_in_blocks % compptr->MCU_width);
+ if (tmp == 0) tmp = compptr->MCU_width;
+ compptr->last_col_width = tmp;
+ tmp = (int) (compptr->height_in_blocks % compptr->MCU_height);
+ if (tmp == 0) tmp = compptr->MCU_height;
+ compptr->last_row_height = tmp;
+ /* Prepare array describing MCU composition */
+ mcublks = compptr->MCU_blocks;
+ if (cinfo->blocks_in_MCU + mcublks > C_MAX_BLOCKS_IN_MCU)
+ ERREXIT(cinfo, JERR_BAD_MCU_SIZE);
+ while (mcublks-- > 0) {
+ cinfo->MCU_membership[cinfo->blocks_in_MCU++] = ci;
+ }
+ }
+
+ }
+
+ /* Convert restart specified in rows to actual MCU count. */
+ /* Note that count must fit in 16 bits, so we provide limiting. */
+ if (cinfo->restart_in_rows > 0) {
+ long nominal = (long) cinfo->restart_in_rows * (long) cinfo->MCUs_per_row;
+ cinfo->restart_interval = (unsigned int) MIN(nominal, 65535L);
+ }
+}
+
+
+/*
+ * Per-pass setup.
+ * This is called at the beginning of each pass. We determine which modules
+ * will be active during this pass and give them appropriate start_pass calls.
+ * We also set is_last_pass to indicate whether any more passes will be
+ * required.
+ */
+
+METHODDEF(void)
+prepare_for_pass (j_compress_ptr cinfo)
+{
+ my_master_ptr master = (my_master_ptr) cinfo->master;
+
+ switch (master->pass_type) {
+ case main_pass:
+ /* Initial pass: will collect input data, and do either Huffman
+ * optimization or data output for the first scan.
+ */
+ select_scan_parameters(cinfo);
+ per_scan_setup(cinfo);
+ if (! cinfo->raw_data_in) {
+ (*cinfo->cconvert->start_pass) (cinfo);
+ (*cinfo->downsample->start_pass) (cinfo);
+ (*cinfo->prep->start_pass) (cinfo, JBUF_PASS_THRU);
+ }
+ (*cinfo->fdct->start_pass) (cinfo);
+ (*cinfo->entropy->start_pass) (cinfo, cinfo->optimize_coding);
+ (*cinfo->coef->start_pass) (cinfo,
+ (master->total_passes > 1 ?
+ JBUF_SAVE_AND_PASS : JBUF_PASS_THRU));
+ (*cinfo->main->start_pass) (cinfo, JBUF_PASS_THRU);
+ if (cinfo->optimize_coding) {
+ /* No immediate data output; postpone writing frame/scan headers */
+ master->pub.call_pass_startup = FALSE;
+ } else {
+ /* Will write frame/scan headers at first jpeg_write_scanlines call */
+ master->pub.call_pass_startup = TRUE;
+ }
+ break;
+#ifdef ENTROPY_OPT_SUPPORTED
+ case huff_opt_pass:
+ /* Do Huffman optimization for a scan after the first one. */
+ select_scan_parameters(cinfo);
+ per_scan_setup(cinfo);
+ if (cinfo->Ss != 0 || cinfo->Ah == 0 || cinfo->arith_code) {
+ (*cinfo->entropy->start_pass) (cinfo, TRUE);
+ (*cinfo->coef->start_pass) (cinfo, JBUF_CRANK_DEST);
+ master->pub.call_pass_startup = FALSE;
+ break;
+ }
+ /* Special case: Huffman DC refinement scans need no Huffman table
+ * and therefore we can skip the optimization pass for them.
+ */
+ master->pass_type = output_pass;
+ master->pass_number++;
+ /*FALLTHROUGH*/
+#endif
+ case output_pass:
+ /* Do a data-output pass. */
+ /* We need not repeat per-scan setup if prior optimization pass did it. */
+ if (! cinfo->optimize_coding) {
+ select_scan_parameters(cinfo);
+ per_scan_setup(cinfo);
+ }
+ (*cinfo->entropy->start_pass) (cinfo, FALSE);
+ (*cinfo->coef->start_pass) (cinfo, JBUF_CRANK_DEST);
+ /* We emit frame/scan headers now */
+ if (master->scan_number == 0)
+ (*cinfo->marker->write_frame_header) (cinfo);
+ (*cinfo->marker->write_scan_header) (cinfo);
+ master->pub.call_pass_startup = FALSE;
+ break;
+ default:
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+ }
+
+ master->pub.is_last_pass = (master->pass_number == master->total_passes-1);
+
+ /* Set up progress monitor's pass info if present */
+ if (cinfo->progress != NULL) {
+ cinfo->progress->completed_passes = master->pass_number;
+ cinfo->progress->total_passes = master->total_passes;
+ }
+}
+
+
+/*
+ * Special start-of-pass hook.
+ * This is called by jpeg_write_scanlines if call_pass_startup is TRUE.
+ * In single-pass processing, we need this hook because we don't want to
+ * write frame/scan headers during jpeg_start_compress; we want to let the
+ * application write COM markers etc. between jpeg_start_compress and the
+ * jpeg_write_scanlines loop.
+ * In multi-pass processing, this routine is not used.
+ */
+
+METHODDEF(void)
+pass_startup (j_compress_ptr cinfo)
+{
+ cinfo->master->call_pass_startup = FALSE; /* reset flag so call only once */
+
+ (*cinfo->marker->write_frame_header) (cinfo);
+ (*cinfo->marker->write_scan_header) (cinfo);
+}
+
+
+/*
+ * Finish up at end of pass.
+ */
+
+METHODDEF(void)
+finish_pass_master (j_compress_ptr cinfo)
+{
+ my_master_ptr master = (my_master_ptr) cinfo->master;
+
+ /* The entropy coder always needs an end-of-pass call,
+ * either to analyze statistics or to flush its output buffer.
+ */
+ (*cinfo->entropy->finish_pass) (cinfo);
+
+ /* Update state for next pass */
+ switch (master->pass_type) {
+ case main_pass:
+ /* next pass is either output of scan 0 (after optimization)
+ * or output of scan 1 (if no optimization).
+ */
+ master->pass_type = output_pass;
+ if (! cinfo->optimize_coding)
+ master->scan_number++;
+ break;
+ case huff_opt_pass:
+ /* next pass is always output of current scan */
+ master->pass_type = output_pass;
+ break;
+ case output_pass:
+ /* next pass is either optimization or output of next scan */
+ if (cinfo->optimize_coding)
+ master->pass_type = huff_opt_pass;
+ master->scan_number++;
+ break;
+ }
+
+ master->pass_number++;
+}
+
+
+/*
+ * Initialize master compression control.
+ */
+
+GLOBAL(void)
+jinit_c_master_control (j_compress_ptr cinfo, boolean transcode_only)
+{
+ my_master_ptr master;
+
+ master = (my_master_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_comp_master));
+ cinfo->master = (struct jpeg_comp_master *) master;
+ master->pub.prepare_for_pass = prepare_for_pass;
+ master->pub.pass_startup = pass_startup;
+ master->pub.finish_pass = finish_pass_master;
+ master->pub.is_last_pass = FALSE;
+
+ /* Validate parameters, determine derived values */
+ initial_setup(cinfo);
+
+ if (cinfo->scan_info != NULL) {
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+ validate_script(cinfo);
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+ } else {
+ cinfo->progressive_mode = FALSE;
+ cinfo->num_scans = 1;
+ }
+
+ if (cinfo->progressive_mode) /* TEMPORARY HACK ??? */
+ cinfo->optimize_coding = TRUE; /* assume default tables no good for progressive mode */
+
+ /* Initialize my private state */
+ if (transcode_only) {
+ /* no main pass in transcoding */
+ if (cinfo->optimize_coding)
+ master->pass_type = huff_opt_pass;
+ else
+ master->pass_type = output_pass;
+ } else {
+ /* for normal compression, first pass is always this type: */
+ master->pass_type = main_pass;
+ }
+ master->scan_number = 0;
+ master->pass_number = 0;
+ if (cinfo->optimize_coding)
+ master->total_passes = cinfo->num_scans * 2;
+ else
+ master->total_passes = cinfo->num_scans;
+}
--- /dev/null
+/*
+ * jcomapi.c
+ *
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * 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;
+}
--- /dev/null
+/* jconfig.vc --- jconfig.h for Microsoft Visual C++ on Windows 95 or NT. */
+/* see jconfig.doc for explanations */
+
+#define HAVE_PROTOTYPES
+#define HAVE_UNSIGNED_CHAR
+#define HAVE_UNSIGNED_SHORT
+/* #define void char */
+/* #define const */
+#undef CHAR_IS_UNSIGNED
+#define HAVE_STDDEF_H
+#define HAVE_STDLIB_H
+#undef NEED_BSD_STRINGS
+#undef NEED_SYS_TYPES_H
+#undef NEED_FAR_POINTERS /* we presume a 32-bit flat memory model */
+#undef NEED_SHORT_EXTERNAL_NAMES
+#undef INCOMPLETE_TYPES_BROKEN
+
+/* Define "boolean" as unsigned char, not int, per Windows custom */
+#ifndef __RPCNDR_H__ /* don't conflict if rpcndr.h already read */
+typedef unsigned char boolean;
+#endif
+#define HAVE_BOOLEAN /* prevent jmorecfg.h from redefining it */
+
+
+#ifdef JPEG_INTERNALS
+
+#undef RIGHT_SHIFT_IS_UNSIGNED
+
+#endif /* JPEG_INTERNALS */
+
+#ifdef JPEG_CJPEG_DJPEG
+
+#define BMP_SUPPORTED /* BMP image file format */
+#define GIF_SUPPORTED /* GIF image file format */
+#define PPM_SUPPORTED /* PBMPLUS PPM/PGM image file format */
+#undef RLE_SUPPORTED /* Utah RLE image file format */
+#define TARGA_SUPPORTED /* Targa image file format */
+
+#define TWO_FILE_COMMANDLINE /* optional */
+#define USE_SETMODE /* Microsoft has setmode() */
+#undef NEED_SIGNAL_CATCHER
+#undef DONT_USE_B_MODE
+#undef PROGRESS_REPORT /* optional */
+
+#endif /* JPEG_CJPEG_DJPEG */
--- /dev/null
+/*
+ * jcparam.c
+ *
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * 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 optional default-setting code for the JPEG compressor.
+ * Applications do not have to use this file, but those that don't use it
+ * must know a lot more about the innards of the JPEG code.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Quantization table setup routines
+ */
+
+GLOBAL(void)
+jpeg_add_quant_table (j_compress_ptr cinfo, int which_tbl,
+ const unsigned int *basic_table,
+ int scale_factor, boolean force_baseline)
+/* Define a quantization table equal to the basic_table times
+ * a scale factor (given as a percentage).
+ * If force_baseline is TRUE, the computed quantization table entries
+ * are limited to 1..255 for JPEG baseline compatibility.
+ */
+{
+ JQUANT_TBL ** qtblptr;
+ int i;
+ long temp;
+
+ /* Safety check to ensure start_compress not called yet. */
+ if (cinfo->global_state != CSTATE_START)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+ if (which_tbl < 0 || which_tbl >= NUM_QUANT_TBLS)
+ ERREXIT1(cinfo, JERR_DQT_INDEX, which_tbl);
+
+ qtblptr = & cinfo->quant_tbl_ptrs[which_tbl];
+
+ if (*qtblptr == NULL)
+ *qtblptr = jpeg_alloc_quant_table((j_common_ptr) cinfo);
+
+ for (i = 0; i < DCTSIZE2; i++) {
+ temp = ((long) basic_table[i] * scale_factor + 50L) / 100L;
+ /* limit the values to the valid range */
+ if (temp <= 0L) temp = 1L;
+ if (temp > 32767L) temp = 32767L; /* max quantizer needed for 12 bits */
+ if (force_baseline && temp > 255L)
+ temp = 255L; /* limit to baseline range if requested */
+ (*qtblptr)->quantval[i] = (UINT16) temp;
+ }
+
+ /* Initialize sent_table FALSE so table will be written to JPEG file. */
+ (*qtblptr)->sent_table = FALSE;
+}
+
+
+GLOBAL(void)
+jpeg_set_linear_quality (j_compress_ptr cinfo, int scale_factor,
+ boolean force_baseline)
+/* Set or change the 'quality' (quantization) setting, using default tables
+ * and a straight percentage-scaling quality scale. In most cases it's better
+ * to use jpeg_set_quality (below); this entry point is provided for
+ * applications that insist on a linear percentage scaling.
+ */
+{
+ /* These are the sample quantization tables given in JPEG spec section K.1.
+ * The spec says that the values given produce "good" quality, and
+ * when divided by 2, "very good" quality.
+ */
+ static const unsigned int std_luminance_quant_tbl[DCTSIZE2] = {
+ 16, 11, 10, 16, 24, 40, 51, 61,
+ 12, 12, 14, 19, 26, 58, 60, 55,
+ 14, 13, 16, 24, 40, 57, 69, 56,
+ 14, 17, 22, 29, 51, 87, 80, 62,
+ 18, 22, 37, 56, 68, 109, 103, 77,
+ 24, 35, 55, 64, 81, 104, 113, 92,
+ 49, 64, 78, 87, 103, 121, 120, 101,
+ 72, 92, 95, 98, 112, 100, 103, 99
+ };
+ static const unsigned int std_chrominance_quant_tbl[DCTSIZE2] = {
+ 17, 18, 24, 47, 99, 99, 99, 99,
+ 18, 21, 26, 66, 99, 99, 99, 99,
+ 24, 26, 56, 99, 99, 99, 99, 99,
+ 47, 66, 99, 99, 99, 99, 99, 99,
+ 99, 99, 99, 99, 99, 99, 99, 99,
+ 99, 99, 99, 99, 99, 99, 99, 99,
+ 99, 99, 99, 99, 99, 99, 99, 99,
+ 99, 99, 99, 99, 99, 99, 99, 99
+ };
+
+ /* Set up two quantization tables using the specified scaling */
+ jpeg_add_quant_table(cinfo, 0, std_luminance_quant_tbl,
+ scale_factor, force_baseline);
+ jpeg_add_quant_table(cinfo, 1, std_chrominance_quant_tbl,
+ scale_factor, force_baseline);
+}
+
+
+GLOBAL(int)
+jpeg_quality_scaling (int quality)
+/* Convert a user-specified quality rating to a percentage scaling factor
+ * for an underlying quantization table, using our recommended scaling curve.
+ * The input 'quality' factor should be 0 (terrible) to 100 (very good).
+ */
+{
+ /* Safety limit on quality factor. Convert 0 to 1 to avoid zero divide. */
+ if (quality <= 0) quality = 1;
+ if (quality > 100) quality = 100;
+
+ /* The basic table is used as-is (scaling 100) for a quality of 50.
+ * Qualities 50..100 are converted to scaling percentage 200 - 2*Q;
+ * note that at Q=100 the scaling is 0, which will cause jpeg_add_quant_table
+ * to make all the table entries 1 (hence, minimum quantization loss).
+ * Qualities 1..50 are converted to scaling percentage 5000/Q.
+ */
+ if (quality < 50)
+ quality = 5000 / quality;
+ else
+ quality = 200 - quality*2;
+
+ return quality;
+}
+
+
+GLOBAL(void)
+jpeg_set_quality (j_compress_ptr cinfo, int quality, boolean force_baseline)
+/* Set or change the 'quality' (quantization) setting, using default tables.
+ * This is the standard quality-adjusting entry point for typical user
+ * interfaces; only those who want detailed control over quantization tables
+ * would use the preceding three routines directly.
+ */
+{
+ /* Convert user 0-100 rating to percentage scaling */
+ quality = jpeg_quality_scaling(quality);
+
+ /* Set up standard quality tables */
+ jpeg_set_linear_quality(cinfo, quality, force_baseline);
+}
+
+
+/*
+ * Huffman table setup routines
+ */
+
+LOCAL(void)
+add_huff_table (j_compress_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((j_common_ptr) cinfo);
+
+ /* Copy the number-of-symbols-of-each-code-length counts */
+ MEMCOPY((*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);
+
+ MEMCOPY((*htblptr)->huffval, val, 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_compress_ptr cinfo)
+/* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
+/* IMPORTANT: these are only valid for 8-bit data precision! */
+{
+ 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 };
+
+ add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[0],
+ bits_dc_luminance, val_dc_luminance);
+ add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[0],
+ bits_ac_luminance, val_ac_luminance);
+ add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[1],
+ bits_dc_chrominance, val_dc_chrominance);
+ add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[1],
+ bits_ac_chrominance, val_ac_chrominance);
+}
+
+
+/*
+ * Default parameter setup for compression.
+ *
+ * Applications that don't choose to use this routine must do their
+ * own setup of all these parameters. Alternately, you can call this
+ * to establish defaults and then alter parameters selectively. This
+ * is the recommended approach since, if we add any new parameters,
+ * your code will still work (they'll be set to reasonable defaults).
+ */
+
+GLOBAL(void)
+jpeg_set_defaults (j_compress_ptr cinfo)
+{
+ int i;
+
+ /* Safety check to ensure start_compress not called yet. */
+ if (cinfo->global_state != CSTATE_START)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+ /* Allocate comp_info array large enough for maximum component count.
+ * Array is made permanent in case application wants to compress
+ * multiple images at same param settings.
+ */
+ if (cinfo->comp_info == NULL)
+ cinfo->comp_info = (jpeg_component_info *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+ MAX_COMPONENTS * SIZEOF(jpeg_component_info));
+
+ /* Initialize everything not dependent on the color space */
+
+ cinfo->data_precision = BITS_IN_JSAMPLE;
+ /* Set up two quantization tables using default quality of 75 */
+ jpeg_set_quality(cinfo, 75, TRUE);
+ /* Set up two Huffman tables */
+ std_huff_tables(cinfo);
+
+ /* Initialize default arithmetic coding conditioning */
+ for (i = 0; i < NUM_ARITH_TBLS; i++) {
+ cinfo->arith_dc_L[i] = 0;
+ cinfo->arith_dc_U[i] = 1;
+ cinfo->arith_ac_K[i] = 5;
+ }
+
+ /* Default is no multiple-scan output */
+ cinfo->scan_info = NULL;
+ cinfo->num_scans = 0;
+
+ /* Expect normal source image, not raw downsampled data */
+ cinfo->raw_data_in = FALSE;
+
+ /* Use Huffman coding, not arithmetic coding, by default */
+ cinfo->arith_code = FALSE;
+
+ /* By default, don't do extra passes to optimize entropy coding */
+ cinfo->optimize_coding = FALSE;
+ /* The standard Huffman tables are only valid for 8-bit data precision.
+ * If the precision is higher, force optimization on so that usable
+ * tables will be computed. This test can be removed if default tables
+ * are supplied that are valid for the desired precision.
+ */
+ if (cinfo->data_precision > 8)
+ cinfo->optimize_coding = TRUE;
+
+ /* By default, use the simpler non-cosited sampling alignment */
+ cinfo->CCIR601_sampling = FALSE;
+
+ /* No input smoothing */
+ cinfo->smoothing_factor = 0;
+
+ /* DCT algorithm preference */
+ cinfo->dct_method = JDCT_DEFAULT;
+
+ /* No restart markers */
+ cinfo->restart_interval = 0;
+ cinfo->restart_in_rows = 0;
+
+ /* Fill in default JFIF marker parameters. Note that whether the marker
+ * will actually be written is determined by jpeg_set_colorspace.
+ *
+ * By default, the library emits JFIF version code 1.01.
+ * An application that wants to emit JFIF 1.02 extension markers should set
+ * JFIF_minor_version to 2. We could probably get away with just defaulting
+ * to 1.02, but there may still be some decoders in use that will complain
+ * about that; saying 1.01 should minimize compatibility problems.
+ */
+ cinfo->JFIF_major_version = 1; /* Default JFIF version = 1.01 */
+ cinfo->JFIF_minor_version = 1;
+ cinfo->density_unit = 0; /* Pixel size is unknown by default */
+ cinfo->X_density = 1; /* Pixel aspect ratio is square by default */
+ cinfo->Y_density = 1;
+
+ /* Choose JPEG colorspace based on input space, set defaults accordingly */
+
+ jpeg_default_colorspace(cinfo);
+}
+
+
+/*
+ * Select an appropriate JPEG colorspace for in_color_space.
+ */
+
+GLOBAL(void)
+jpeg_default_colorspace (j_compress_ptr cinfo)
+{
+ switch (cinfo->in_color_space) {
+ case JCS_GRAYSCALE:
+ jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);
+ break;
+ case JCS_RGB:
+ jpeg_set_colorspace(cinfo, JCS_YCbCr);
+ break;
+ case JCS_YCbCr:
+ jpeg_set_colorspace(cinfo, JCS_YCbCr);
+ break;
+ case JCS_CMYK:
+ jpeg_set_colorspace(cinfo, JCS_CMYK); /* By default, no translation */
+ break;
+ case JCS_YCCK:
+ jpeg_set_colorspace(cinfo, JCS_YCCK);
+ break;
+ case JCS_UNKNOWN:
+ jpeg_set_colorspace(cinfo, JCS_UNKNOWN);
+ break;
+ default:
+ ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+ }
+}
+
+
+/*
+ * Set the JPEG colorspace, and choose colorspace-dependent default values.
+ */
+
+GLOBAL(void)
+jpeg_set_colorspace (j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
+{
+ jpeg_component_info * compptr;
+ int ci;
+
+#define SET_COMP(index,id,hsamp,vsamp,quant,dctbl,actbl) \
+ (compptr = &cinfo->comp_info[index], \
+ compptr->component_id = (id), \
+ compptr->h_samp_factor = (hsamp), \
+ compptr->v_samp_factor = (vsamp), \
+ compptr->quant_tbl_no = (quant), \
+ compptr->dc_tbl_no = (dctbl), \
+ compptr->ac_tbl_no = (actbl) )
+
+ /* Safety check to ensure start_compress not called yet. */
+ if (cinfo->global_state != CSTATE_START)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+ /* For all colorspaces, we use Q and Huff tables 0 for luminance components,
+ * tables 1 for chrominance components.
+ */
+
+ cinfo->jpeg_color_space = colorspace;
+
+ cinfo->write_JFIF_header = FALSE; /* No marker for non-JFIF colorspaces */
+ cinfo->write_Adobe_marker = FALSE; /* write no Adobe marker by default */
+
+ switch (colorspace) {
+ case JCS_GRAYSCALE:
+ cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
+ cinfo->num_components = 1;
+ /* JFIF specifies component ID 1 */
+ SET_COMP(0, 1, 1,1, 0, 0,0);
+ break;
+ case JCS_RGB:
+ cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag RGB */
+ cinfo->num_components = 3;
+ SET_COMP(0, 0x52 /* 'R' */, 1,1, 0, 0,0);
+ SET_COMP(1, 0x47 /* 'G' */, 1,1, 0, 0,0);
+ SET_COMP(2, 0x42 /* 'B' */, 1,1, 0, 0,0);
+ break;
+ case JCS_YCbCr:
+ cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
+ cinfo->num_components = 3;
+ /* JFIF specifies component IDs 1,2,3 */
+ /* We default to 2x2 subsamples of chrominance */
+ SET_COMP(0, 1, 2,2, 0, 0,0);
+ SET_COMP(1, 2, 1,1, 1, 1,1);
+ SET_COMP(2, 3, 1,1, 1, 1,1);
+ break;
+ case JCS_CMYK:
+ cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag CMYK */
+ cinfo->num_components = 4;
+ SET_COMP(0, 0x43 /* 'C' */, 1,1, 0, 0,0);
+ SET_COMP(1, 0x4D /* 'M' */, 1,1, 0, 0,0);
+ SET_COMP(2, 0x59 /* 'Y' */, 1,1, 0, 0,0);
+ SET_COMP(3, 0x4B /* 'K' */, 1,1, 0, 0,0);
+ break;
+ case JCS_YCCK:
+ cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag YCCK */
+ cinfo->num_components = 4;
+ SET_COMP(0, 1, 2,2, 0, 0,0);
+ SET_COMP(1, 2, 1,1, 1, 1,1);
+ SET_COMP(2, 3, 1,1, 1, 1,1);
+ SET_COMP(3, 4, 2,2, 0, 0,0);
+ break;
+ case JCS_UNKNOWN:
+ cinfo->num_components = cinfo->input_components;
+ if (cinfo->num_components < 1 || cinfo->num_components > MAX_COMPONENTS)
+ ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
+ MAX_COMPONENTS);
+ for (ci = 0; ci < cinfo->num_components; ci++) {
+ SET_COMP(ci, ci, 1,1, 0, 0,0);
+ }
+ break;
+ default:
+ ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+ }
+}
+
+
+#ifdef C_PROGRESSIVE_SUPPORTED
+
+LOCAL(jpeg_scan_info *)
+fill_a_scan (jpeg_scan_info * scanptr, int ci,
+ int Ss, int Se, int Ah, int Al)
+/* Support routine: generate one scan for specified component */
+{
+ scanptr->comps_in_scan = 1;
+ scanptr->component_index[0] = ci;
+ scanptr->Ss = Ss;
+ scanptr->Se = Se;
+ scanptr->Ah = Ah;
+ scanptr->Al = Al;
+ scanptr++;
+ return scanptr;
+}
+
+LOCAL(jpeg_scan_info *)
+fill_scans (jpeg_scan_info * scanptr, int ncomps,
+ int Ss, int Se, int Ah, int Al)
+/* Support routine: generate one scan for each component */
+{
+ int ci;
+
+ for (ci = 0; ci < ncomps; ci++) {
+ scanptr->comps_in_scan = 1;
+ scanptr->component_index[0] = ci;
+ scanptr->Ss = Ss;
+ scanptr->Se = Se;
+ scanptr->Ah = Ah;
+ scanptr->Al = Al;
+ scanptr++;
+ }
+ return scanptr;
+}
+
+LOCAL(jpeg_scan_info *)
+fill_dc_scans (jpeg_scan_info * scanptr, int ncomps, int Ah, int Al)
+/* Support routine: generate interleaved DC scan if possible, else N scans */
+{
+ int ci;
+
+ if (ncomps <= MAX_COMPS_IN_SCAN) {
+ /* Single interleaved DC scan */
+ scanptr->comps_in_scan = ncomps;
+ for (ci = 0; ci < ncomps; ci++)
+ scanptr->component_index[ci] = ci;
+ scanptr->Ss = scanptr->Se = 0;
+ scanptr->Ah = Ah;
+ scanptr->Al = Al;
+ scanptr++;
+ } else {
+ /* Noninterleaved DC scan for each component */
+ scanptr = fill_scans(scanptr, ncomps, 0, 0, Ah, Al);
+ }
+ return scanptr;
+}
+
+
+/*
+ * Create a recommended progressive-JPEG script.
+ * cinfo->num_components and cinfo->jpeg_color_space must be correct.
+ */
+
+GLOBAL(void)
+jpeg_simple_progression (j_compress_ptr cinfo)
+{
+ int ncomps = cinfo->num_components;
+ int nscans;
+ jpeg_scan_info * scanptr;
+
+ /* Safety check to ensure start_compress not called yet. */
+ if (cinfo->global_state != CSTATE_START)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+ /* Figure space needed for script. Calculation must match code below! */
+ if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
+ /* Custom script for YCbCr color images. */
+ nscans = 10;
+ } else {
+ /* All-purpose script for other color spaces. */
+ if (ncomps > MAX_COMPS_IN_SCAN)
+ nscans = 6 * ncomps; /* 2 DC + 4 AC scans per component */
+ else
+ nscans = 2 + 4 * ncomps; /* 2 DC scans; 4 AC scans per component */
+ }
+
+ /* Allocate space for script.
+ * We need to put it in the permanent pool in case the application performs
+ * multiple compressions without changing the settings. To avoid a memory
+ * leak if jpeg_simple_progression is called repeatedly for the same JPEG
+ * object, we try to re-use previously allocated space, and we allocate
+ * enough space to handle YCbCr even if initially asked for grayscale.
+ */
+ if (cinfo->script_space == NULL || cinfo->script_space_size < nscans) {
+ cinfo->script_space_size = MAX(nscans, 10);
+ cinfo->script_space = (jpeg_scan_info *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+ cinfo->script_space_size * SIZEOF(jpeg_scan_info));
+ }
+ scanptr = cinfo->script_space;
+ cinfo->scan_info = scanptr;
+ cinfo->num_scans = nscans;
+
+ if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
+ /* Custom script for YCbCr color images. */
+ /* Initial DC scan */
+ scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
+ /* Initial AC scan: get some luma data out in a hurry */
+ scanptr = fill_a_scan(scanptr, 0, 1, 5, 0, 2);
+ /* Chroma data is too small to be worth expending many scans on */
+ scanptr = fill_a_scan(scanptr, 2, 1, 63, 0, 1);
+ scanptr = fill_a_scan(scanptr, 1, 1, 63, 0, 1);
+ /* Complete spectral selection for luma AC */
+ scanptr = fill_a_scan(scanptr, 0, 6, 63, 0, 2);
+ /* Refine next bit of luma AC */
+ scanptr = fill_a_scan(scanptr, 0, 1, 63, 2, 1);
+ /* Finish DC successive approximation */
+ scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
+ /* Finish AC successive approximation */
+ scanptr = fill_a_scan(scanptr, 2, 1, 63, 1, 0);
+ scanptr = fill_a_scan(scanptr, 1, 1, 63, 1, 0);
+ /* Luma bottom bit comes last since it's usually largest scan */
+ scanptr = fill_a_scan(scanptr, 0, 1, 63, 1, 0);
+ } else {
+ /* All-purpose script for other color spaces. */
+ /* Successive approximation first pass */
+ scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
+ scanptr = fill_scans(scanptr, ncomps, 1, 5, 0, 2);
+ scanptr = fill_scans(scanptr, ncomps, 6, 63, 0, 2);
+ /* Successive approximation second pass */
+ scanptr = fill_scans(scanptr, ncomps, 1, 63, 2, 1);
+ /* Successive approximation final pass */
+ scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
+ scanptr = fill_scans(scanptr, ncomps, 1, 63, 1, 0);
+ }
+}
+
+#endif /* C_PROGRESSIVE_SUPPORTED */
--- /dev/null
+/*
+ * jcphuff.c
+ *
+ * Copyright (C) 1995-1997, Thomas G. Lane.
+ * 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 Huffman entropy encoding routines for progressive JPEG.
+ *
+ * We do not support output suspension in this module, since the library
+ * currently does not allow multiple-scan files to be written with output
+ * suspension.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jchuff.h" /* Declarations shared with jchuff.c */
+
+#ifdef C_PROGRESSIVE_SUPPORTED
+
+/* Expanded entropy encoder object for progressive Huffman encoding. */
+
+typedef struct {
+ struct jpeg_entropy_encoder pub; /* public fields */
+
+ /* Mode flag: TRUE for optimization, FALSE for actual data output */
+ boolean gather_statistics;
+
+ /* Bit-level coding status.
+ * next_output_byte/free_in_buffer are local copies of cinfo->dest fields.
+ */
+ JOCTET * next_output_byte; /* => next byte to write in buffer */
+ size_t free_in_buffer; /* # of byte spaces remaining in buffer */
+ INT32 put_buffer; /* current bit-accumulation buffer */
+ int put_bits; /* # of bits now in it */
+ j_compress_ptr cinfo; /* link to cinfo (needed for dump_buffer) */
+
+ /* Coding status for DC components */
+ int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
+
+ /* Coding status for AC components */
+ int ac_tbl_no; /* the table number of the single component */
+ unsigned int EOBRUN; /* run length of EOBs */
+ unsigned int BE; /* # of buffered correction bits before MCU */
+ char * bit_buffer; /* buffer for correction bits (1 per char) */
+ /* packing correction bits tightly would save some space but cost time... */
+
+ unsigned int restarts_to_go; /* MCUs left in this restart interval */
+ int next_restart_num; /* next restart number to write (0-7) */
+
+ /* Pointers to derived tables (these workspaces have image lifespan).
+ * Since any one scan codes only DC or only AC, we only need one set
+ * of tables, not one for DC and one for AC.
+ */
+ c_derived_tbl * derived_tbls[NUM_HUFF_TBLS];
+
+ /* Statistics tables for optimization; again, one set is enough */
+ long * count_ptrs[NUM_HUFF_TBLS];
+} phuff_entropy_encoder;
+
+typedef phuff_entropy_encoder * phuff_entropy_ptr;
+
+/* MAX_CORR_BITS is the number of bits the AC refinement correction-bit
+ * buffer can hold. Larger sizes may slightly improve compression, but
+ * 1000 is already well into the realm of overkill.
+ * The minimum safe size is 64 bits.
+ */
+
+#define MAX_CORR_BITS 1000 /* Max # of correction bits I can buffer */
+
+/* IRIGHT_SHIFT is like RIGHT_SHIFT, but works on int rather than INT32.
+ * We assume that int right shift is unsigned if INT32 right shift is,
+ * which should be safe.
+ */
+
+#ifdef RIGHT_SHIFT_IS_UNSIGNED
+#define ISHIFT_TEMPS int ishift_temp;
+#define IRIGHT_SHIFT(x,shft) \
+ ((ishift_temp = (x)) < 0 ? \
+ (ishift_temp >> (shft)) | ((~0) << (16-(shft))) : \
+ (ishift_temp >> (shft)))
+#else
+#define ISHIFT_TEMPS
+#define IRIGHT_SHIFT(x,shft) ((x) >> (shft))
+#endif
+
+/* Forward declarations */
+METHODDEF(boolean) encode_mcu_DC_first JPP((j_compress_ptr cinfo,
+ JBLOCKROW *MCU_data));
+METHODDEF(boolean) encode_mcu_AC_first JPP((j_compress_ptr cinfo,
+ JBLOCKROW *MCU_data));
+METHODDEF(boolean) encode_mcu_DC_refine JPP((j_compress_ptr cinfo,
+ JBLOCKROW *MCU_data));
+METHODDEF(boolean) encode_mcu_AC_refine JPP((j_compress_ptr cinfo,
+ JBLOCKROW *MCU_data));
+METHODDEF(void) finish_pass_phuff JPP((j_compress_ptr cinfo));
+METHODDEF(void) finish_pass_gather_phuff JPP((j_compress_ptr cinfo));
+
+
+/*
+ * Initialize for a Huffman-compressed scan using progressive JPEG.
+ */
+
+METHODDEF(void)
+start_pass_phuff (j_compress_ptr cinfo, boolean gather_statistics)
+{
+ phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+ boolean is_DC_band;
+ int ci, tbl;
+ jpeg_component_info * compptr;
+
+ entropy->cinfo = cinfo;
+ entropy->gather_statistics = gather_statistics;
+
+ is_DC_band = (cinfo->Ss == 0);
+
+ /* We assume jcmaster.c already validated the scan parameters. */
+
+ /* Select execution routines */
+ if (cinfo->Ah == 0) {
+ if (is_DC_band)
+ entropy->pub.encode_mcu = encode_mcu_DC_first;
+ else
+ entropy->pub.encode_mcu = encode_mcu_AC_first;
+ } else {
+ if (is_DC_band)
+ entropy->pub.encode_mcu = encode_mcu_DC_refine;
+ else {
+ entropy->pub.encode_mcu = encode_mcu_AC_refine;
+ /* AC refinement needs a correction bit buffer */
+ if (entropy->bit_buffer == NULL)
+ entropy->bit_buffer = (char *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ MAX_CORR_BITS * SIZEOF(char));
+ }
+ }
+ if (gather_statistics)
+ entropy->pub.finish_pass = finish_pass_gather_phuff;
+ else
+ entropy->pub.finish_pass = finish_pass_phuff;
+
+ /* Only DC coefficients may be interleaved, so cinfo->comps_in_scan = 1
+ * for AC coefficients.
+ */
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ /* Initialize DC predictions to 0 */
+ entropy->last_dc_val[ci] = 0;
+ /* Get table index */
+ if (is_DC_band) {
+ if (cinfo->Ah != 0) /* DC refinement needs no table */
+ continue;
+ tbl = compptr->dc_tbl_no;
+ } else {
+ entropy->ac_tbl_no = tbl = compptr->ac_tbl_no;
+ }
+ if (gather_statistics) {
+ /* Check for invalid table index */
+ /* (make_c_derived_tbl does this in the other path) */
+ if (tbl < 0 || tbl >= NUM_HUFF_TBLS)
+ ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tbl);
+ /* Allocate and zero the statistics tables */
+ /* Note that jpeg_gen_optimal_table expects 257 entries in each table! */
+ if (entropy->count_ptrs[tbl] == NULL)
+ entropy->count_ptrs[tbl] = (long *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ 257 * SIZEOF(long));
+ MEMZERO(entropy->count_ptrs[tbl], 257 * SIZEOF(long));
+ } else {
+ /* Compute derived values for Huffman table */
+ /* We may do this more than once for a table, but it's not expensive */
+ jpeg_make_c_derived_tbl(cinfo, is_DC_band, tbl,
+ & entropy->derived_tbls[tbl]);
+ }
+ }
+
+ /* Initialize AC stuff */
+ entropy->EOBRUN = 0;
+ entropy->BE = 0;
+
+ /* Initialize bit buffer to empty */
+ entropy->put_buffer = 0;
+ entropy->put_bits = 0;
+
+ /* Initialize restart stuff */
+ entropy->restarts_to_go = cinfo->restart_interval;
+ entropy->next_restart_num = 0;
+}
+
+
+/* Outputting bytes to the file.
+ * NB: these must be called only when actually outputting,
+ * that is, entropy->gather_statistics == FALSE.
+ */
+
+/* Emit a byte */
+#define emit_byte(entropy,val) \
+ { *(entropy)->next_output_byte++ = (JOCTET) (val); \
+ if (--(entropy)->free_in_buffer == 0) \
+ dump_buffer(entropy); }
+
+
+LOCAL(void)
+dump_buffer (phuff_entropy_ptr entropy)
+/* Empty the output buffer; we do not support suspension in this module. */
+{
+ struct jpeg_destination_mgr * dest = entropy->cinfo->dest;
+
+ if (! (*dest->empty_output_buffer) (entropy->cinfo))
+ ERREXIT(entropy->cinfo, JERR_CANT_SUSPEND);
+ /* After a successful buffer dump, must reset buffer pointers */
+ entropy->next_output_byte = dest->next_output_byte;
+ entropy->free_in_buffer = dest->free_in_buffer;
+}
+
+
+/* Outputting bits to the file */
+
+/* Only the right 24 bits of put_buffer are used; the valid bits are
+ * left-justified in this part. At most 16 bits can be passed to emit_bits
+ * in one call, and we never retain more than 7 bits in put_buffer
+ * between calls, so 24 bits are sufficient.
+ */
+
+INLINE
+LOCAL(void)
+emit_bits (phuff_entropy_ptr entropy, unsigned int code, int size)
+/* Emit some bits, unless we are in gather mode */
+{
+ /* This routine is heavily used, so it's worth coding tightly. */
+ register INT32 put_buffer = (INT32) code;
+ register int put_bits = entropy->put_bits;
+
+ /* if size is 0, caller used an invalid Huffman table entry */
+ if (size == 0)
+ ERREXIT(entropy->cinfo, JERR_HUFF_MISSING_CODE);
+
+ if (entropy->gather_statistics)
+ return; /* do nothing if we're only getting stats */
+
+ put_buffer &= (((INT32) 1)<<size) - 1; /* mask off any extra bits in code */
+
+ put_bits += size; /* new number of bits in buffer */
+
+ put_buffer <<= 24 - put_bits; /* align incoming bits */
+
+ put_buffer |= entropy->put_buffer; /* and merge with old buffer contents */
+
+ while (put_bits >= 8) {
+ int c = (int) ((put_buffer >> 16) & 0xFF);
+
+ emit_byte(entropy, c);
+ if (c == 0xFF) { /* need to stuff a zero byte? */
+ emit_byte(entropy, 0);
+ }
+ put_buffer <<= 8;
+ put_bits -= 8;
+ }
+
+ entropy->put_buffer = put_buffer; /* update variables */
+ entropy->put_bits = put_bits;
+}
+
+
+LOCAL(void)
+flush_bits (phuff_entropy_ptr entropy)
+{
+ emit_bits(entropy, 0x7F, 7); /* fill any partial byte with ones */
+ entropy->put_buffer = 0; /* and reset bit-buffer to empty */
+ entropy->put_bits = 0;
+}
+
+
+/*
+ * Emit (or just count) a Huffman symbol.
+ */
+
+INLINE
+LOCAL(void)
+emit_symbol (phuff_entropy_ptr entropy, int tbl_no, int symbol)
+{
+ if (entropy->gather_statistics)
+ entropy->count_ptrs[tbl_no][symbol]++;
+ else {
+ c_derived_tbl * tbl = entropy->derived_tbls[tbl_no];
+ emit_bits(entropy, tbl->ehufco[symbol], tbl->ehufsi[symbol]);
+ }
+}
+
+
+/*
+ * Emit bits from a correction bit buffer.
+ */
+
+LOCAL(void)
+emit_buffered_bits (phuff_entropy_ptr entropy, char * bufstart,
+ unsigned int nbits)
+{
+ if (entropy->gather_statistics)
+ return; /* no real work */
+
+ while (nbits > 0) {
+ emit_bits(entropy, (unsigned int) (*bufstart), 1);
+ bufstart++;
+ nbits--;
+ }
+}
+
+
+/*
+ * Emit any pending EOBRUN symbol.
+ */
+
+LOCAL(void)
+emit_eobrun (phuff_entropy_ptr entropy)
+{
+ register int temp, nbits;
+
+ if (entropy->EOBRUN > 0) { /* if there is any pending EOBRUN */
+ temp = entropy->EOBRUN;
+ nbits = 0;
+ while ((temp >>= 1))
+ nbits++;
+ /* safety check: shouldn't happen given limited correction-bit buffer */
+ if (nbits > 14)
+ ERREXIT(entropy->cinfo, JERR_HUFF_MISSING_CODE);
+
+ emit_symbol(entropy, entropy->ac_tbl_no, nbits << 4);
+ if (nbits)
+ emit_bits(entropy, entropy->EOBRUN, nbits);
+
+ entropy->EOBRUN = 0;
+
+ /* Emit any buffered correction bits */
+ emit_buffered_bits(entropy, entropy->bit_buffer, entropy->BE);
+ entropy->BE = 0;
+ }
+}
+
+
+/*
+ * Emit a restart marker & resynchronize predictions.
+ */
+
+LOCAL(void)
+emit_restart (phuff_entropy_ptr entropy, int restart_num)
+{
+ int ci;
+
+ emit_eobrun(entropy);
+
+ if (! entropy->gather_statistics) {
+ flush_bits(entropy);
+ emit_byte(entropy, 0xFF);
+ emit_byte(entropy, JPEG_RST0 + restart_num);
+ }
+
+ if (entropy->cinfo->Ss == 0) {
+ /* Re-initialize DC predictions to 0 */
+ for (ci = 0; ci < entropy->cinfo->comps_in_scan; ci++)
+ entropy->last_dc_val[ci] = 0;
+ } else {
+ /* Re-initialize all AC-related fields to 0 */
+ entropy->EOBRUN = 0;
+ entropy->BE = 0;
+ }
+}
+
+
+/*
+ * MCU encoding for DC initial scan (either spectral selection,
+ * or first pass of successive approximation).
+ */
+
+METHODDEF(boolean)
+encode_mcu_DC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+ phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+ register int temp, temp2;
+ register int nbits;
+ int blkn, ci;
+ int Al = cinfo->Al;
+ JBLOCKROW block;
+ jpeg_component_info * compptr;
+ ISHIFT_TEMPS
+
+ entropy->next_output_byte = cinfo->dest->next_output_byte;
+ entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+ /* Emit restart marker if needed */
+ if (cinfo->restart_interval)
+ if (entropy->restarts_to_go == 0)
+ emit_restart(entropy, entropy->next_restart_num);
+
+ /* Encode the MCU data blocks */
+ for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+ block = MCU_data[blkn];
+ ci = cinfo->MCU_membership[blkn];
+ compptr = cinfo->cur_comp_info[ci];
+
+ /* Compute the DC value after the required point transform by Al.
+ * This is simply an arithmetic right shift.
+ */
+ temp2 = IRIGHT_SHIFT((int) ((*block)[0]), Al);
+
+ /* DC differences are figured on the point-transformed values. */
+ temp = temp2 - entropy->last_dc_val[ci];
+ entropy->last_dc_val[ci] = temp2;
+
+ /* Encode the DC coefficient difference per section G.1.2.1 */
+ temp2 = temp;
+ if (temp < 0) {
+ temp = -temp; /* temp is abs value of input */
+ /* For a negative input, want temp2 = bitwise complement of abs(input) */
+ /* This code assumes we are on a two's complement machine */
+ temp2--;
+ }
+
+ /* Find the number of bits needed for the magnitude of the coefficient */
+ nbits = 0;
+ while (temp) {
+ nbits++;
+ temp >>= 1;
+ }
+ /* Check for out-of-range coefficient values.
+ * Since we're encoding a difference, the range limit is twice as much.
+ */
+ if (nbits > MAX_COEF_BITS+1)
+ ERREXIT(cinfo, JERR_BAD_DCT_COEF);
+
+ /* Count/emit the Huffman-coded symbol for the number of bits */
+ emit_symbol(entropy, compptr->dc_tbl_no, nbits);
+
+ /* Emit that number of bits of the value, if positive, */
+ /* or the complement of its magnitude, if negative. */
+ if (nbits) /* emit_bits rejects calls with size 0 */
+ emit_bits(entropy, (unsigned int) temp2, nbits);
+ }
+
+ cinfo->dest->next_output_byte = entropy->next_output_byte;
+ cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+
+ /* Update restart-interval state too */
+ if (cinfo->restart_interval) {
+ if (entropy->restarts_to_go == 0) {
+ entropy->restarts_to_go = cinfo->restart_interval;
+ entropy->next_restart_num++;
+ entropy->next_restart_num &= 7;
+ }
+ entropy->restarts_to_go--;
+ }
+
+ return TRUE;
+}
+
+
+/*
+ * MCU encoding for AC initial scan (either spectral selection,
+ * or first pass of successive approximation).
+ */
+
+METHODDEF(boolean)
+encode_mcu_AC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+ phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+ register int temp, temp2;
+ register int nbits;
+ register int r, k;
+ int Se = cinfo->Se;
+ int Al = cinfo->Al;
+ JBLOCKROW block;
+
+ entropy->next_output_byte = cinfo->dest->next_output_byte;
+ entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+ /* Emit restart marker if needed */
+ if (cinfo->restart_interval)
+ if (entropy->restarts_to_go == 0)
+ emit_restart(entropy, entropy->next_restart_num);
+
+ /* Encode the MCU data block */
+ block = MCU_data[0];
+
+ /* Encode the AC coefficients per section G.1.2.2, fig. G.3 */
+
+ r = 0; /* r = run length of zeros */
+
+ for (k = cinfo->Ss; k <= Se; k++) {
+ if ((temp = (*block)[jpeg_natural_order[k]]) == 0) {
+ r++;
+ continue;
+ }
+ /* We must apply the point transform by Al. For AC coefficients this
+ * is an integer division with rounding towards 0. To do this portably
+ * in C, we shift after obtaining the absolute value; so the code is
+ * interwoven with finding the abs value (temp) and output bits (temp2).
+ */
+ if (temp < 0) {
+ temp = -temp; /* temp is abs value of input */
+ temp >>= Al; /* apply the point transform */
+ /* For a negative coef, want temp2 = bitwise complement of abs(coef) */
+ temp2 = ~temp;
+ } else {
+ temp >>= Al; /* apply the point transform */
+ temp2 = temp;
+ }
+ /* Watch out for case that nonzero coef is zero after point transform */
+ if (temp == 0) {
+ r++;
+ continue;
+ }
+
+ /* Emit any pending EOBRUN */
+ if (entropy->EOBRUN > 0)
+ emit_eobrun(entropy);
+ /* if run length > 15, must emit special run-length-16 codes (0xF0) */
+ while (r > 15) {
+ emit_symbol(entropy, entropy->ac_tbl_no, 0xF0);
+ r -= 16;
+ }
+
+ /* Find the number of bits needed for the magnitude of the coefficient */
+ nbits = 1; /* there must be at least one 1 bit */
+ while ((temp >>= 1))
+ nbits++;
+ /* Check for out-of-range coefficient values */
+ if (nbits > MAX_COEF_BITS)
+ ERREXIT(cinfo, JERR_BAD_DCT_COEF);
+
+ /* Count/emit Huffman symbol for run length / number of bits */
+ emit_symbol(entropy, entropy->ac_tbl_no, (r << 4) + nbits);
+
+ /* Emit that number of bits of the value, if positive, */
+ /* or the complement of its magnitude, if negative. */
+ emit_bits(entropy, (unsigned int) temp2, nbits);
+
+ r = 0; /* reset zero run length */
+ }
+
+ if (r > 0) { /* If there are trailing zeroes, */
+ entropy->EOBRUN++; /* count an EOB */
+ if (entropy->EOBRUN == 0x7FFF)
+ emit_eobrun(entropy); /* force it out to avoid overflow */
+ }
+
+ cinfo->dest->next_output_byte = entropy->next_output_byte;
+ cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+
+ /* Update restart-interval state too */
+ if (cinfo->restart_interval) {
+ if (entropy->restarts_to_go == 0) {
+ entropy->restarts_to_go = cinfo->restart_interval;
+ entropy->next_restart_num++;
+ entropy->next_restart_num &= 7;
+ }
+ entropy->restarts_to_go--;
+ }
+
+ return TRUE;
+}
+
+
+/*
+ * MCU encoding for DC successive approximation refinement scan.
+ * Note: we assume such scans can be multi-component, although the spec
+ * is not very clear on the point.
+ */
+
+METHODDEF(boolean)
+encode_mcu_DC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+ phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+ register int temp;
+ int blkn;
+ int Al = cinfo->Al;
+ JBLOCKROW block;
+
+ entropy->next_output_byte = cinfo->dest->next_output_byte;
+ entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+ /* Emit restart marker if needed */
+ if (cinfo->restart_interval)
+ if (entropy->restarts_to_go == 0)
+ emit_restart(entropy, entropy->next_restart_num);
+
+ /* Encode the MCU data blocks */
+ for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+ block = MCU_data[blkn];
+
+ /* We simply emit the Al'th bit of the DC coefficient value. */
+ temp = (*block)[0];
+ emit_bits(entropy, (unsigned int) (temp >> Al), 1);
+ }
+
+ cinfo->dest->next_output_byte = entropy->next_output_byte;
+ cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+
+ /* Update restart-interval state too */
+ if (cinfo->restart_interval) {
+ if (entropy->restarts_to_go == 0) {
+ entropy->restarts_to_go = cinfo->restart_interval;
+ entropy->next_restart_num++;
+ entropy->next_restart_num &= 7;
+ }
+ entropy->restarts_to_go--;
+ }
+
+ return TRUE;
+}
+
+
+/*
+ * MCU encoding for AC successive approximation refinement scan.
+ */
+
+METHODDEF(boolean)
+encode_mcu_AC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+ phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+ register int temp;
+ register int r, k;
+ int EOB;
+ char *BR_buffer;
+ unsigned int BR;
+ int Se = cinfo->Se;
+ int Al = cinfo->Al;
+ JBLOCKROW block;
+ int absvalues[DCTSIZE2];
+
+ entropy->next_output_byte = cinfo->dest->next_output_byte;
+ entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+ /* Emit restart marker if needed */
+ if (cinfo->restart_interval)
+ if (entropy->restarts_to_go == 0)
+ emit_restart(entropy, entropy->next_restart_num);
+
+ /* Encode the MCU data block */
+ block = MCU_data[0];
+
+ /* It is convenient to make a pre-pass to determine the transformed
+ * coefficients' absolute values and the EOB position.
+ */
+ EOB = 0;
+ for (k = cinfo->Ss; k <= Se; k++) {
+ temp = (*block)[jpeg_natural_order[k]];
+ /* We must apply the point transform by Al. For AC coefficients this
+ * is an integer division with rounding towards 0. To do this portably
+ * in C, we shift after obtaining the absolute value.
+ */
+ if (temp < 0)
+ temp = -temp; /* temp is abs value of input */
+ temp >>= Al; /* apply the point transform */
+ absvalues[k] = temp; /* save abs value for main pass */
+ if (temp == 1)
+ EOB = k; /* EOB = index of last newly-nonzero coef */
+ }
+
+ /* Encode the AC coefficients per section G.1.2.3, fig. G.7 */
+
+ r = 0; /* r = run length of zeros */
+ BR = 0; /* BR = count of buffered bits added now */
+ BR_buffer = entropy->bit_buffer + entropy->BE; /* Append bits to buffer */
+
+ for (k = cinfo->Ss; k <= Se; k++) {
+ if ((temp = absvalues[k]) == 0) {
+ r++;
+ continue;
+ }
+
+ /* Emit any required ZRLs, but not if they can be folded into EOB */
+ while (r > 15 && k <= EOB) {
+ /* emit any pending EOBRUN and the BE correction bits */
+ emit_eobrun(entropy);
+ /* Emit ZRL */
+ emit_symbol(entropy, entropy->ac_tbl_no, 0xF0);
+ r -= 16;
+ /* Emit buffered correction bits that must be associated with ZRL */
+ emit_buffered_bits(entropy, BR_buffer, BR);
+ BR_buffer = entropy->bit_buffer; /* BE bits are gone now */
+ BR = 0;
+ }
+
+ /* If the coef was previously nonzero, it only needs a correction bit.
+ * NOTE: a straight translation of the spec's figure G.7 would suggest
+ * that we also need to test r > 15. But if r > 15, we can only get here
+ * if k > EOB, which implies that this coefficient is not 1.
+ */
+ if (temp > 1) {
+ /* The correction bit is the next bit of the absolute value. */
+ BR_buffer[BR++] = (char) (temp & 1);
+ continue;
+ }
+
+ /* Emit any pending EOBRUN and the BE correction bits */
+ emit_eobrun(entropy);
+
+ /* Count/emit Huffman symbol for run length / number of bits */
+ emit_symbol(entropy, entropy->ac_tbl_no, (r << 4) + 1);
+
+ /* Emit output bit for newly-nonzero coef */
+ temp = ((*block)[jpeg_natural_order[k]] < 0) ? 0 : 1;
+ emit_bits(entropy, (unsigned int) temp, 1);
+
+ /* Emit buffered correction bits that must be associated with this code */
+ emit_buffered_bits(entropy, BR_buffer, BR);
+ BR_buffer = entropy->bit_buffer; /* BE bits are gone now */
+ BR = 0;
+ r = 0; /* reset zero run length */
+ }
+
+ if (r > 0 || BR > 0) { /* If there are trailing zeroes, */
+ entropy->EOBRUN++; /* count an EOB */
+ entropy->BE += BR; /* concat my correction bits to older ones */
+ /* We force out the EOB if we risk either:
+ * 1. overflow of the EOB counter;
+ * 2. overflow of the correction bit buffer during the next MCU.
+ */
+ if (entropy->EOBRUN == 0x7FFF || entropy->BE > (MAX_CORR_BITS-DCTSIZE2+1))
+ emit_eobrun(entropy);
+ }
+
+ cinfo->dest->next_output_byte = entropy->next_output_byte;
+ cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+
+ /* Update restart-interval state too */
+ if (cinfo->restart_interval) {
+ if (entropy->restarts_to_go == 0) {
+ entropy->restarts_to_go = cinfo->restart_interval;
+ entropy->next_restart_num++;
+ entropy->next_restart_num &= 7;
+ }
+ entropy->restarts_to_go--;
+ }
+
+ return TRUE;
+}
+
+
+/*
+ * Finish up at the end of a Huffman-compressed progressive scan.
+ */
+
+METHODDEF(void)
+finish_pass_phuff (j_compress_ptr cinfo)
+{
+ phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+
+ entropy->next_output_byte = cinfo->dest->next_output_byte;
+ entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+ /* Flush out any buffered data */
+ emit_eobrun(entropy);
+ flush_bits(entropy);
+
+ cinfo->dest->next_output_byte = entropy->next_output_byte;
+ cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+}
+
+
+/*
+ * Finish up a statistics-gathering pass and create the new Huffman tables.
+ */
+
+METHODDEF(void)
+finish_pass_gather_phuff (j_compress_ptr cinfo)
+{
+ phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+ boolean is_DC_band;
+ int ci, tbl;
+ jpeg_component_info * compptr;
+ JHUFF_TBL **htblptr;
+ boolean did[NUM_HUFF_TBLS];
+
+ /* Flush out buffered data (all we care about is counting the EOB symbol) */
+ emit_eobrun(entropy);
+
+ is_DC_band = (cinfo->Ss == 0);
+
+ /* It's important not to apply jpeg_gen_optimal_table more than once
+ * per table, because it clobbers the input frequency counts!
+ */
+ MEMZERO(did, SIZEOF(did));
+
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ if (is_DC_band) {
+ if (cinfo->Ah != 0) /* DC refinement needs no table */
+ continue;
+ tbl = compptr->dc_tbl_no;
+ } else {
+ tbl = compptr->ac_tbl_no;
+ }
+ if (! did[tbl]) {
+ if (is_DC_band)
+ htblptr = & cinfo->dc_huff_tbl_ptrs[tbl];
+ else
+ htblptr = & cinfo->ac_huff_tbl_ptrs[tbl];
+ if (*htblptr == NULL)
+ *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
+ jpeg_gen_optimal_table(cinfo, *htblptr, entropy->count_ptrs[tbl]);
+ did[tbl] = TRUE;
+ }
+ }
+}
+
+
+/*
+ * Module initialization routine for progressive Huffman entropy encoding.
+ */
+
+GLOBAL(void)
+jinit_phuff_encoder (j_compress_ptr cinfo)
+{
+ phuff_entropy_ptr entropy;
+ int i;
+
+ entropy = (phuff_entropy_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(phuff_entropy_encoder));
+ cinfo->entropy = (struct jpeg_entropy_encoder *) entropy;
+ entropy->pub.start_pass = start_pass_phuff;
+
+ /* Mark tables unallocated */
+ for (i = 0; i < NUM_HUFF_TBLS; i++) {
+ entropy->derived_tbls[i] = NULL;
+ entropy->count_ptrs[i] = NULL;
+ }
+ entropy->bit_buffer = NULL; /* needed only in AC refinement scan */
+}
+
+#endif /* C_PROGRESSIVE_SUPPORTED */
--- /dev/null
+/*
+ * jcprepct.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * 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 the compression preprocessing controller.
+ * This controller manages the color conversion, downsampling,
+ * and edge expansion steps.
+ *
+ * Most of the complexity here is associated with buffering input rows
+ * as required by the downsampler. See the comments at the head of
+ * jcsample.c for the downsampler's needs.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* At present, jcsample.c can request context rows only for smoothing.
+ * In the future, we might also need context rows for CCIR601 sampling
+ * or other more-complex downsampling procedures. The code to support
+ * context rows should be compiled only if needed.
+ */
+#ifdef INPUT_SMOOTHING_SUPPORTED
+#define CONTEXT_ROWS_SUPPORTED
+#endif
+
+
+/*
+ * For the simple (no-context-row) case, we just need to buffer one
+ * row group's worth of pixels for the downsampling step. At the bottom of
+ * the image, we pad to a full row group by replicating the last pixel row.
+ * The downsampler's last output row is then replicated if needed to pad
+ * out to a full iMCU row.
+ *
+ * When providing context rows, we must buffer three row groups' worth of
+ * pixels. Three row groups are physically allocated, but the row pointer
+ * arrays are made five row groups high, with the extra pointers above and
+ * below "wrapping around" to point to the last and first real row groups.
+ * This allows the downsampler to access the proper context rows.
+ * At the top and bottom of the image, we create dummy context rows by
+ * copying the first or last real pixel row. This copying could be avoided
+ * by pointer hacking as is done in jdmainct.c, but it doesn't seem worth the
+ * trouble on the compression side.
+ */
+
+
+/* Private buffer controller object */
+
+typedef struct {
+ struct jpeg_c_prep_controller pub; /* public fields */
+
+ /* Downsampling input buffer. This buffer holds color-converted data
+ * until we have enough to do a downsample step.
+ */
+ JSAMPARRAY color_buf[MAX_COMPONENTS];
+
+ JDIMENSION rows_to_go; /* counts rows remaining in source image */
+ int next_buf_row; /* index of next row to store in color_buf */
+
+#ifdef CONTEXT_ROWS_SUPPORTED /* only needed for context case */
+ int this_row_group; /* starting row index of group to process */
+ int next_buf_stop; /* downsample when we reach this index */
+#endif
+} my_prep_controller;
+
+typedef my_prep_controller * my_prep_ptr;
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF(void)
+start_pass_prep (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+ my_prep_ptr prep = (my_prep_ptr) cinfo->prep;
+
+ if (pass_mode != JBUF_PASS_THRU)
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+
+ /* Initialize total-height counter for detecting bottom of image */
+ prep->rows_to_go = cinfo->image_height;
+ /* Mark the conversion buffer empty */
+ prep->next_buf_row = 0;
+#ifdef CONTEXT_ROWS_SUPPORTED
+ /* Preset additional state variables for context mode.
+ * These aren't used in non-context mode, so we needn't test which mode.
+ */
+ prep->this_row_group = 0;
+ /* Set next_buf_stop to stop after two row groups have been read in. */
+ prep->next_buf_stop = 2 * cinfo->max_v_samp_factor;
+#endif
+}
+
+
+/*
+ * Expand an image vertically from height input_rows to height output_rows,
+ * by duplicating the bottom row.
+ */
+
+LOCAL(void)
+expand_bottom_edge (JSAMPARRAY image_data, JDIMENSION num_cols,
+ int input_rows, int output_rows)
+{
+ register int row;
+
+ for (row = input_rows; row < output_rows; row++) {
+ jcopy_sample_rows(image_data, input_rows-1, image_data, row,
+ 1, num_cols);
+ }
+}
+
+
+/*
+ * Process some data in the simple no-context case.
+ *
+ * Preprocessor output data is counted in "row groups". A row group
+ * is defined to be v_samp_factor sample rows of each component.
+ * Downsampling will produce this much data from each max_v_samp_factor
+ * input rows.
+ */
+
+METHODDEF(void)
+pre_process_data (j_compress_ptr cinfo,
+ JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+ JDIMENSION in_rows_avail,
+ JSAMPIMAGE output_buf, JDIMENSION *out_row_group_ctr,
+ JDIMENSION out_row_groups_avail)
+{
+ my_prep_ptr prep = (my_prep_ptr) cinfo->prep;
+ int numrows, ci;
+ JDIMENSION inrows;
+ jpeg_component_info * compptr;
+
+ while (*in_row_ctr < in_rows_avail &&
+ *out_row_group_ctr < out_row_groups_avail) {
+ /* Do color conversion to fill the conversion buffer. */
+ inrows = in_rows_avail - *in_row_ctr;
+ numrows = cinfo->max_v_samp_factor - prep->next_buf_row;
+ numrows = (int) MIN((JDIMENSION) numrows, inrows);
+ (*cinfo->cconvert->color_convert) (cinfo, input_buf + *in_row_ctr,
+ prep->color_buf,
+ (JDIMENSION) prep->next_buf_row,
+ numrows);
+ *in_row_ctr += numrows;
+ prep->next_buf_row += numrows;
+ prep->rows_to_go -= numrows;
+ /* If at bottom of image, pad to fill the conversion buffer. */
+ if (prep->rows_to_go == 0 &&
+ prep->next_buf_row < cinfo->max_v_samp_factor) {
+ for (ci = 0; ci < cinfo->num_components; ci++) {
+ expand_bottom_edge(prep->color_buf[ci], cinfo->image_width,
+ prep->next_buf_row, cinfo->max_v_samp_factor);
+ }
+ prep->next_buf_row = cinfo->max_v_samp_factor;
+ }
+ /* If we've filled the conversion buffer, empty it. */
+ if (prep->next_buf_row == cinfo->max_v_samp_factor) {
+ (*cinfo->downsample->downsample) (cinfo,
+ prep->color_buf, (JDIMENSION) 0,
+ output_buf, *out_row_group_ctr);
+ prep->next_buf_row = 0;
+ (*out_row_group_ctr)++;
+ }
+ /* If at bottom of image, pad the output to a full iMCU height.
+ * Note we assume the caller is providing a one-iMCU-height output buffer!
+ */
+ if (prep->rows_to_go == 0 &&
+ *out_row_group_ctr < out_row_groups_avail) {
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ expand_bottom_edge(output_buf[ci],
+ compptr->width_in_blocks * DCTSIZE,
+ (int) (*out_row_group_ctr * compptr->v_samp_factor),
+ (int) (out_row_groups_avail * compptr->v_samp_factor));
+ }
+ *out_row_group_ctr = out_row_groups_avail;
+ break; /* can exit outer loop without test */
+ }
+ }
+}
+
+
+#ifdef CONTEXT_ROWS_SUPPORTED
+
+/*
+ * Process some data in the context case.
+ */
+
+METHODDEF(void)
+pre_process_context (j_compress_ptr cinfo,
+ JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+ JDIMENSION in_rows_avail,
+ JSAMPIMAGE output_buf, JDIMENSION *out_row_group_ctr,
+ JDIMENSION out_row_groups_avail)
+{
+ my_prep_ptr prep = (my_prep_ptr) cinfo->prep;
+ int numrows, ci;
+ int buf_height = cinfo->max_v_samp_factor * 3;
+ JDIMENSION inrows;
+
+ while (*out_row_group_ctr < out_row_groups_avail) {
+ if (*in_row_ctr < in_rows_avail) {
+ /* Do color conversion to fill the conversion buffer. */
+ inrows = in_rows_avail - *in_row_ctr;
+ numrows = prep->next_buf_stop - prep->next_buf_row;
+ numrows = (int) MIN((JDIMENSION) numrows, inrows);
+ (*cinfo->cconvert->color_convert) (cinfo, input_buf + *in_row_ctr,
+ prep->color_buf,
+ (JDIMENSION) prep->next_buf_row,
+ numrows);
+ /* Pad at top of image, if first time through */
+ if (prep->rows_to_go == cinfo->image_height) {
+ for (ci = 0; ci < cinfo->num_components; ci++) {
+ int row;
+ for (row = 1; row <= cinfo->max_v_samp_factor; row++) {
+ jcopy_sample_rows(prep->color_buf[ci], 0,
+ prep->color_buf[ci], -row,
+ 1, cinfo->image_width);
+ }
+ }
+ }
+ *in_row_ctr += numrows;
+ prep->next_buf_row += numrows;
+ prep->rows_to_go -= numrows;
+ } else {
+ /* Return for more data, unless we are at the bottom of the image. */
+ if (prep->rows_to_go != 0)
+ break;
+ /* When at bottom of image, pad to fill the conversion buffer. */
+ if (prep->next_buf_row < prep->next_buf_stop) {
+ for (ci = 0; ci < cinfo->num_components; ci++) {
+ expand_bottom_edge(prep->color_buf[ci], cinfo->image_width,
+ prep->next_buf_row, prep->next_buf_stop);
+ }
+ prep->next_buf_row = prep->next_buf_stop;
+ }
+ }
+ /* If we've gotten enough data, downsample a row group. */
+ if (prep->next_buf_row == prep->next_buf_stop) {
+ (*cinfo->downsample->downsample) (cinfo,
+ prep->color_buf,
+ (JDIMENSION) prep->this_row_group,
+ output_buf, *out_row_group_ctr);
+ (*out_row_group_ctr)++;
+ /* Advance pointers with wraparound as necessary. */
+ prep->this_row_group += cinfo->max_v_samp_factor;
+ if (prep->this_row_group >= buf_height)
+ prep->this_row_group = 0;
+ if (prep->next_buf_row >= buf_height)
+ prep->next_buf_row = 0;
+ prep->next_buf_stop = prep->next_buf_row + cinfo->max_v_samp_factor;
+ }
+ }
+}
+
+
+/*
+ * Create the wrapped-around downsampling input buffer needed for context mode.
+ */
+
+LOCAL(void)
+create_context_buffer (j_compress_ptr cinfo)
+{
+ my_prep_ptr prep = (my_prep_ptr) cinfo->prep;
+ int rgroup_height = cinfo->max_v_samp_factor;
+ int ci, i;
+ jpeg_component_info * compptr;
+ JSAMPARRAY true_buffer, fake_buffer;
+
+ /* Grab enough space for fake row pointers for all the components;
+ * we need five row groups' worth of pointers for each component.
+ */
+ fake_buffer = (JSAMPARRAY)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (cinfo->num_components * 5 * rgroup_height) *
+ SIZEOF(JSAMPROW));
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ /* Allocate the actual buffer space (3 row groups) for this component.
+ * We make the buffer wide enough to allow the downsampler to edge-expand
+ * horizontally within the buffer, if it so chooses.
+ */
+ true_buffer = (*cinfo->mem->alloc_sarray)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (JDIMENSION) (((long) compptr->width_in_blocks * DCTSIZE *
+ cinfo->max_h_samp_factor) / compptr->h_samp_factor),
+ (JDIMENSION) (3 * rgroup_height));
+ /* Copy true buffer row pointers into the middle of the fake row array */
+ MEMCOPY(fake_buffer + rgroup_height, true_buffer,
+ 3 * rgroup_height * SIZEOF(JSAMPROW));
+ /* Fill in the above and below wraparound pointers */
+ for (i = 0; i < rgroup_height; i++) {
+ fake_buffer[i] = true_buffer[2 * rgroup_height + i];
+ fake_buffer[4 * rgroup_height + i] = true_buffer[i];
+ }
+ prep->color_buf[ci] = fake_buffer + rgroup_height;
+ fake_buffer += 5 * rgroup_height; /* point to space for next component */
+ }
+}
+
+#endif /* CONTEXT_ROWS_SUPPORTED */
+
+
+/*
+ * Initialize preprocessing controller.
+ */
+
+GLOBAL(void)
+jinit_c_prep_controller (j_compress_ptr cinfo, boolean need_full_buffer)
+{
+ my_prep_ptr prep;
+ int ci;
+ jpeg_component_info * compptr;
+
+ if (need_full_buffer) /* safety check */
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+
+ prep = (my_prep_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_prep_controller));
+ cinfo->prep = (struct jpeg_c_prep_controller *) prep;
+ prep->pub.start_pass = start_pass_prep;
+
+ /* Allocate the color conversion buffer.
+ * We make the buffer wide enough to allow the downsampler to edge-expand
+ * horizontally within the buffer, if it so chooses.
+ */
+ if (cinfo->downsample->need_context_rows) {
+ /* Set up to provide context rows */
+#ifdef CONTEXT_ROWS_SUPPORTED
+ prep->pub.pre_process_data = pre_process_context;
+ create_context_buffer(cinfo);
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+ } else {
+ /* No context, just make it tall enough for one row group */
+ prep->pub.pre_process_data = pre_process_data;
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ prep->color_buf[ci] = (*cinfo->mem->alloc_sarray)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (JDIMENSION) (((long) compptr->width_in_blocks * DCTSIZE *
+ cinfo->max_h_samp_factor) / compptr->h_samp_factor),
+ (JDIMENSION) cinfo->max_v_samp_factor);
+ }
+ }
+}
--- /dev/null
+/*
+ * jcsample.c
+ *
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * 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 downsampling routines.
+ *
+ * Downsampling input data is counted in "row groups". A row group
+ * is defined to be max_v_samp_factor pixel rows of each component,
+ * from which the downsampler produces v_samp_factor sample rows.
+ * A single row group is processed in each call to the downsampler module.
+ *
+ * The downsampler is responsible for edge-expansion of its output data
+ * to fill an integral number of DCT blocks horizontally. The source buffer
+ * may be modified if it is helpful for this purpose (the source buffer is
+ * allocated wide enough to correspond to the desired output width).
+ * The caller (the prep controller) is responsible for vertical padding.
+ *
+ * The downsampler may request "context rows" by setting need_context_rows
+ * during startup. In this case, the input arrays will contain at least
+ * one row group's worth of pixels above and below the passed-in data;
+ * the caller will create dummy rows at image top and bottom by replicating
+ * the first or last real pixel row.
+ *
+ * An excellent reference for image resampling is
+ * Digital Image Warping, George Wolberg, 1990.
+ * Pub. by IEEE Computer Society Press, Los Alamitos, CA. ISBN 0-8186-8944-7.
+ *
+ * The downsampling algorithm used here is a simple average of the source
+ * pixels covered by the output pixel. The hi-falutin sampling literature
+ * refers to this as a "box filter". In general the characteristics of a box
+ * filter are not very good, but for the specific cases we normally use (1:1
+ * and 2:1 ratios) the box is equivalent to a "triangle filter" which is not
+ * nearly so bad. If you intend to use other sampling ratios, you'd be well
+ * advised to improve this code.
+ *
+ * A simple input-smoothing capability is provided. This is mainly intended
+ * for cleaning up color-dithered GIF input files (if you find it inadequate,
+ * we suggest using an external filtering program such as pnmconvol). When
+ * enabled, each input pixel P is replaced by a weighted sum of itself and its
+ * eight neighbors. P's weight is 1-8*SF and each neighbor's weight is SF,
+ * where SF = (smoothing_factor / 1024).
+ * Currently, smoothing is only supported for 2h2v sampling factors.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Pointer to routine to downsample a single component */
+typedef JMETHOD(void, downsample1_ptr,
+ (j_compress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY input_data, JSAMPARRAY output_data));
+
+/* Private subobject */
+
+typedef struct {
+ struct jpeg_downsampler pub; /* public fields */
+
+ /* Downsampling method pointers, one per component */
+ downsample1_ptr methods[MAX_COMPONENTS];
+} my_downsampler;
+
+typedef my_downsampler * my_downsample_ptr;
+
+
+/*
+ * Initialize for a downsampling pass.
+ */
+
+METHODDEF(void)
+start_pass_downsample (j_compress_ptr cinfo)
+{
+ /* no work for now */
+}
+
+
+/*
+ * Expand a component horizontally from width input_cols to width output_cols,
+ * by duplicating the rightmost samples.
+ */
+
+LOCAL(void)
+expand_right_edge (JSAMPARRAY image_data, int num_rows,
+ JDIMENSION input_cols, JDIMENSION output_cols)
+{
+ register JSAMPROW ptr;
+ register JSAMPLE pixval;
+ register int count;
+ int row;
+ int numcols = (int) (output_cols - input_cols);
+
+ if (numcols > 0) {
+ for (row = 0; row < num_rows; row++) {
+ ptr = image_data[row] + input_cols;
+ pixval = ptr[-1]; /* don't need GETJSAMPLE() here */
+ for (count = numcols; count > 0; count--)
+ *ptr++ = pixval;
+ }
+ }
+}
+
+
+/*
+ * Do downsampling for a whole row group (all components).
+ *
+ * In this version we simply downsample each component independently.
+ */
+
+METHODDEF(void)
+sep_downsample (j_compress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION in_row_index,
+ JSAMPIMAGE output_buf, JDIMENSION out_row_group_index)
+{
+ my_downsample_ptr downsample = (my_downsample_ptr) cinfo->downsample;
+ int ci;
+ jpeg_component_info * compptr;
+ JSAMPARRAY in_ptr, out_ptr;
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ in_ptr = input_buf[ci] + in_row_index;
+ out_ptr = output_buf[ci] + (out_row_group_index * compptr->v_samp_factor);
+ (*downsample->methods[ci]) (cinfo, compptr, in_ptr, out_ptr);
+ }
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * One row group is processed per call.
+ * This version handles arbitrary integral sampling ratios, without smoothing.
+ * Note that this version is not actually used for customary sampling ratios.
+ */
+
+METHODDEF(void)
+int_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+ int inrow, outrow, h_expand, v_expand, numpix, numpix2, h, v;
+ JDIMENSION outcol, outcol_h; /* outcol_h == outcol*h_expand */
+ JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+ JSAMPROW inptr, outptr;
+ INT32 outvalue;
+
+ h_expand = cinfo->max_h_samp_factor / compptr->h_samp_factor;
+ v_expand = cinfo->max_v_samp_factor / compptr->v_samp_factor;
+ numpix = h_expand * v_expand;
+ numpix2 = numpix/2;
+
+ /* Expand input data enough to let all the output samples be generated
+ * by the standard loop. Special-casing padded output would be more
+ * efficient.
+ */
+ expand_right_edge(input_data, cinfo->max_v_samp_factor,
+ cinfo->image_width, output_cols * h_expand);
+
+ inrow = 0;
+ for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+ outptr = output_data[outrow];
+ for (outcol = 0, outcol_h = 0; outcol < output_cols;
+ outcol++, outcol_h += h_expand) {
+ outvalue = 0;
+ for (v = 0; v < v_expand; v++) {
+ inptr = input_data[inrow+v] + outcol_h;
+ for (h = 0; h < h_expand; h++) {
+ outvalue += (INT32) GETJSAMPLE(*inptr++);
+ }
+ }
+ *outptr++ = (JSAMPLE) ((outvalue + numpix2) / numpix);
+ }
+ inrow += v_expand;
+ }
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the special case of a full-size component,
+ * without smoothing.
+ */
+
+METHODDEF(void)
+fullsize_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+ /* Copy the data */
+ jcopy_sample_rows(input_data, 0, output_data, 0,
+ cinfo->max_v_samp_factor, cinfo->image_width);
+ /* Edge-expand */
+ expand_right_edge(output_data, cinfo->max_v_samp_factor,
+ cinfo->image_width, compptr->width_in_blocks * DCTSIZE);
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the common case of 2:1 horizontal and 1:1 vertical,
+ * without smoothing.
+ *
+ * A note about the "bias" calculations: when rounding fractional values to
+ * integer, we do not want to always round 0.5 up to the next integer.
+ * If we did that, we'd introduce a noticeable bias towards larger values.
+ * Instead, this code is arranged so that 0.5 will be rounded up or down at
+ * alternate pixel locations (a simple ordered dither pattern).
+ */
+
+METHODDEF(void)
+h2v1_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+ int outrow;
+ JDIMENSION outcol;
+ JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+ register JSAMPROW inptr, outptr;
+ register int bias;
+
+ /* Expand input data enough to let all the output samples be generated
+ * by the standard loop. Special-casing padded output would be more
+ * efficient.
+ */
+ expand_right_edge(input_data, cinfo->max_v_samp_factor,
+ cinfo->image_width, output_cols * 2);
+
+ for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+ outptr = output_data[outrow];
+ inptr = input_data[outrow];
+ bias = 0; /* bias = 0,1,0,1,... for successive samples */
+ for (outcol = 0; outcol < output_cols; outcol++) {
+ *outptr++ = (JSAMPLE) ((GETJSAMPLE(*inptr) + GETJSAMPLE(inptr[1])
+ + bias) >> 1);
+ bias ^= 1; /* 0=>1, 1=>0 */
+ inptr += 2;
+ }
+ }
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the standard case of 2:1 horizontal and 2:1 vertical,
+ * without smoothing.
+ */
+
+METHODDEF(void)
+h2v2_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+ int inrow, outrow;
+ JDIMENSION outcol;
+ JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+ register JSAMPROW inptr0, inptr1, outptr;
+ register int bias;
+
+ /* Expand input data enough to let all the output samples be generated
+ * by the standard loop. Special-casing padded output would be more
+ * efficient.
+ */
+ expand_right_edge(input_data, cinfo->max_v_samp_factor,
+ cinfo->image_width, output_cols * 2);
+
+ inrow = 0;
+ for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+ outptr = output_data[outrow];
+ inptr0 = input_data[inrow];
+ inptr1 = input_data[inrow+1];
+ bias = 1; /* bias = 1,2,1,2,... for successive samples */
+ for (outcol = 0; outcol < output_cols; outcol++) {
+ *outptr++ = (JSAMPLE) ((GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
+ GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1])
+ + bias) >> 2);
+ bias ^= 3; /* 1=>2, 2=>1 */
+ inptr0 += 2; inptr1 += 2;
+ }
+ inrow += 2;
+ }
+}
+
+
+#ifdef INPUT_SMOOTHING_SUPPORTED
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the standard case of 2:1 horizontal and 2:1 vertical,
+ * with smoothing. One row of context is required.
+ */
+
+METHODDEF(void)
+h2v2_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+ int inrow, outrow;
+ JDIMENSION colctr;
+ JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+ register JSAMPROW inptr0, inptr1, above_ptr, below_ptr, outptr;
+ INT32 membersum, neighsum, memberscale, neighscale;
+
+ /* Expand input data enough to let all the output samples be generated
+ * by the standard loop. Special-casing padded output would be more
+ * efficient.
+ */
+ expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2,
+ cinfo->image_width, output_cols * 2);
+
+ /* We don't bother to form the individual "smoothed" input pixel values;
+ * we can directly compute the output which is the average of the four
+ * smoothed values. Each of the four member pixels contributes a fraction
+ * (1-8*SF) to its own smoothed image and a fraction SF to each of the three
+ * other smoothed pixels, therefore a total fraction (1-5*SF)/4 to the final
+ * output. The four corner-adjacent neighbor pixels contribute a fraction
+ * SF to just one smoothed pixel, or SF/4 to the final output; while the
+ * eight edge-adjacent neighbors contribute SF to each of two smoothed
+ * pixels, or SF/2 overall. In order to use integer arithmetic, these
+ * factors are scaled by 2^16 = 65536.
+ * Also recall that SF = smoothing_factor / 1024.
+ */
+
+ memberscale = 16384 - cinfo->smoothing_factor * 80; /* scaled (1-5*SF)/4 */
+ neighscale = cinfo->smoothing_factor * 16; /* scaled SF/4 */
+
+ inrow = 0;
+ for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+ outptr = output_data[outrow];
+ inptr0 = input_data[inrow];
+ inptr1 = input_data[inrow+1];
+ above_ptr = input_data[inrow-1];
+ below_ptr = input_data[inrow+2];
+
+ /* Special case for first column: pretend column -1 is same as column 0 */
+ membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
+ GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
+ neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
+ GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
+ GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[2]) +
+ GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[2]);
+ neighsum += neighsum;
+ neighsum += GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[2]) +
+ GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[2]);
+ membersum = membersum * memberscale + neighsum * neighscale;
+ *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
+ inptr0 += 2; inptr1 += 2; above_ptr += 2; below_ptr += 2;
+
+ for (colctr = output_cols - 2; colctr > 0; colctr--) {
+ /* sum of pixels directly mapped to this output element */
+ membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
+ GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
+ /* sum of edge-neighbor pixels */
+ neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
+ GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
+ GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[2]) +
+ GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[2]);
+ /* The edge-neighbors count twice as much as corner-neighbors */
+ neighsum += neighsum;
+ /* Add in the corner-neighbors */
+ neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[2]) +
+ GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[2]);
+ /* form final output scaled up by 2^16 */
+ membersum = membersum * memberscale + neighsum * neighscale;
+ /* round, descale and output it */
+ *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
+ inptr0 += 2; inptr1 += 2; above_ptr += 2; below_ptr += 2;
+ }
+
+ /* Special case for last column */
+ membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
+ GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
+ neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
+ GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
+ GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[1]) +
+ GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[1]);
+ neighsum += neighsum;
+ neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[1]) +
+ GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[1]);
+ membersum = membersum * memberscale + neighsum * neighscale;
+ *outptr = (JSAMPLE) ((membersum + 32768) >> 16);
+
+ inrow += 2;
+ }
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the special case of a full-size component,
+ * with smoothing. One row of context is required.
+ */
+
+METHODDEF(void)
+fullsize_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info *compptr,
+ JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+ int outrow;
+ JDIMENSION colctr;
+ JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+ register JSAMPROW inptr, above_ptr, below_ptr, outptr;
+ INT32 membersum, neighsum, memberscale, neighscale;
+ int colsum, lastcolsum, nextcolsum;
+
+ /* Expand input data enough to let all the output samples be generated
+ * by the standard loop. Special-casing padded output would be more
+ * efficient.
+ */
+ expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2,
+ cinfo->image_width, output_cols);
+
+ /* Each of the eight neighbor pixels contributes a fraction SF to the
+ * smoothed pixel, while the main pixel contributes (1-8*SF). In order
+ * to use integer arithmetic, these factors are multiplied by 2^16 = 65536.
+ * Also recall that SF = smoothing_factor / 1024.
+ */
+
+ memberscale = 65536L - cinfo->smoothing_factor * 512L; /* scaled 1-8*SF */
+ neighscale = cinfo->smoothing_factor * 64; /* scaled SF */
+
+ for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+ outptr = output_data[outrow];
+ inptr = input_data[outrow];
+ above_ptr = input_data[outrow-1];
+ below_ptr = input_data[outrow+1];
+
+ /* Special case for first column */
+ colsum = GETJSAMPLE(*above_ptr++) + GETJSAMPLE(*below_ptr++) +
+ GETJSAMPLE(*inptr);
+ membersum = GETJSAMPLE(*inptr++);
+ nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) +
+ GETJSAMPLE(*inptr);
+ neighsum = colsum + (colsum - membersum) + nextcolsum;
+ membersum = membersum * memberscale + neighsum * neighscale;
+ *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
+ lastcolsum = colsum; colsum = nextcolsum;
+
+ for (colctr = output_cols - 2; colctr > 0; colctr--) {
+ membersum = GETJSAMPLE(*inptr++);
+ above_ptr++; below_ptr++;
+ nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) +
+ GETJSAMPLE(*inptr);
+ neighsum = lastcolsum + (colsum - membersum) + nextcolsum;
+ membersum = membersum * memberscale + neighsum * neighscale;
+ *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
+ lastcolsum = colsum; colsum = nextcolsum;
+ }
+
+ /* Special case for last column */
+ membersum = GETJSAMPLE(*inptr);
+ neighsum = lastcolsum + (colsum - membersum) + colsum;
+ membersum = membersum * memberscale + neighsum * neighscale;
+ *outptr = (JSAMPLE) ((membersum + 32768) >> 16);
+
+ }
+}
+
+#endif /* INPUT_SMOOTHING_SUPPORTED */
+
+
+/*
+ * Module initialization routine for downsampling.
+ * Note that we must select a routine for each component.
+ */
+
+GLOBAL(void)
+jinit_downsampler (j_compress_ptr cinfo)
+{
+ my_downsample_ptr downsample;
+ int ci;
+ jpeg_component_info * compptr;
+ boolean smoothok = TRUE;
+
+ downsample = (my_downsample_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_downsampler));
+ cinfo->downsample = (struct jpeg_downsampler *) downsample;
+ downsample->pub.start_pass = start_pass_downsample;
+ downsample->pub.downsample = sep_downsample;
+ downsample->pub.need_context_rows = FALSE;
+
+ if (cinfo->CCIR601_sampling)
+ ERREXIT(cinfo, JERR_CCIR601_NOTIMPL);
+
+ /* Verify we can handle the sampling factors, and set up method pointers */
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ if (compptr->h_samp_factor == cinfo->max_h_samp_factor &&
+ compptr->v_samp_factor == cinfo->max_v_samp_factor) {
+#ifdef INPUT_SMOOTHING_SUPPORTED
+ if (cinfo->smoothing_factor) {
+ downsample->methods[ci] = fullsize_smooth_downsample;
+ downsample->pub.need_context_rows = TRUE;
+ } else
+#endif
+ downsample->methods[ci] = fullsize_downsample;
+ } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor &&
+ compptr->v_samp_factor == cinfo->max_v_samp_factor) {
+ smoothok = FALSE;
+ downsample->methods[ci] = h2v1_downsample;
+ } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor &&
+ compptr->v_samp_factor * 2 == cinfo->max_v_samp_factor) {
+#ifdef INPUT_SMOOTHING_SUPPORTED
+ if (cinfo->smoothing_factor) {
+ downsample->methods[ci] = h2v2_smooth_downsample;
+ downsample->pub.need_context_rows = TRUE;
+ } else
+#endif
+ downsample->methods[ci] = h2v2_downsample;
+ } else if ((cinfo->max_h_samp_factor % compptr->h_samp_factor) == 0 &&
+ (cinfo->max_v_samp_factor % compptr->v_samp_factor) == 0) {
+ smoothok = FALSE;
+ downsample->methods[ci] = int_downsample;
+ } else
+ ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL);
+ }
+
+#ifdef INPUT_SMOOTHING_SUPPORTED
+ if (cinfo->smoothing_factor && !smoothok)
+ TRACEMS(cinfo, 0, JTRC_SMOOTH_NOTIMPL);
+#endif
+}
--- /dev/null
+/*
+ * jctrans.c
+ *
+ * Copyright (C) 1995-1998, Thomas G. Lane.
+ * 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 library routines for transcoding compression,
+ * that is, writing raw DCT coefficient arrays to an output JPEG file.
+ * The routines in jcapimin.c will also be needed by a transcoder.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Forward declarations */
+LOCAL(void) transencode_master_selection
+ JPP((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays));
+LOCAL(void) transencode_coef_controller
+ JPP((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays));
+
+
+/*
+ * Compression initialization for writing raw-coefficient data.
+ * Before calling this, all parameters and a data destination must be set up.
+ * Call jpeg_finish_compress() to actually write the data.
+ *
+ * The number of passed virtual arrays must match cinfo->num_components.
+ * Note that the virtual arrays need not be filled or even realized at
+ * the time write_coefficients is called; indeed, if the virtual arrays
+ * were requested from this compression object's memory manager, they
+ * typically will be realized during this routine and filled afterwards.
+ */
+
+GLOBAL(void)
+jpeg_write_coefficients (j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays)
+{
+ if (cinfo->global_state != CSTATE_START)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+ /* Mark all tables to be written */
+ jpeg_suppress_tables(cinfo, FALSE);
+ /* (Re)initialize error mgr and destination modules */
+ (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
+ (*cinfo->dest->init_destination) (cinfo);
+ /* Perform master selection of active modules */
+ transencode_master_selection(cinfo, coef_arrays);
+ /* Wait for jpeg_finish_compress() call */
+ cinfo->next_scanline = 0; /* so jpeg_write_marker works */
+ cinfo->global_state = CSTATE_WRCOEFS;
+}
+
+
+/*
+ * Initialize the compression object with default parameters,
+ * then copy from the source object all parameters needed for lossless
+ * transcoding. Parameters that can be varied without loss (such as
+ * scan script and Huffman optimization) are left in their default states.
+ */
+
+GLOBAL(void)
+jpeg_copy_critical_parameters (j_decompress_ptr srcinfo,
+ j_compress_ptr dstinfo)
+{
+ JQUANT_TBL ** qtblptr;
+ jpeg_component_info *incomp, *outcomp;
+ JQUANT_TBL *c_quant, *slot_quant;
+ int tblno, ci, coefi;
+
+ /* Safety check to ensure start_compress not called yet. */
+ if (dstinfo->global_state != CSTATE_START)
+ ERREXIT1(dstinfo, JERR_BAD_STATE, dstinfo->global_state);
+ /* Copy fundamental image dimensions */
+ dstinfo->image_width = srcinfo->image_width;
+ dstinfo->image_height = srcinfo->image_height;
+ dstinfo->input_components = srcinfo->num_components;
+ dstinfo->in_color_space = srcinfo->jpeg_color_space;
+ /* Initialize all parameters to default values */
+ jpeg_set_defaults(dstinfo);
+ /* jpeg_set_defaults may choose wrong colorspace, eg YCbCr if input is RGB.
+ * Fix it to get the right header markers for the image colorspace.
+ */
+ jpeg_set_colorspace(dstinfo, srcinfo->jpeg_color_space);
+ dstinfo->data_precision = srcinfo->data_precision;
+ dstinfo->CCIR601_sampling = srcinfo->CCIR601_sampling;
+ /* Copy the source's quantization tables. */
+ for (tblno = 0; tblno < NUM_QUANT_TBLS; tblno++) {
+ if (srcinfo->quant_tbl_ptrs[tblno] != NULL) {
+ qtblptr = & dstinfo->quant_tbl_ptrs[tblno];
+ if (*qtblptr == NULL)
+ *qtblptr = jpeg_alloc_quant_table((j_common_ptr) dstinfo);
+ MEMCOPY((*qtblptr)->quantval,
+ srcinfo->quant_tbl_ptrs[tblno]->quantval,
+ SIZEOF((*qtblptr)->quantval));
+ (*qtblptr)->sent_table = FALSE;
+ }
+ }
+ /* Copy the source's per-component info.
+ * Note we assume jpeg_set_defaults has allocated the dest comp_info array.
+ */
+ dstinfo->num_components = srcinfo->num_components;
+ if (dstinfo->num_components < 1 || dstinfo->num_components > MAX_COMPONENTS)
+ ERREXIT2(dstinfo, JERR_COMPONENT_COUNT, dstinfo->num_components,
+ MAX_COMPONENTS);
+ for (ci = 0, incomp = srcinfo->comp_info, outcomp = dstinfo->comp_info;
+ ci < dstinfo->num_components; ci++, incomp++, outcomp++) {
+ outcomp->component_id = incomp->component_id;
+ outcomp->h_samp_factor = incomp->h_samp_factor;
+ outcomp->v_samp_factor = incomp->v_samp_factor;
+ outcomp->quant_tbl_no = incomp->quant_tbl_no;
+ /* Make sure saved quantization table for component matches the qtable
+ * slot. If not, the input file re-used this qtable slot.
+ * IJG encoder currently cannot duplicate this.
+ */
+ tblno = outcomp->quant_tbl_no;
+ if (tblno < 0 || tblno >= NUM_QUANT_TBLS ||
+ srcinfo->quant_tbl_ptrs[tblno] == NULL)
+ ERREXIT1(dstinfo, JERR_NO_QUANT_TABLE, tblno);
+ slot_quant = srcinfo->quant_tbl_ptrs[tblno];
+ c_quant = incomp->quant_table;
+ if (c_quant != NULL) {
+ for (coefi = 0; coefi < DCTSIZE2; coefi++) {
+ if (c_quant->quantval[coefi] != slot_quant->quantval[coefi])
+ ERREXIT1(dstinfo, JERR_MISMATCHED_QUANT_TABLE, tblno);
+ }
+ }
+ /* Note: we do not copy the source's Huffman table assignments;
+ * instead we rely on jpeg_set_colorspace to have made a suitable choice.
+ */
+ }
+ /* Also copy JFIF version and resolution information, if available.
+ * Strictly speaking this isn't "critical" info, but it's nearly
+ * always appropriate to copy it if available. In particular,
+ * if the application chooses to copy JFIF 1.02 extension markers from
+ * the source file, we need to copy the version to make sure we don't
+ * emit a file that has 1.02 extensions but a claimed version of 1.01.
+ * We will *not*, however, copy version info from mislabeled "2.01" files.
+ */
+ if (srcinfo->saw_JFIF_marker) {
+ if (srcinfo->JFIF_major_version == 1) {
+ dstinfo->JFIF_major_version = srcinfo->JFIF_major_version;
+ dstinfo->JFIF_minor_version = srcinfo->JFIF_minor_version;
+ }
+ dstinfo->density_unit = srcinfo->density_unit;
+ dstinfo->X_density = srcinfo->X_density;
+ dstinfo->Y_density = srcinfo->Y_density;
+ }
+}
+
+
+/*
+ * Master selection of compression modules for transcoding.
+ * This substitutes for jcinit.c's initialization of the full compressor.
+ */
+
+LOCAL(void)
+transencode_master_selection (j_compress_ptr cinfo,
+ jvirt_barray_ptr * coef_arrays)
+{
+ /* Although we don't actually use input_components for transcoding,
+ * jcmaster.c's initial_setup will complain if input_components is 0.
+ */
+ cinfo->input_components = 1;
+ /* Initialize master control (includes parameter checking/processing) */
+ jinit_c_master_control(cinfo, TRUE /* transcode only */);
+
+ /* Entropy encoding: either Huffman or arithmetic coding. */
+ if (cinfo->arith_code) {
+ ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
+ } else {
+ if (cinfo->progressive_mode) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+ jinit_phuff_encoder(cinfo);
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+ } else
+ jinit_huff_encoder(cinfo);
+ }
+
+ /* We need a special coefficient buffer controller. */
+ transencode_coef_controller(cinfo, coef_arrays);
+
+ jinit_marker_writer(cinfo);
+
+ /* We can now tell the memory manager to allocate virtual arrays. */
+ (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo);
+
+ /* Write the datastream header (SOI, JFIF) immediately.
+ * Frame and scan headers are postponed till later.
+ * This lets application insert special markers after the SOI.
+ */
+ (*cinfo->marker->write_file_header) (cinfo);
+}
+
+
+/*
+ * The rest of this file is a special implementation of the coefficient
+ * buffer controller. This is similar to jccoefct.c, but it handles only
+ * output from presupplied virtual arrays. Furthermore, we generate any
+ * dummy padding blocks on-the-fly rather than expecting them to be present
+ * in the arrays.
+ */
+
+/* Private buffer controller object */
+
+typedef struct {
+ struct jpeg_c_coef_controller pub; /* public fields */
+
+ JDIMENSION iMCU_row_num; /* iMCU row # within image */
+ JDIMENSION mcu_ctr; /* counts MCUs processed in current row */
+ int MCU_vert_offset; /* counts MCU rows within iMCU row */
+ int MCU_rows_per_iMCU_row; /* number of such rows needed */
+
+ /* Virtual block array for each component. */
+ jvirt_barray_ptr * whole_image;
+
+ /* Workspace for constructing dummy blocks at right/bottom edges. */
+ JBLOCKROW dummy_buffer[C_MAX_BLOCKS_IN_MCU];
+} my_coef_controller;
+
+typedef my_coef_controller * my_coef_ptr;
+
+
+LOCAL(void)
+start_iMCU_row (j_compress_ptr cinfo)
+/* Reset within-iMCU-row counters for a new row */
+{
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+ /* In an interleaved scan, an MCU row is the same as an iMCU row.
+ * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
+ * But at the bottom of the image, process only what's left.
+ */
+ if (cinfo->comps_in_scan > 1) {
+ coef->MCU_rows_per_iMCU_row = 1;
+ } else {
+ if (coef->iMCU_row_num < (cinfo->total_iMCU_rows-1))
+ coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
+ else
+ coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
+ }
+
+ coef->mcu_ctr = 0;
+ coef->MCU_vert_offset = 0;
+}
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF(void)
+start_pass_coef (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+ if (pass_mode != JBUF_CRANK_DEST)
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+
+ coef->iMCU_row_num = 0;
+ start_iMCU_row(cinfo);
+}
+
+
+/*
+ * Process some data.
+ * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
+ * per call, ie, v_samp_factor block rows for each component in the scan.
+ * The data is obtained from the virtual arrays and fed to the entropy coder.
+ * Returns TRUE if the iMCU row is completed, FALSE if suspended.
+ *
+ * NB: input_buf is ignored; it is likely to be a NULL pointer.
+ */
+
+METHODDEF(boolean)
+compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+{
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+ JDIMENSION MCU_col_num; /* index of current MCU within row */
+ JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
+ JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+ int blkn, ci, xindex, yindex, yoffset, blockcnt;
+ JDIMENSION start_col;
+ JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
+ JBLOCKROW MCU_buffer[C_MAX_BLOCKS_IN_MCU];
+ JBLOCKROW buffer_ptr;
+ jpeg_component_info *compptr;
+
+ /* Align the virtual buffers for the components used in this scan. */
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ buffer[ci] = (*cinfo->mem->access_virt_barray)
+ ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index],
+ coef->iMCU_row_num * compptr->v_samp_factor,
+ (JDIMENSION) compptr->v_samp_factor, FALSE);
+ }
+
+ /* Loop to process one whole iMCU row */
+ for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+ yoffset++) {
+ for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row;
+ MCU_col_num++) {
+ /* Construct list of pointers to DCT blocks belonging to this MCU */
+ blkn = 0; /* index of current DCT block within MCU */
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ start_col = MCU_col_num * compptr->MCU_width;
+ blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
+ : compptr->last_col_width;
+ for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+ if (coef->iMCU_row_num < last_iMCU_row ||
+ yindex+yoffset < compptr->last_row_height) {
+ /* Fill in pointers to real blocks in this row */
+ buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
+ for (xindex = 0; xindex < blockcnt; xindex++)
+ MCU_buffer[blkn++] = buffer_ptr++;
+ } else {
+ /* At bottom of image, need a whole row of dummy blocks */
+ xindex = 0;
+ }
+ /* Fill in any dummy blocks needed in this row.
+ * Dummy blocks are filled in the same way as in jccoefct.c:
+ * all zeroes in the AC entries, DC entries equal to previous
+ * block's DC value. The init routine has already zeroed the
+ * AC entries, so we need only set the DC entries correctly.
+ */
+ for (; xindex < compptr->MCU_width; xindex++) {
+ MCU_buffer[blkn] = coef->dummy_buffer[blkn];
+ MCU_buffer[blkn][0][0] = MCU_buffer[blkn-1][0][0];
+ blkn++;
+ }
+ }
+ }
+ /* Try to write the MCU. */
+ if (! (*cinfo->entropy->encode_mcu) (cinfo, MCU_buffer)) {
+ /* Suspension forced; update state counters and exit */
+ coef->MCU_vert_offset = yoffset;
+ coef->mcu_ctr = MCU_col_num;
+ return FALSE;
+ }
+ }
+ /* Completed an MCU row, but perhaps not an iMCU row */
+ coef->mcu_ctr = 0;
+ }
+ /* Completed the iMCU row, advance counters for next one */
+ coef->iMCU_row_num++;
+ start_iMCU_row(cinfo);
+ return TRUE;
+}
+
+
+/*
+ * Initialize coefficient buffer controller.
+ *
+ * Each passed coefficient array must be the right size for that
+ * coefficient: width_in_blocks wide and height_in_blocks high,
+ * with unitheight at least v_samp_factor.
+ */
+
+LOCAL(void)
+transencode_coef_controller (j_compress_ptr cinfo,
+ jvirt_barray_ptr * coef_arrays)
+{
+ my_coef_ptr coef;
+ JBLOCKROW buffer;
+ int i;
+
+ coef = (my_coef_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_coef_controller));
+ cinfo->coef = (struct jpeg_c_coef_controller *) coef;
+ coef->pub.start_pass = start_pass_coef;
+ coef->pub.compress_data = compress_output;
+
+ /* Save pointer to virtual arrays */
+ coef->whole_image = coef_arrays;
+
+ /* Allocate and pre-zero space for dummy DCT blocks. */
+ buffer = (JBLOCKROW)
+ (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+ jzero_far((void FAR *) buffer, C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+ for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
+ coef->dummy_buffer[i] = buffer + i;
+ }
+}
--- /dev/null
+/*
+ * jdapimin.c
+ *
+ * Copyright (C) 1994-1998, Thomas G. Lane.
+ * 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 code for the decompression half
+ * of the JPEG library. These are the "minimum" API routines that may be
+ * needed in either the normal full-decompression case or the
+ * transcoding-only case.
+ *
+ * Most of the routines intended to be called directly by an application
+ * are in this file or in jdapistd.c. But also see jcomapi.c for routines
+ * shared by compression and decompression, and jdtrans.c for the transcoding
+ * case.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Initialization of a JPEG decompression object.
+ * The error manager must already be set up (in case memory manager fails).
+ */
+
+GLOBAL(void)
+jpeg_CreateDecompress (j_decompress_ptr cinfo, int version, size_t structsize)
+{
+ int i;
+
+ /* Guard against version mismatches between library and caller. */
+ cinfo->mem = NULL; /* so jpeg_destroy knows mem mgr not called */
+ if (version != JPEG_LIB_VERSION)
+ ERREXIT2(cinfo, JERR_BAD_LIB_VERSION, JPEG_LIB_VERSION, version);
+ if (structsize != SIZEOF(struct jpeg_decompress_struct))
+ ERREXIT2(cinfo, JERR_BAD_STRUCT_SIZE,
+ (int) SIZEOF(struct jpeg_decompress_struct), (int) structsize);
+
+ /* For debugging purposes, we zero the whole master structure.
+ * But the application has already set the err pointer, and may have set
+ * client_data, so we have to save and restore those fields.
+ * Note: if application hasn't set client_data, tools like Purify may
+ * complain here.
+ */
+ {
+ struct jpeg_error_mgr * err = cinfo->err;
+ void * client_data = cinfo->client_data; /* ignore Purify complaint here */
+ MEMZERO(cinfo, SIZEOF(struct jpeg_decompress_struct));
+ cinfo->err = err;
+ cinfo->client_data = client_data;
+ }
+ cinfo->is_decompressor = TRUE;
+
+ /* Initialize a memory manager instance for this object */
+ jinit_memory_mgr((j_common_ptr) cinfo);
+
+ /* Zero out pointers to permanent structures. */
+ cinfo->progress = NULL;
+ cinfo->src = NULL;
+
+ for (i = 0; i < NUM_QUANT_TBLS; i++)
+ cinfo->quant_tbl_ptrs[i] = NULL;
+
+ for (i = 0; i < NUM_HUFF_TBLS; i++) {
+ cinfo->dc_huff_tbl_ptrs[i] = NULL;
+ cinfo->ac_huff_tbl_ptrs[i] = NULL;
+ }
+
+ /* Initialize marker processor so application can override methods
+ * for COM, APPn markers before calling jpeg_read_header.
+ */
+ cinfo->marker_list = NULL;
+ jinit_marker_reader(cinfo);
+
+ /* And initialize the overall input controller. */
+ jinit_input_controller(cinfo);
+
+ /* OK, I'm ready */
+ cinfo->global_state = DSTATE_START;
+}
+
+
+/*
+ * Destruction of a JPEG decompression object
+ */
+
+GLOBAL(void)
+jpeg_destroy_decompress (j_decompress_ptr cinfo)
+{
+ jpeg_destroy((j_common_ptr) cinfo); /* use common routine */
+}
+
+
+/*
+ * Abort processing of a JPEG decompression operation,
+ * but don't destroy the object itself.
+ */
+
+GLOBAL(void)
+jpeg_abort_decompress (j_decompress_ptr cinfo)
+{
+ jpeg_abort((j_common_ptr) cinfo); /* use common routine */
+}
+
+
+/*
+ * Set default decompression parameters.
+ */
+
+LOCAL(void)
+default_decompress_parms (j_decompress_ptr cinfo)
+{
+ /* Guess the input colorspace, and set output colorspace accordingly. */
+ /* (Wish JPEG committee had provided a real way to specify this...) */
+ /* Note application may override our guesses. */
+ switch (cinfo->num_components) {
+ case 1:
+ cinfo->jpeg_color_space = JCS_GRAYSCALE;
+ cinfo->out_color_space = JCS_GRAYSCALE;
+ break;
+
+ case 3:
+ if (cinfo->saw_JFIF_marker) {
+ cinfo->jpeg_color_space = JCS_YCbCr; /* JFIF implies YCbCr */
+ } else if (cinfo->saw_Adobe_marker) {
+ switch (cinfo->Adobe_transform) {
+ case 0:
+ cinfo->jpeg_color_space = JCS_RGB;
+ break;
+ case 1:
+ cinfo->jpeg_color_space = JCS_YCbCr;
+ break;
+ default:
+ WARNMS1(cinfo, JWRN_ADOBE_XFORM, cinfo->Adobe_transform);
+ cinfo->jpeg_color_space = JCS_YCbCr; /* assume it's YCbCr */
+ break;
+ }
+ } else {
+ /* Saw no special markers, try to guess from the component IDs */
+ int cid0 = cinfo->comp_info[0].component_id;
+ int cid1 = cinfo->comp_info[1].component_id;
+ int cid2 = cinfo->comp_info[2].component_id;
+
+ if (cid0 == 1 && cid1 == 2 && cid2 == 3)
+ cinfo->jpeg_color_space = JCS_YCbCr; /* assume JFIF w/out marker */
+ else if (cid0 == 82 && cid1 == 71 && cid2 == 66)
+ cinfo->jpeg_color_space = JCS_RGB; /* ASCII 'R', 'G', 'B' */
+ else {
+ TRACEMS3(cinfo, 1, JTRC_UNKNOWN_IDS, cid0, cid1, cid2);
+ cinfo->jpeg_color_space = JCS_YCbCr; /* assume it's YCbCr */
+ }
+ }
+ /* Always guess RGB is proper output colorspace. */
+ cinfo->out_color_space = JCS_RGB;
+ break;
+
+ case 4:
+ if (cinfo->saw_Adobe_marker) {
+ switch (cinfo->Adobe_transform) {
+ case 0:
+ cinfo->jpeg_color_space = JCS_CMYK;
+ break;
+ case 2:
+ cinfo->jpeg_color_space = JCS_YCCK;
+ break;
+ default:
+ WARNMS1(cinfo, JWRN_ADOBE_XFORM, cinfo->Adobe_transform);
+ cinfo->jpeg_color_space = JCS_YCCK; /* assume it's YCCK */
+ break;
+ }
+ } else {
+ /* No special markers, assume straight CMYK. */
+ cinfo->jpeg_color_space = JCS_CMYK;
+ }
+ cinfo->out_color_space = JCS_CMYK;
+ break;
+
+ default:
+ cinfo->jpeg_color_space = JCS_UNKNOWN;
+ cinfo->out_color_space = JCS_UNKNOWN;
+ break;
+ }
+
+ /* Set defaults for other decompression parameters. */
+ cinfo->scale_num = 1; /* 1:1 scaling */
+ cinfo->scale_denom = 1;
+ cinfo->output_gamma = 1.0;
+ cinfo->buffered_image = FALSE;
+ cinfo->raw_data_out = FALSE;
+ cinfo->dct_method = JDCT_DEFAULT;
+ cinfo->do_fancy_upsampling = TRUE;
+ cinfo->do_block_smoothing = TRUE;
+ cinfo->quantize_colors = FALSE;
+ /* We set these in case application only sets quantize_colors. */
+ cinfo->dither_mode = JDITHER_FS;
+#ifdef QUANT_2PASS_SUPPORTED
+ cinfo->two_pass_quantize = TRUE;
+#else
+ cinfo->two_pass_quantize = FALSE;
+#endif
+ cinfo->desired_number_of_colors = 256;
+ cinfo->colormap = NULL;
+ /* Initialize for no mode change in buffered-image mode. */
+ cinfo->enable_1pass_quant = FALSE;
+ cinfo->enable_external_quant = FALSE;
+ cinfo->enable_2pass_quant = FALSE;
+}
+
+
+/*
+ * Decompression startup: read start of JPEG datastream to see what's there.
+ * Need only initialize JPEG object and supply a data source before calling.
+ *
+ * This routine will read as far as the first SOS marker (ie, actual start of
+ * compressed data), and will save all tables and parameters in the JPEG
+ * object. It will also initialize the decompression parameters to default
+ * values, and finally return JPEG_HEADER_OK. On return, the application may
+ * adjust the decompression parameters and then call jpeg_start_decompress.
+ * (Or, if the application only wanted to determine the image parameters,
+ * the data need not be decompressed. In that case, call jpeg_abort or
+ * jpeg_destroy to release any temporary space.)
+ * If an abbreviated (tables only) datastream is presented, the routine will
+ * return JPEG_HEADER_TABLES_ONLY upon reaching EOI. The application may then
+ * re-use the JPEG object to read the abbreviated image datastream(s).
+ * It is unnecessary (but OK) to call jpeg_abort in this case.
+ * The JPEG_SUSPENDED return code only occurs if the data source module
+ * requests suspension of the decompressor. In this case the application
+ * should load more source data and then re-call jpeg_read_header to resume
+ * processing.
+ * If a non-suspending data source is used and require_image is TRUE, then the
+ * return code need not be inspected since only JPEG_HEADER_OK is possible.
+ *
+ * This routine is now just a front end to jpeg_consume_input, with some
+ * extra error checking.
+ */
+
+GLOBAL(int)
+jpeg_read_header (j_decompress_ptr cinfo, boolean require_image)
+{
+ int retcode;
+
+ if (cinfo->global_state != DSTATE_START &&
+ cinfo->global_state != DSTATE_INHEADER)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+ retcode = jpeg_consume_input(cinfo);
+
+ switch (retcode) {
+ case JPEG_REACHED_SOS:
+ retcode = JPEG_HEADER_OK;
+ break;
+ case JPEG_REACHED_EOI:
+ if (require_image) /* Complain if application wanted an image */
+ ERREXIT(cinfo, JERR_NO_IMAGE);
+ /* Reset to start state; it would be safer to require the application to
+ * call jpeg_abort, but we can't change it now for compatibility reasons.
+ * A side effect is to free any temporary memory (there shouldn't be any).
+ */
+ jpeg_abort((j_common_ptr) cinfo); /* sets state = DSTATE_START */
+ retcode = JPEG_HEADER_TABLES_ONLY;
+ break;
+ case JPEG_SUSPENDED:
+ /* no work */
+ break;
+ }
+
+ return retcode;
+}
+
+
+/*
+ * Consume data in advance of what the decompressor requires.
+ * This can be called at any time once the decompressor object has
+ * been created and a data source has been set up.
+ *
+ * This routine is essentially a state machine that handles a couple
+ * of critical state-transition actions, namely initial setup and
+ * transition from header scanning to ready-for-start_decompress.
+ * All the actual input is done via the input controller's consume_input
+ * method.
+ */
+
+GLOBAL(int)
+jpeg_consume_input (j_decompress_ptr cinfo)
+{
+ int retcode = JPEG_SUSPENDED;
+
+ /* NB: every possible DSTATE value should be listed in this switch */
+ switch (cinfo->global_state) {
+ case DSTATE_START:
+ /* Start-of-datastream actions: reset appropriate modules */
+ (*cinfo->inputctl->reset_input_controller) (cinfo);
+ /* Initialize application's data source module */
+ (*cinfo->src->init_source) (cinfo);
+ cinfo->global_state = DSTATE_INHEADER;
+ /*FALLTHROUGH*/
+ case DSTATE_INHEADER:
+ retcode = (*cinfo->inputctl->consume_input) (cinfo);
+ if (retcode == JPEG_REACHED_SOS) { /* Found SOS, prepare to decompress */
+ /* Set up default parameters based on header data */
+ default_decompress_parms(cinfo);
+ /* Set global state: ready for start_decompress */
+ cinfo->global_state = DSTATE_READY;
+ }
+ break;
+ case DSTATE_READY:
+ /* Can't advance past first SOS until start_decompress is called */
+ retcode = JPEG_REACHED_SOS;
+ break;
+ case DSTATE_PRELOAD:
+ case DSTATE_PRESCAN:
+ case DSTATE_SCANNING:
+ case DSTATE_RAW_OK:
+ case DSTATE_BUFIMAGE:
+ case DSTATE_BUFPOST:
+ case DSTATE_STOPPING:
+ retcode = (*cinfo->inputctl->consume_input) (cinfo);
+ break;
+ default:
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+ }
+ return retcode;
+}
+
+
+/*
+ * Have we finished reading the input file?
+ */
+
+GLOBAL(boolean)
+jpeg_input_complete (j_decompress_ptr cinfo)
+{
+ /* Check for valid jpeg object */
+ if (cinfo->global_state < DSTATE_START ||
+ cinfo->global_state > DSTATE_STOPPING)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+ return cinfo->inputctl->eoi_reached;
+}
+
+
+/*
+ * Is there more than one scan?
+ */
+
+GLOBAL(boolean)
+jpeg_has_multiple_scans (j_decompress_ptr cinfo)
+{
+ /* Only valid after jpeg_read_header completes */
+ if (cinfo->global_state < DSTATE_READY ||
+ cinfo->global_state > DSTATE_STOPPING)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+ return cinfo->inputctl->has_multiple_scans;
+}
+
+
+/*
+ * Finish JPEG decompression.
+ *
+ * This will normally just verify the file trailer and release temp storage.
+ *
+ * Returns FALSE if suspended. The return value need be inspected only if
+ * a suspending data source is used.
+ */
+
+GLOBAL(boolean)
+jpeg_finish_decompress (j_decompress_ptr cinfo)
+{
+ if ((cinfo->global_state == DSTATE_SCANNING ||
+ cinfo->global_state == DSTATE_RAW_OK) && ! cinfo->buffered_image) {
+ /* Terminate final pass of non-buffered mode */
+ if (cinfo->output_scanline < cinfo->output_height)
+ ERREXIT(cinfo, JERR_TOO_LITTLE_DATA);
+ (*cinfo->master->finish_output_pass) (cinfo);
+ cinfo->global_state = DSTATE_STOPPING;
+ } else if (cinfo->global_state == DSTATE_BUFIMAGE) {
+ /* Finishing after a buffered-image operation */
+ cinfo->global_state = DSTATE_STOPPING;
+ } else if (cinfo->global_state != DSTATE_STOPPING) {
+ /* STOPPING = repeat call after a suspension, anything else is error */
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+ }
+ /* Read until EOI */
+ while (! cinfo->inputctl->eoi_reached) {
+ if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED)
+ return FALSE; /* Suspend, come back later */
+ }
+ /* Do final cleanup */
+ (*cinfo->src->term_source) (cinfo);
+ /* We can use jpeg_abort to release memory and reset global_state */
+ jpeg_abort((j_common_ptr) cinfo);
+ return TRUE;
+}
--- /dev/null
+/*
+ * jdapistd.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * 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 code for the decompression half
+ * of the JPEG library. These are the "standard" API routines that are
+ * used in the normal full-decompression case. They are not used by a
+ * transcoding-only application. Note that if an application links in
+ * jpeg_start_decompress, it will end up linking in the entire decompressor.
+ * We thus must separate this file from jdapimin.c to avoid linking the
+ * whole decompression library into a transcoder.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Forward declarations */
+LOCAL(boolean) output_pass_setup JPP((j_decompress_ptr cinfo));
+
+
+/*
+ * Decompression initialization.
+ * jpeg_read_header must be completed before calling this.
+ *
+ * If a multipass operating mode was selected, this will do all but the
+ * last pass, and thus may take a great deal of time.
+ *
+ * Returns FALSE if suspended. The return value need be inspected only if
+ * a suspending data source is used.
+ */
+
+GLOBAL(boolean)
+jpeg_start_decompress (j_decompress_ptr cinfo)
+{
+ if (cinfo->global_state == DSTATE_READY) {
+ /* First call: initialize master control, select active modules */
+ jinit_master_decompress(cinfo);
+ if (cinfo->buffered_image) {
+ /* No more work here; expecting jpeg_start_output next */
+ cinfo->global_state = DSTATE_BUFIMAGE;
+ return TRUE;
+ }
+ cinfo->global_state = DSTATE_PRELOAD;
+ }
+ if (cinfo->global_state == DSTATE_PRELOAD) {
+ /* If file has multiple scans, absorb them all into the coef buffer */
+ if (cinfo->inputctl->has_multiple_scans) {
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+ for (;;) {
+ int retcode;
+ /* Call progress monitor hook if present */
+ if (cinfo->progress != NULL)
+ (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+ /* Absorb some more input */
+ retcode = (*cinfo->inputctl->consume_input) (cinfo);
+ if (retcode == JPEG_SUSPENDED)
+ return FALSE;
+ if (retcode == JPEG_REACHED_EOI)
+ break;
+ /* Advance progress counter if appropriate */
+ if (cinfo->progress != NULL &&
+ (retcode == JPEG_ROW_COMPLETED || retcode == JPEG_REACHED_SOS)) {
+ if (++cinfo->progress->pass_counter >= cinfo->progress->pass_limit) {
+ /* jdmaster underestimated number of scans; ratchet up one scan */
+ cinfo->progress->pass_limit += (long) cinfo->total_iMCU_rows;
+ }
+ }
+ }
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif /* D_MULTISCAN_FILES_SUPPORTED */
+ }
+ cinfo->output_scan_number = cinfo->input_scan_number;
+ } else if (cinfo->global_state != DSTATE_PRESCAN)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+ /* Perform any dummy output passes, and set up for the final pass */
+ return output_pass_setup(cinfo);
+}
+
+
+/*
+ * Set up for an output pass, and perform any dummy pass(es) needed.
+ * Common subroutine for jpeg_start_decompress and jpeg_start_output.
+ * Entry: global_state = DSTATE_PRESCAN only if previously suspended.
+ * Exit: If done, returns TRUE and sets global_state for proper output mode.
+ * If suspended, returns FALSE and sets global_state = DSTATE_PRESCAN.
+ */
+
+LOCAL(boolean)
+output_pass_setup (j_decompress_ptr cinfo)
+{
+ if (cinfo->global_state != DSTATE_PRESCAN) {
+ /* First call: do pass setup */
+ (*cinfo->master->prepare_for_output_pass) (cinfo);
+ cinfo->output_scanline = 0;
+ cinfo->global_state = DSTATE_PRESCAN;
+ }
+ /* Loop over any required dummy passes */
+ while (cinfo->master->is_dummy_pass) {
+#ifdef QUANT_2PASS_SUPPORTED
+ /* Crank through the dummy pass */
+ while (cinfo->output_scanline < cinfo->output_height) {
+ JDIMENSION last_scanline;
+ /* Call progress monitor hook if present */
+ if (cinfo->progress != NULL) {
+ cinfo->progress->pass_counter = (long) cinfo->output_scanline;
+ cinfo->progress->pass_limit = (long) cinfo->output_height;
+ (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+ }
+ /* Process some data */
+ last_scanline = cinfo->output_scanline;
+ (*cinfo->main->process_data) (cinfo, (JSAMPARRAY) NULL,
+ &cinfo->output_scanline, (JDIMENSION) 0);
+ if (cinfo->output_scanline == last_scanline)
+ return FALSE; /* No progress made, must suspend */
+ }
+ /* Finish up dummy pass, and set up for another one */
+ (*cinfo->master->finish_output_pass) (cinfo);
+ (*cinfo->master->prepare_for_output_pass) (cinfo);
+ cinfo->output_scanline = 0;
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif /* QUANT_2PASS_SUPPORTED */
+ }
+ /* Ready for application to drive output pass through
+ * jpeg_read_scanlines or jpeg_read_raw_data.
+ */
+ cinfo->global_state = cinfo->raw_data_out ? DSTATE_RAW_OK : DSTATE_SCANNING;
+ return TRUE;
+}
+
+
+/*
+ * Read some scanlines of data from the JPEG decompressor.
+ *
+ * The return value will be the number of lines actually read.
+ * This may be less than the number requested in several cases,
+ * including bottom of image, data source suspension, and operating
+ * modes that emit multiple scanlines at a time.
+ *
+ * Note: we warn about excess calls to jpeg_read_scanlines() since
+ * this likely signals an application programmer error. However,
+ * an oversize buffer (max_lines > scanlines remaining) is not an error.
+ */
+
+GLOBAL(JDIMENSION)
+jpeg_read_scanlines (j_decompress_ptr cinfo, JSAMPARRAY scanlines,
+ JDIMENSION max_lines)
+{
+ JDIMENSION row_ctr;
+
+ if (cinfo->global_state != DSTATE_SCANNING)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+ if (cinfo->output_scanline >= cinfo->output_height) {
+ WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
+ return 0;
+ }
+
+ /* Call progress monitor hook if present */
+ if (cinfo->progress != NULL) {
+ cinfo->progress->pass_counter = (long) cinfo->output_scanline;
+ cinfo->progress->pass_limit = (long) cinfo->output_height;
+ (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+ }
+
+ /* Process some data */
+ row_ctr = 0;
+ (*cinfo->main->process_data) (cinfo, scanlines, &row_ctr, max_lines);
+ cinfo->output_scanline += row_ctr;
+ return row_ctr;
+}
+
+
+/*
+ * Alternate entry point to read raw data.
+ * Processes exactly one iMCU row per call, unless suspended.
+ */
+
+GLOBAL(JDIMENSION)
+jpeg_read_raw_data (j_decompress_ptr cinfo, JSAMPIMAGE data,
+ JDIMENSION max_lines)
+{
+ JDIMENSION lines_per_iMCU_row;
+
+ if (cinfo->global_state != DSTATE_RAW_OK)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+ if (cinfo->output_scanline >= cinfo->output_height) {
+ WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
+ return 0;
+ }
+
+ /* Call progress monitor hook if present */
+ if (cinfo->progress != NULL) {
+ cinfo->progress->pass_counter = (long) cinfo->output_scanline;
+ cinfo->progress->pass_limit = (long) cinfo->output_height;
+ (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+ }
+
+ /* Verify that at least one iMCU row can be returned. */
+ lines_per_iMCU_row = cinfo->max_v_samp_factor * cinfo->min_DCT_scaled_size;
+ if (max_lines < lines_per_iMCU_row)
+ ERREXIT(cinfo, JERR_BUFFER_SIZE);
+
+ /* Decompress directly into user's buffer. */
+ if (! (*cinfo->coef->decompress_data) (cinfo, data))
+ return 0; /* suspension forced, can do nothing more */
+
+ /* OK, we processed one iMCU row. */
+ cinfo->output_scanline += lines_per_iMCU_row;
+ return lines_per_iMCU_row;
+}
+
+
+/* Additional entry points for buffered-image mode. */
+
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+
+/*
+ * Initialize for an output pass in buffered-image mode.
+ */
+
+GLOBAL(boolean)
+jpeg_start_output (j_decompress_ptr cinfo, int scan_number)
+{
+ if (cinfo->global_state != DSTATE_BUFIMAGE &&
+ cinfo->global_state != DSTATE_PRESCAN)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+ /* Limit scan number to valid range */
+ if (scan_number <= 0)
+ scan_number = 1;
+ if (cinfo->inputctl->eoi_reached &&
+ scan_number > cinfo->input_scan_number)
+ scan_number = cinfo->input_scan_number;
+ cinfo->output_scan_number = scan_number;
+ /* Perform any dummy output passes, and set up for the real pass */
+ return output_pass_setup(cinfo);
+}
+
+
+/*
+ * Finish up after an output pass in buffered-image mode.
+ *
+ * Returns FALSE if suspended. The return value need be inspected only if
+ * a suspending data source is used.
+ */
+
+GLOBAL(boolean)
+jpeg_finish_output (j_decompress_ptr cinfo)
+{
+ if ((cinfo->global_state == DSTATE_SCANNING ||
+ cinfo->global_state == DSTATE_RAW_OK) && cinfo->buffered_image) {
+ /* Terminate this pass. */
+ /* We do not require the whole pass to have been completed. */
+ (*cinfo->master->finish_output_pass) (cinfo);
+ cinfo->global_state = DSTATE_BUFPOST;
+ } else if (cinfo->global_state != DSTATE_BUFPOST) {
+ /* BUFPOST = repeat call after a suspension, anything else is error */
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+ }
+ /* Read markers looking for SOS or EOI */
+ while (cinfo->input_scan_number <= cinfo->output_scan_number &&
+ ! cinfo->inputctl->eoi_reached) {
+ if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED)
+ return FALSE; /* Suspend, come back later */
+ }
+ cinfo->global_state = DSTATE_BUFIMAGE;
+ return TRUE;
+}
+
+#endif /* D_MULTISCAN_FILES_SUPPORTED */
--- /dev/null
+/*
+ * jdatadst.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * 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 compression data destination routines for the case of
+ * emitting JPEG data to a file (or any stdio stream). While these routines
+ * are sufficient for most applications, some will want to use a different
+ * destination manager.
+ * IMPORTANT: we assume that fwrite() will correctly transcribe an array of
+ * JOCTETs into 8-bit-wide elements on external storage. If char is wider
+ * than 8 bits on your machine, you may need to do some tweaking.
+ */
+
+/* this is not a core library module, so it doesn't define JPEG_INTERNALS */
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jerror.h"
+
+
+/* Expanded data destination object for stdio output */
+
+typedef struct {
+ struct jpeg_destination_mgr pub; /* public fields */
+
+ FILE * outfile; /* target stream */
+ JOCTET * buffer; /* start of buffer */
+} my_destination_mgr;
+
+typedef my_destination_mgr * my_dest_ptr;
+
+#define OUTPUT_BUF_SIZE 4096 /* choose an efficiently fwrite'able size */
+
+
+/*
+ * Initialize destination --- called by jpeg_start_compress
+ * before any data is actually written.
+ */
+
+METHODDEF(void)
+init_destination (j_compress_ptr cinfo)
+{
+ my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
+
+ /* Allocate the output buffer --- it will be released when done with image */
+ dest->buffer = (JOCTET *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ OUTPUT_BUF_SIZE * SIZEOF(JOCTET));
+
+ dest->pub.next_output_byte = dest->buffer;
+ dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
+}
+
+
+/*
+ * Empty the output buffer --- called whenever buffer fills up.
+ *
+ * In typical applications, this should write the entire output buffer
+ * (ignoring the current state of next_output_byte & free_in_buffer),
+ * reset the pointer & count to the start of the buffer, and return TRUE
+ * indicating that the buffer has been dumped.
+ *
+ * In applications that need to be able to suspend compression due to output
+ * overrun, a FALSE return indicates that the buffer cannot be emptied now.
+ * In this situation, the compressor will return to its caller (possibly with
+ * an indication that it has not accepted all the supplied scanlines). The
+ * application should resume compression after it has made more room in the
+ * output buffer. Note that there are substantial restrictions on the use of
+ * suspension --- see the documentation.
+ *
+ * When suspending, the compressor will back up to a convenient restart point
+ * (typically the start of the current MCU). next_output_byte & free_in_buffer
+ * indicate where the restart point will be if the current call returns FALSE.
+ * Data beyond this point will be regenerated after resumption, so do not
+ * write it out when emptying the buffer externally.
+ */
+
+METHODDEF(boolean)
+empty_output_buffer (j_compress_ptr cinfo)
+{
+ my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
+
+ if (JFWRITE(dest->outfile, dest->buffer, OUTPUT_BUF_SIZE) !=
+ (size_t) OUTPUT_BUF_SIZE)
+ ERREXIT(cinfo, JERR_FILE_WRITE);
+
+ dest->pub.next_output_byte = dest->buffer;
+ dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
+
+ return TRUE;
+}
+
+
+/*
+ * Terminate destination --- called by jpeg_finish_compress
+ * after all data has been written. Usually needs to flush buffer.
+ *
+ * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
+ * application must deal with any cleanup that should happen even
+ * for error exit.
+ */
+
+METHODDEF(void)
+term_destination (j_compress_ptr cinfo)
+{
+ my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
+ size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer;
+
+ /* Write any data remaining in the buffer */
+ if (datacount > 0) {
+ if (JFWRITE(dest->outfile, dest->buffer, datacount) != datacount)
+ ERREXIT(cinfo, JERR_FILE_WRITE);
+ }
+ fflush(dest->outfile);
+ /* Make sure we wrote the output file OK */
+ if (ferror(dest->outfile))
+ ERREXIT(cinfo, JERR_FILE_WRITE);
+}
+
+
+/*
+ * Prepare for output to a stdio stream.
+ * The caller must have already opened the stream, and is responsible
+ * for closing it after finishing compression.
+ */
+
+GLOBAL(void)
+jpeg_stdio_dest (j_compress_ptr cinfo, FILE * outfile)
+{
+ my_dest_ptr dest;
+
+ /* The destination object is made permanent so that multiple JPEG images
+ * can be written to the same file without re-executing jpeg_stdio_dest.
+ * This makes it dangerous to use this manager and a different destination
+ * manager serially with the same JPEG object, because their private object
+ * sizes may be different. Caveat programmer.
+ */
+ if (cinfo->dest == NULL) { /* first time for this JPEG object? */
+ cinfo->dest = (struct jpeg_destination_mgr *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+ SIZEOF(my_destination_mgr));
+ }
+
+ dest = (my_dest_ptr) cinfo->dest;
+ dest->pub.init_destination = init_destination;
+ dest->pub.empty_output_buffer = empty_output_buffer;
+ dest->pub.term_destination = term_destination;
+ dest->outfile = outfile;
+}
--- /dev/null
+/*
+ * jdatasrc.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * 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 decompression data source routines for the case of
+ * reading JPEG data from a file (or any stdio stream). While these routines
+ * are sufficient for most applications, some will want to use a different
+ * source manager.
+ * IMPORTANT: we assume that fread() will correctly transcribe an array of
+ * JOCTETs from 8-bit-wide elements on external storage. If char is wider
+ * than 8 bits on your machine, you may need to do some tweaking.
+ */
+
+/* this is not a core library module, so it doesn't define JPEG_INTERNALS */
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jerror.h"
+
+
+/* Expanded data source object for stdio input */
+
+typedef struct {
+ struct jpeg_source_mgr pub; /* public fields */
+
+ FILE * infile; /* source stream */
+ JOCTET * buffer; /* start of buffer */
+ boolean start_of_file; /* have we gotten any data yet? */
+} my_source_mgr;
+
+typedef my_source_mgr * my_src_ptr;
+
+#define INPUT_BUF_SIZE 4096 /* choose an efficiently fread'able size */
+
+
+/*
+ * Initialize source --- called by jpeg_read_header
+ * before any data is actually read.
+ */
+
+METHODDEF(void)
+init_source (j_decompress_ptr cinfo)
+{
+ my_src_ptr src = (my_src_ptr) cinfo->src;
+
+ /* We reset the empty-input-file flag for each image,
+ * but we don't clear the input buffer.
+ * This is correct behavior for reading a series of images from one source.
+ */
+ src->start_of_file = TRUE;
+}
+
+
+/*
+ * Fill the input buffer --- called whenever buffer is emptied.
+ *
+ * In typical applications, this should read fresh data into the buffer
+ * (ignoring the current state of next_input_byte & bytes_in_buffer),
+ * reset the pointer & count to the start of the buffer, and return TRUE
+ * indicating that the buffer has been reloaded. It is not necessary to
+ * fill the buffer entirely, only to obtain at least one more byte.
+ *
+ * There is no such thing as an EOF return. If the end of the file has been
+ * reached, the routine has a choice of ERREXIT() or inserting fake data into
+ * the buffer. In most cases, generating a warning message and inserting a
+ * fake EOI marker is the best course of action --- this will allow the
+ * decompressor to output however much of the image is there. However,
+ * the resulting error message is misleading if the real problem is an empty
+ * input file, so we handle that case specially.
+ *
+ * In applications that need to be able to suspend compression due to input
+ * not being available yet, a FALSE return indicates that no more data can be
+ * obtained right now, but more may be forthcoming later. In this situation,
+ * the decompressor will return to its caller (with an indication of the
+ * number of scanlines it has read, if any). The application should resume
+ * decompression after it has loaded more data into the input buffer. Note
+ * that there are substantial restrictions on the use of suspension --- see
+ * the documentation.
+ *
+ * When suspending, the decompressor will back up to a convenient restart point
+ * (typically the start of the current MCU). next_input_byte & bytes_in_buffer
+ * indicate where the restart point will be if the current call returns FALSE.
+ * Data beyond this point must be rescanned after resumption, so move it to
+ * the front of the buffer rather than discarding it.
+ */
+
+METHODDEF(boolean)
+fill_input_buffer (j_decompress_ptr cinfo)
+{
+ my_src_ptr src = (my_src_ptr) cinfo->src;
+ size_t nbytes;
+
+ nbytes = JFREAD(src->infile, src->buffer, INPUT_BUF_SIZE);
+
+ if (nbytes <= 0) {
+ if (src->start_of_file) /* Treat empty input file as fatal error */
+ ERREXIT(cinfo, JERR_INPUT_EMPTY);
+ WARNMS(cinfo, JWRN_JPEG_EOF);
+ /* Insert a fake EOI marker */
+ src->buffer[0] = (JOCTET) 0xFF;
+ src->buffer[1] = (JOCTET) JPEG_EOI;
+ nbytes = 2;
+ }
+
+ src->pub.next_input_byte = src->buffer;
+ src->pub.bytes_in_buffer = nbytes;
+ src->start_of_file = FALSE;
+
+ return TRUE;
+}
+
+
+/*
+ * Skip data --- used to skip over a potentially large amount of
+ * uninteresting data (such as an APPn marker).
+ *
+ * Writers of suspendable-input applications must note that skip_input_data
+ * is not granted the right to give a suspension return. If the skip extends
+ * beyond the data currently in the buffer, the buffer can be marked empty so
+ * that the next read will cause a fill_input_buffer call that can suspend.
+ * Arranging for additional bytes to be discarded before reloading the input
+ * buffer is the application writer's problem.
+ */
+
+METHODDEF(void)
+skip_input_data (j_decompress_ptr cinfo, long num_bytes)
+{
+ my_src_ptr src = (my_src_ptr) cinfo->src;
+
+ /* Just a dumb implementation for now. Could use fseek() except
+ * it doesn't work on pipes. Not clear that being smart is worth
+ * any trouble anyway --- large skips are infrequent.
+ */
+ if (num_bytes > 0) {
+ while (num_bytes > (long) src->pub.bytes_in_buffer) {
+ num_bytes -= (long) src->pub.bytes_in_buffer;
+ (void) fill_input_buffer(cinfo);
+ /* note we assume that fill_input_buffer will never return FALSE,
+ * so suspension need not be handled.
+ */
+ }
+ src->pub.next_input_byte += (size_t) num_bytes;
+ src->pub.bytes_in_buffer -= (size_t) num_bytes;
+ }
+}
+
+
+/*
+ * An additional method that can be provided by data source modules is the
+ * resync_to_restart method for error recovery in the presence of RST markers.
+ * For the moment, this source module just uses the default resync method
+ * provided by the JPEG library. That method assumes that no backtracking
+ * is possible.
+ */
+
+
+/*
+ * Terminate source --- called by jpeg_finish_decompress
+ * after all data has been read. Often a no-op.
+ *
+ * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
+ * application must deal with any cleanup that should happen even
+ * for error exit.
+ */
+
+METHODDEF(void)
+term_source (j_decompress_ptr cinfo)
+{
+ /* no work necessary here */
+}
+
+
+/*
+ * Prepare for input from a stdio stream.
+ * The caller must have already opened the stream, and is responsible
+ * for closing it after finishing decompression.
+ */
+
+GLOBAL(void)
+jpeg_stdio_src (j_decompress_ptr cinfo, FILE * infile)
+{
+ my_src_ptr src;
+
+ /* The source object and input buffer are made permanent so that a series
+ * of JPEG images can be read from the same file by calling jpeg_stdio_src
+ * only before the first one. (If we discarded the buffer at the end of
+ * one image, we'd likely lose the start of the next one.)
+ * This makes it unsafe to use this manager and a different source
+ * manager serially with the same JPEG object. Caveat programmer.
+ */
+ if (cinfo->src == NULL) { /* first time for this JPEG object? */
+ cinfo->src = (struct jpeg_source_mgr *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+ SIZEOF(my_source_mgr));
+ src = (my_src_ptr) cinfo->src;
+ src->buffer = (JOCTET *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+ INPUT_BUF_SIZE * SIZEOF(JOCTET));
+ }
+
+ src = (my_src_ptr) cinfo->src;
+ src->pub.init_source = init_source;
+ src->pub.fill_input_buffer = fill_input_buffer;
+ src->pub.skip_input_data = skip_input_data;
+ src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */
+ src->pub.term_source = term_source;
+ src->infile = infile;
+ src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */
+ src->pub.next_input_byte = NULL; /* until buffer loaded */
+}
--- /dev/null
+/*
+ * jdcoefct.c
+ *
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * 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 the coefficient buffer controller for decompression.
+ * This controller is the top level of the JPEG decompressor proper.
+ * The coefficient buffer lies between entropy decoding and inverse-DCT steps.
+ *
+ * In buffered-image mode, this controller is the interface between
+ * input-oriented processing and output-oriented processing.
+ * Also, the input side (only) is used when reading a file for transcoding.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+/* Block smoothing is only applicable for progressive JPEG, so: */
+#ifndef D_PROGRESSIVE_SUPPORTED
+#undef BLOCK_SMOOTHING_SUPPORTED
+#endif
+
+/* Private buffer controller object */
+
+typedef struct {
+ struct jpeg_d_coef_controller pub; /* public fields */
+
+ /* These variables keep track of the current location of the input side. */
+ /* cinfo->input_iMCU_row is also used for this. */
+ JDIMENSION MCU_ctr; /* counts MCUs processed in current row */
+ int MCU_vert_offset; /* counts MCU rows within iMCU row */
+ int MCU_rows_per_iMCU_row; /* number of such rows needed */
+
+ /* The output side's location is represented by cinfo->output_iMCU_row. */
+
+ /* In single-pass modes, it's sufficient to buffer just one MCU.
+ * We allocate a workspace of D_MAX_BLOCKS_IN_MCU coefficient blocks,
+ * and let the entropy decoder write into that workspace each time.
+ * (On 80x86, the workspace is FAR even though it's not really very big;
+ * this is to keep the module interfaces unchanged when a large coefficient
+ * buffer is necessary.)
+ * In multi-pass modes, this array points to the current MCU's blocks
+ * within the virtual arrays; it is used only by the input side.
+ */
+ JBLOCKROW MCU_buffer[D_MAX_BLOCKS_IN_MCU];
+
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+ /* In multi-pass modes, we need a virtual block array for each component. */
+ jvirt_barray_ptr whole_image[MAX_COMPONENTS];
+#endif
+
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+ /* When doing block smoothing, we latch coefficient Al values here */
+ int * coef_bits_latch;
+#define SAVED_COEFS 6 /* we save coef_bits[0..5] */
+#endif
+} my_coef_controller;
+
+typedef my_coef_controller * my_coef_ptr;
+
+/* Forward declarations */
+METHODDEF(int) decompress_onepass
+ JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf));
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+METHODDEF(int) decompress_data
+ JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf));
+#endif
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+LOCAL(boolean) smoothing_ok JPP((j_decompress_ptr cinfo));
+METHODDEF(int) decompress_smooth_data
+ JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf));
+#endif
+
+
+LOCAL(void)
+start_iMCU_row (j_decompress_ptr cinfo)
+/* Reset within-iMCU-row counters for a new row (input side) */
+{
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+ /* In an interleaved scan, an MCU row is the same as an iMCU row.
+ * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
+ * But at the bottom of the image, process only what's left.
+ */
+ if (cinfo->comps_in_scan > 1) {
+ coef->MCU_rows_per_iMCU_row = 1;
+ } else {
+ if (cinfo->input_iMCU_row < (cinfo->total_iMCU_rows-1))
+ coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
+ else
+ coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
+ }
+
+ coef->MCU_ctr = 0;
+ coef->MCU_vert_offset = 0;
+}
+
+
+/*
+ * Initialize for an input processing pass.
+ */
+
+METHODDEF(void)
+start_input_pass (j_decompress_ptr cinfo)
+{
+ cinfo->input_iMCU_row = 0;
+ start_iMCU_row(cinfo);
+}
+
+
+/*
+ * Initialize for an output processing pass.
+ */
+
+METHODDEF(void)
+start_output_pass (j_decompress_ptr cinfo)
+{
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+ /* If multipass, check to see whether to use block smoothing on this pass */
+ if (coef->pub.coef_arrays != NULL) {
+ if (cinfo->do_block_smoothing && smoothing_ok(cinfo))
+ coef->pub.decompress_data = decompress_smooth_data;
+ else
+ coef->pub.decompress_data = decompress_data;
+ }
+#endif
+ cinfo->output_iMCU_row = 0;
+}
+
+
+/*
+ * Decompress and return some data in the single-pass case.
+ * Always attempts to emit one fully interleaved MCU row ("iMCU" row).
+ * Input and output must run in lockstep since we have only a one-MCU buffer.
+ * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
+ *
+ * NB: output_buf contains a plane for each component in image,
+ * which we index according to the component's SOF position.
+ */
+
+METHODDEF(int)
+decompress_onepass (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
+{
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+ JDIMENSION MCU_col_num; /* index of current MCU within row */
+ JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
+ JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+ int blkn, ci, xindex, yindex, yoffset, useful_width;
+ JSAMPARRAY output_ptr;
+ JDIMENSION start_col, output_col;
+ jpeg_component_info *compptr;
+ inverse_DCT_method_ptr inverse_DCT;
+
+ /* Loop to process as much as one whole iMCU row */
+ for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+ yoffset++) {
+ for (MCU_col_num = coef->MCU_ctr; MCU_col_num <= last_MCU_col;
+ MCU_col_num++) {
+ /* Try to fetch an MCU. Entropy decoder expects buffer to be zeroed. */
+ jzero_far((void FAR *) coef->MCU_buffer[0],
+ (size_t) (cinfo->blocks_in_MCU * SIZEOF(JBLOCK)));
+ if (! (*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
+ /* Suspension forced; update state counters and exit */
+ coef->MCU_vert_offset = yoffset;
+ coef->MCU_ctr = MCU_col_num;
+ return JPEG_SUSPENDED;
+ }
+ /* Determine where data should go in output_buf and do the IDCT thing.
+ * We skip dummy blocks at the right and bottom edges (but blkn gets
+ * incremented past them!). Note the inner loop relies on having
+ * allocated the MCU_buffer[] blocks sequentially.
+ */
+ blkn = 0; /* index of current DCT block within MCU */
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ /* Don't bother to IDCT an uninteresting component. */
+ if (! compptr->component_needed) {
+ blkn += compptr->MCU_blocks;
+ continue;
+ }
+ inverse_DCT = cinfo->idct->inverse_DCT[compptr->component_index];
+ useful_width = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
+ : compptr->last_col_width;
+ output_ptr = output_buf[compptr->component_index] +
+ yoffset * compptr->DCT_scaled_size;
+ start_col = MCU_col_num * compptr->MCU_sample_width;
+ for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+ if (cinfo->input_iMCU_row < last_iMCU_row ||
+ yoffset+yindex < compptr->last_row_height) {
+ output_col = start_col;
+ for (xindex = 0; xindex < useful_width; xindex++) {
+ (*inverse_DCT) (cinfo, compptr,
+ (JCOEFPTR) coef->MCU_buffer[blkn+xindex],
+ output_ptr, output_col);
+ output_col += compptr->DCT_scaled_size;
+ }
+ }
+ blkn += compptr->MCU_width;
+ output_ptr += compptr->DCT_scaled_size;
+ }
+ }
+ }
+ /* Completed an MCU row, but perhaps not an iMCU row */
+ coef->MCU_ctr = 0;
+ }
+ /* Completed the iMCU row, advance counters for next one */
+ cinfo->output_iMCU_row++;
+ if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) {
+ start_iMCU_row(cinfo);
+ return JPEG_ROW_COMPLETED;
+ }
+ /* Completed the scan */
+ (*cinfo->inputctl->finish_input_pass) (cinfo);
+ return JPEG_SCAN_COMPLETED;
+}
+
+
+/*
+ * Dummy consume-input routine for single-pass operation.
+ */
+
+METHODDEF(int)
+dummy_consume_data (j_decompress_ptr cinfo)
+{
+ return JPEG_SUSPENDED; /* Always indicate nothing was done */
+}
+
+
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+
+/*
+ * Consume input data and store it in the full-image coefficient buffer.
+ * We read as much as one fully interleaved MCU row ("iMCU" row) per call,
+ * ie, v_samp_factor block rows for each component in the scan.
+ * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
+ */
+
+METHODDEF(int)
+consume_data (j_decompress_ptr cinfo)
+{
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+ JDIMENSION MCU_col_num; /* index of current MCU within row */
+ int blkn, ci, xindex, yindex, yoffset;
+ JDIMENSION start_col;
+ JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
+ JBLOCKROW buffer_ptr;
+ jpeg_component_info *compptr;
+
+ /* Align the virtual buffers for the components used in this scan. */
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ buffer[ci] = (*cinfo->mem->access_virt_barray)
+ ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index],
+ cinfo->input_iMCU_row * compptr->v_samp_factor,
+ (JDIMENSION) compptr->v_samp_factor, TRUE);
+ /* Note: entropy decoder expects buffer to be zeroed,
+ * but this is handled automatically by the memory manager
+ * because we requested a pre-zeroed array.
+ */
+ }
+
+ /* Loop to process one whole iMCU row */
+ for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+ yoffset++) {
+ for (MCU_col_num = coef->MCU_ctr; MCU_col_num < cinfo->MCUs_per_row;
+ MCU_col_num++) {
+ /* Construct list of pointers to DCT blocks belonging to this MCU */
+ blkn = 0; /* index of current DCT block within MCU */
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ start_col = MCU_col_num * compptr->MCU_width;
+ for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+ buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
+ for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
+ coef->MCU_buffer[blkn++] = buffer_ptr++;
+ }
+ }
+ }
+ /* Try to fetch the MCU. */
+ if (! (*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
+ /* Suspension forced; update state counters and exit */
+ coef->MCU_vert_offset = yoffset;
+ coef->MCU_ctr = MCU_col_num;
+ return JPEG_SUSPENDED;
+ }
+ }
+ /* Completed an MCU row, but perhaps not an iMCU row */
+ coef->MCU_ctr = 0;
+ }
+ /* Completed the iMCU row, advance counters for next one */
+ if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) {
+ start_iMCU_row(cinfo);
+ return JPEG_ROW_COMPLETED;
+ }
+ /* Completed the scan */
+ (*cinfo->inputctl->finish_input_pass) (cinfo);
+ return JPEG_SCAN_COMPLETED;
+}
+
+
+/*
+ * Decompress and return some data in the multi-pass case.
+ * Always attempts to emit one fully interleaved MCU row ("iMCU" row).
+ * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
+ *
+ * NB: output_buf contains a plane for each component in image.
+ */
+
+METHODDEF(int)
+decompress_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
+{
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+ JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+ JDIMENSION block_num;
+ int ci, block_row, block_rows;
+ JBLOCKARRAY buffer;
+ JBLOCKROW buffer_ptr;
+ JSAMPARRAY output_ptr;
+ JDIMENSION output_col;
+ jpeg_component_info *compptr;
+ inverse_DCT_method_ptr inverse_DCT;
+
+ /* Force some input to be done if we are getting ahead of the input. */
+ while (cinfo->input_scan_number < cinfo->output_scan_number ||
+ (cinfo->input_scan_number == cinfo->output_scan_number &&
+ cinfo->input_iMCU_row <= cinfo->output_iMCU_row)) {
+ if ((*cinfo->inputctl->consume_input)(cinfo) == JPEG_SUSPENDED)
+ return JPEG_SUSPENDED;
+ }
+
+ /* OK, output from the virtual arrays. */
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ /* Don't bother to IDCT an uninteresting component. */
+ if (! compptr->component_needed)
+ continue;
+ /* Align the virtual buffer for this component. */
+ buffer = (*cinfo->mem->access_virt_barray)
+ ((j_common_ptr) cinfo, coef->whole_image[ci],
+ cinfo->output_iMCU_row * compptr->v_samp_factor,
+ (JDIMENSION) compptr->v_samp_factor, FALSE);
+ /* Count non-dummy DCT block rows in this iMCU row. */
+ if (cinfo->output_iMCU_row < last_iMCU_row)
+ block_rows = compptr->v_samp_factor;
+ else {
+ /* NB: can't use last_row_height here; it is input-side-dependent! */
+ block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
+ if (block_rows == 0) block_rows = compptr->v_samp_factor;
+ }
+ inverse_DCT = cinfo->idct->inverse_DCT[ci];
+ output_ptr = output_buf[ci];
+ /* Loop over all DCT blocks to be processed. */
+ for (block_row = 0; block_row < block_rows; block_row++) {
+ buffer_ptr = buffer[block_row];
+ output_col = 0;
+ for (block_num = 0; block_num < compptr->width_in_blocks; block_num++) {
+ (*inverse_DCT) (cinfo, compptr, (JCOEFPTR) buffer_ptr,
+ output_ptr, output_col);
+ buffer_ptr++;
+ output_col += compptr->DCT_scaled_size;
+ }
+ output_ptr += compptr->DCT_scaled_size;
+ }
+ }
+
+ if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows)
+ return JPEG_ROW_COMPLETED;
+ return JPEG_SCAN_COMPLETED;
+}
+
+#endif /* D_MULTISCAN_FILES_SUPPORTED */
+
+
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+
+/*
+ * This code applies interblock smoothing as described by section K.8
+ * of the JPEG standard: the first 5 AC coefficients are estimated from
+ * the DC values of a DCT block and its 8 neighboring blocks.
+ * We apply smoothing only for progressive JPEG decoding, and only if
+ * the coefficients it can estimate are not yet known to full precision.
+ */
+
+/* Natural-order array positions of the first 5 zigzag-order coefficients */
+#define Q01_POS 1
+#define Q10_POS 8
+#define Q20_POS 16
+#define Q11_POS 9
+#define Q02_POS 2
+
+/*
+ * Determine whether block smoothing is applicable and safe.
+ * We also latch the current states of the coef_bits[] entries for the
+ * AC coefficients; otherwise, if the input side of the decompressor
+ * advances into a new scan, we might think the coefficients are known
+ * more accurately than they really are.
+ */
+
+LOCAL(boolean)
+smoothing_ok (j_decompress_ptr cinfo)
+{
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+ boolean smoothing_useful = FALSE;
+ int ci, coefi;
+ jpeg_component_info *compptr;
+ JQUANT_TBL * qtable;
+ int * coef_bits;
+ int * coef_bits_latch;
+
+ if (! cinfo->progressive_mode || cinfo->coef_bits == NULL)
+ return FALSE;
+
+ /* Allocate latch area if not already done */
+ if (coef->coef_bits_latch == NULL)
+ coef->coef_bits_latch = (int *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ cinfo->num_components *
+ (SAVED_COEFS * SIZEOF(int)));
+ coef_bits_latch = coef->coef_bits_latch;
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ /* All components' quantization values must already be latched. */
+ if ((qtable = compptr->quant_table) == NULL)
+ return FALSE;
+ /* Verify DC & first 5 AC quantizers are nonzero to avoid zero-divide. */
+ if (qtable->quantval[0] == 0 ||
+ qtable->quantval[Q01_POS] == 0 ||
+ qtable->quantval[Q10_POS] == 0 ||
+ qtable->quantval[Q20_POS] == 0 ||
+ qtable->quantval[Q11_POS] == 0 ||
+ qtable->quantval[Q02_POS] == 0)
+ return FALSE;
+ /* DC values must be at least partly known for all components. */
+ coef_bits = cinfo->coef_bits[ci];
+ if (coef_bits[0] < 0)
+ return FALSE;
+ /* Block smoothing is helpful if some AC coefficients remain inaccurate. */
+ for (coefi = 1; coefi <= 5; coefi++) {
+ coef_bits_latch[coefi] = coef_bits[coefi];
+ if (coef_bits[coefi] != 0)
+ smoothing_useful = TRUE;
+ }
+ coef_bits_latch += SAVED_COEFS;
+ }
+
+ return smoothing_useful;
+}
+
+
+/*
+ * Variant of decompress_data for use when doing block smoothing.
+ */
+
+METHODDEF(int)
+decompress_smooth_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
+{
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+ JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+ JDIMENSION block_num, last_block_column;
+ int ci, block_row, block_rows, access_rows;
+ JBLOCKARRAY buffer;
+ JBLOCKROW buffer_ptr, prev_block_row, next_block_row;
+ JSAMPARRAY output_ptr;
+ JDIMENSION output_col;
+ jpeg_component_info *compptr;
+ inverse_DCT_method_ptr inverse_DCT;
+ boolean first_row, last_row;
+ JBLOCK workspace;
+ int *coef_bits;
+ JQUANT_TBL *quanttbl;
+ INT32 Q00,Q01,Q02,Q10,Q11,Q20, num;
+ int DC1,DC2,DC3,DC4,DC5,DC6,DC7,DC8,DC9;
+ int Al, pred;
+
+ /* Force some input to be done if we are getting ahead of the input. */
+ while (cinfo->input_scan_number <= cinfo->output_scan_number &&
+ ! cinfo->inputctl->eoi_reached) {
+ if (cinfo->input_scan_number == cinfo->output_scan_number) {
+ /* If input is working on current scan, we ordinarily want it to
+ * have completed the current row. But if input scan is DC,
+ * we want it to keep one row ahead so that next block row's DC
+ * values are up to date.
+ */
+ JDIMENSION delta = (cinfo->Ss == 0) ? 1 : 0;
+ if (cinfo->input_iMCU_row > cinfo->output_iMCU_row+delta)
+ break;
+ }
+ if ((*cinfo->inputctl->consume_input)(cinfo) == JPEG_SUSPENDED)
+ return JPEG_SUSPENDED;
+ }
+
+ /* OK, output from the virtual arrays. */
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ /* Don't bother to IDCT an uninteresting component. */
+ if (! compptr->component_needed)
+ continue;
+ /* Count non-dummy DCT block rows in this iMCU row. */
+ if (cinfo->output_iMCU_row < last_iMCU_row) {
+ block_rows = compptr->v_samp_factor;
+ access_rows = block_rows * 2; /* this and next iMCU row */
+ last_row = FALSE;
+ } else {
+ /* NB: can't use last_row_height here; it is input-side-dependent! */
+ block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
+ if (block_rows == 0) block_rows = compptr->v_samp_factor;
+ access_rows = block_rows; /* this iMCU row only */
+ last_row = TRUE;
+ }
+ /* Align the virtual buffer for this component. */
+ if (cinfo->output_iMCU_row > 0) {
+ access_rows += compptr->v_samp_factor; /* prior iMCU row too */
+ buffer = (*cinfo->mem->access_virt_barray)
+ ((j_common_ptr) cinfo, coef->whole_image[ci],
+ (cinfo->output_iMCU_row - 1) * compptr->v_samp_factor,
+ (JDIMENSION) access_rows, FALSE);
+ buffer += compptr->v_samp_factor; /* point to current iMCU row */
+ first_row = FALSE;
+ } else {
+ buffer = (*cinfo->mem->access_virt_barray)
+ ((j_common_ptr) cinfo, coef->whole_image[ci],
+ (JDIMENSION) 0, (JDIMENSION) access_rows, FALSE);
+ first_row = TRUE;
+ }
+ /* Fetch component-dependent info */
+ coef_bits = coef->coef_bits_latch + (ci * SAVED_COEFS);
+ quanttbl = compptr->quant_table;
+ Q00 = quanttbl->quantval[0];
+ Q01 = quanttbl->quantval[Q01_POS];
+ Q10 = quanttbl->quantval[Q10_POS];
+ Q20 = quanttbl->quantval[Q20_POS];
+ Q11 = quanttbl->quantval[Q11_POS];
+ Q02 = quanttbl->quantval[Q02_POS];
+ inverse_DCT = cinfo->idct->inverse_DCT[ci];
+ output_ptr = output_buf[ci];
+ /* Loop over all DCT blocks to be processed. */
+ for (block_row = 0; block_row < block_rows; block_row++) {
+ buffer_ptr = buffer[block_row];
+ if (first_row && block_row == 0)
+ prev_block_row = buffer_ptr;
+ else
+ prev_block_row = buffer[block_row-1];
+ if (last_row && block_row == block_rows-1)
+ next_block_row = buffer_ptr;
+ else
+ next_block_row = buffer[block_row+1];
+ /* We fetch the surrounding DC values using a sliding-register approach.
+ * Initialize all nine here so as to do the right thing on narrow pics.
+ */
+ DC1 = DC2 = DC3 = (int) prev_block_row[0][0];
+ DC4 = DC5 = DC6 = (int) buffer_ptr[0][0];
+ DC7 = DC8 = DC9 = (int) next_block_row[0][0];
+ output_col = 0;
+ last_block_column = compptr->width_in_blocks - 1;
+ for (block_num = 0; block_num <= last_block_column; block_num++) {
+ /* Fetch current DCT block into workspace so we can modify it. */
+ jcopy_block_row(buffer_ptr, (JBLOCKROW) workspace, (JDIMENSION) 1);
+ /* Update DC values */
+ if (block_num < last_block_column) {
+ DC3 = (int) prev_block_row[1][0];
+ DC6 = (int) buffer_ptr[1][0];
+ DC9 = (int) next_block_row[1][0];
+ }
+ /* Compute coefficient estimates per K.8.
+ * An estimate is applied only if coefficient is still zero,
+ * and is not known to be fully accurate.
+ */
+ /* AC01 */
+ if ((Al=coef_bits[1]) != 0 && workspace[1] == 0) {
+ num = 36 * Q00 * (DC4 - DC6);
+ if (num >= 0) {
+ pred = (int) (((Q01<<7) + num) / (Q01<<8));
+ if (Al > 0 && pred >= (1<<Al))
+ pred = (1<<Al)-1;
+ } else {
+ pred = (int) (((Q01<<7) - num) / (Q01<<8));
+ if (Al > 0 && pred >= (1<<Al))
+ pred = (1<<Al)-1;
+ pred = -pred;
+ }
+ workspace[1] = (JCOEF) pred;
+ }
+ /* AC10 */
+ if ((Al=coef_bits[2]) != 0 && workspace[8] == 0) {
+ num = 36 * Q00 * (DC2 - DC8);
+ if (num >= 0) {
+ pred = (int) (((Q10<<7) + num) / (Q10<<8));
+ if (Al > 0 && pred >= (1<<Al))
+ pred = (1<<Al)-1;
+ } else {
+ pred = (int) (((Q10<<7) - num) / (Q10<<8));
+ if (Al > 0 && pred >= (1<<Al))
+ pred = (1<<Al)-1;
+ pred = -pred;
+ }
+ workspace[8] = (JCOEF) pred;
+ }
+ /* AC20 */
+ if ((Al=coef_bits[3]) != 0 && workspace[16] == 0) {
+ num = 9 * Q00 * (DC2 + DC8 - 2*DC5);
+ if (num >= 0) {
+ pred = (int) (((Q20<<7) + num) / (Q20<<8));
+ if (Al > 0 && pred >= (1<<Al))
+ pred = (1<<Al)-1;
+ } else {
+ pred = (int) (((Q20<<7) - num) / (Q20<<8));
+ if (Al > 0 && pred >= (1<<Al))
+ pred = (1<<Al)-1;
+ pred = -pred;
+ }
+ workspace[16] = (JCOEF) pred;
+ }
+ /* AC11 */
+ if ((Al=coef_bits[4]) != 0 && workspace[9] == 0) {
+ num = 5 * Q00 * (DC1 - DC3 - DC7 + DC9);
+ if (num >= 0) {
+ pred = (int) (((Q11<<7) + num) / (Q11<<8));
+ if (Al > 0 && pred >= (1<<Al))
+ pred = (1<<Al)-1;
+ } else {
+ pred = (int) (((Q11<<7) - num) / (Q11<<8));
+ if (Al > 0 && pred >= (1<<Al))
+ pred = (1<<Al)-1;
+ pred = -pred;
+ }
+ workspace[9] = (JCOEF) pred;
+ }
+ /* AC02 */
+ if ((Al=coef_bits[5]) != 0 && workspace[2] == 0) {
+ num = 9 * Q00 * (DC4 + DC6 - 2*DC5);
+ if (num >= 0) {
+ pred = (int) (((Q02<<7) + num) / (Q02<<8));
+ if (Al > 0 && pred >= (1<<Al))
+ pred = (1<<Al)-1;
+ } else {
+ pred = (int) (((Q02<<7) - num) / (Q02<<8));
+ if (Al > 0 && pred >= (1<<Al))
+ pred = (1<<Al)-1;
+ pred = -pred;
+ }
+ workspace[2] = (JCOEF) pred;
+ }
+ /* OK, do the IDCT */
+ (*inverse_DCT) (cinfo, compptr, (JCOEFPTR) workspace,
+ output_ptr, output_col);
+ /* Advance for next column */
+ DC1 = DC2; DC2 = DC3;
+ DC4 = DC5; DC5 = DC6;
+ DC7 = DC8; DC8 = DC9;
+ buffer_ptr++, prev_block_row++, next_block_row++;
+ output_col += compptr->DCT_scaled_size;
+ }
+ output_ptr += compptr->DCT_scaled_size;
+ }
+ }
+
+ if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows)
+ return JPEG_ROW_COMPLETED;
+ return JPEG_SCAN_COMPLETED;
+}
+
+#endif /* BLOCK_SMOOTHING_SUPPORTED */
+
+
+/*
+ * Initialize coefficient buffer controller.
+ */
+
+GLOBAL(void)
+jinit_d_coef_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
+{
+ my_coef_ptr coef;
+
+ coef = (my_coef_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_coef_controller));
+ cinfo->coef = (struct jpeg_d_coef_controller *) coef;
+ coef->pub.start_input_pass = start_input_pass;
+ coef->pub.start_output_pass = start_output_pass;
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+ coef->coef_bits_latch = NULL;
+#endif
+
+ /* Create the coefficient buffer. */
+ if (need_full_buffer) {
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+ /* Allocate a full-image virtual array for each component, */
+ /* padded to a multiple of samp_factor DCT blocks in each direction. */
+ /* Note we ask for a pre-zeroed array. */
+ int ci, access_rows;
+ jpeg_component_info *compptr;
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ access_rows = compptr->v_samp_factor;
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+ /* If block smoothing could be used, need a bigger window */
+ if (cinfo->progressive_mode)
+ access_rows *= 3;
+#endif
+ coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE, TRUE,
+ (JDIMENSION) jround_up((long) compptr->width_in_blocks,
+ (long) compptr->h_samp_factor),
+ (JDIMENSION) jround_up((long) compptr->height_in_blocks,
+ (long) compptr->v_samp_factor),
+ (JDIMENSION) access_rows);
+ }
+ coef->pub.consume_data = consume_data;
+ coef->pub.decompress_data = decompress_data;
+ coef->pub.coef_arrays = coef->whole_image; /* link to virtual arrays */
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+ } else {
+ /* We only need a single-MCU buffer. */
+ JBLOCKROW buffer;
+ int i;
+
+ buffer = (JBLOCKROW)
+ (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ D_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+ for (i = 0; i < D_MAX_BLOCKS_IN_MCU; i++) {
+ coef->MCU_buffer[i] = buffer + i;
+ }
+ coef->pub.consume_data = dummy_consume_data;
+ coef->pub.decompress_data = decompress_onepass;
+ coef->pub.coef_arrays = NULL; /* flag for no virtual arrays */
+ }
+}
--- /dev/null
+/*
+ * jdcolor.c
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * 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 output colorspace conversion routines.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private subobject */
+
+typedef struct {
+ struct jpeg_color_deconverter pub; /* public fields */
+
+ /* Private state for YCC->RGB conversion */
+ int * Cr_r_tab; /* => table for Cr to R conversion */
+ int * Cb_b_tab; /* => table for Cb to B conversion */
+ INT32 * Cr_g_tab; /* => table for Cr to G conversion */
+ INT32 * Cb_g_tab; /* => table for Cb to G conversion */
+} my_color_deconverter;
+
+typedef my_color_deconverter * my_cconvert_ptr;
+
+
+/**************** YCbCr -> RGB conversion: most common case **************/
+
+/*
+ * YCbCr is defined per CCIR 601-1, except that Cb and Cr are
+ * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
+ * The conversion equations to be implemented are therefore
+ * R = Y + 1.40200 * Cr
+ * G = Y - 0.34414 * Cb - 0.71414 * Cr
+ * B = Y + 1.77200 * Cb
+ * where Cb and Cr represent the incoming values less CENTERJSAMPLE.
+ * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.)
+ *
+ * To avoid floating-point arithmetic, we represent the fractional constants
+ * as integers scaled up by 2^16 (about 4 digits precision); we have to divide
+ * the products by 2^16, with appropriate rounding, to get the correct answer.
+ * Notice that Y, being an integral input, does not contribute any fraction
+ * so it need not participate in the rounding.
+ *
+ * For even more speed, we avoid doing any multiplications in the inner loop
+ * by precalculating the constants times Cb and Cr for all possible values.
+ * For 8-bit JSAMPLEs this is very reasonable (only 256 entries per table);
+ * for 12-bit samples it is still acceptable. It's not very reasonable for
+ * 16-bit samples, but if you want lossless storage you shouldn't be changing
+ * colorspace anyway.
+ * The Cr=>R and Cb=>B values can be rounded to integers in advance; the
+ * values for the G calculation are left scaled up, since we must add them
+ * together before rounding.
+ */
+
+#define SCALEBITS 16 /* speediest right-shift on some machines */
+#define ONE_HALF ((INT32) 1 << (SCALEBITS-1))
+#define FIX(x) ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
+
+
+/*
+ * Initialize tables for YCC->RGB colorspace conversion.
+ */
+
+LOCAL(void)
+build_ycc_rgb_table (j_decompress_ptr cinfo)
+{
+ my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+ int i;
+ INT32 x;
+ SHIFT_TEMPS
+
+ cconvert->Cr_r_tab = (int *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (MAXJSAMPLE+1) * SIZEOF(int));
+ cconvert->Cb_b_tab = (int *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (MAXJSAMPLE+1) * SIZEOF(int));
+ cconvert->Cr_g_tab = (INT32 *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (MAXJSAMPLE+1) * SIZEOF(INT32));
+ cconvert->Cb_g_tab = (INT32 *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (MAXJSAMPLE+1) * SIZEOF(INT32));
+
+ for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
+ /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
+ /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
+ /* Cr=>R value is nearest int to 1.40200 * x */
+ cconvert->Cr_r_tab[i] = (int)
+ RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS);
+ /* Cb=>B value is nearest int to 1.77200 * x */
+ cconvert->Cb_b_tab[i] = (int)
+ RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS);
+ /* Cr=>G value is scaled-up -0.71414 * x */
+ cconvert->Cr_g_tab[i] = (- FIX(0.71414)) * x;
+ /* Cb=>G value is scaled-up -0.34414 * x */
+ /* We also add in ONE_HALF so that need not do it in inner loop */
+ cconvert->Cb_g_tab[i] = (- FIX(0.34414)) * x + ONE_HALF;
+ }
+}
+
+
+/*
+ * Convert some rows of samples to the output colorspace.
+ *
+ * Note that we change from noninterleaved, one-plane-per-component format
+ * to interleaved-pixel format. The output buffer is therefore three times
+ * as wide as the input buffer.
+ * A starting row offset is provided only for the input buffer. The caller
+ * can easily adjust the passed output_buf value to accommodate any row
+ * offset required on that side.
+ */
+
+METHODDEF(void)
+ycc_rgb_convert (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION input_row,
+ JSAMPARRAY output_buf, int num_rows)
+{
+ my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+ register int y, cb, cr;
+ register JSAMPROW outptr;
+ register JSAMPROW inptr0, inptr1, inptr2;
+ register JDIMENSION col;
+ JDIMENSION num_cols = cinfo->output_width;
+ /* copy these pointers into registers if possible */
+ register JSAMPLE * range_limit = cinfo->sample_range_limit;
+ register int * Crrtab = cconvert->Cr_r_tab;
+ register int * Cbbtab = cconvert->Cb_b_tab;
+ register INT32 * Crgtab = cconvert->Cr_g_tab;
+ register INT32 * Cbgtab = cconvert->Cb_g_tab;
+ SHIFT_TEMPS
+
+ while (--num_rows >= 0) {
+ inptr0 = input_buf[0][input_row];
+ inptr1 = input_buf[1][input_row];
+ inptr2 = input_buf[2][input_row];
+ input_row++;
+ outptr = *output_buf++;
+ for (col = 0; col < num_cols; col++) {
+ y = GETJSAMPLE(inptr0[col]);
+ cb = GETJSAMPLE(inptr1[col]);
+ cr = GETJSAMPLE(inptr2[col]);
+ /* Range-limiting is essential due to noise introduced by DCT losses. */
+ outptr[RGB_RED] = range_limit[y + Crrtab[cr]];
+ outptr[RGB_GREEN] = range_limit[y +
+ ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
+ SCALEBITS))];
+ outptr[RGB_BLUE] = range_limit[y + Cbbtab[cb]];
+ outptr += RGB_PIXELSIZE;
+ }
+ }
+}
+
+
+/**************** Cases other than YCbCr -> RGB **************/
+
+
+/*
+ * Color conversion for no colorspace change: just copy the data,
+ * converting from separate-planes to interleaved representation.
+ */
+
+METHODDEF(void)
+null_convert (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION input_row,
+ JSAMPARRAY output_buf, int num_rows)
+{
+ register JSAMPROW inptr, outptr;
+ register JDIMENSION count;
+ register int num_components = cinfo->num_components;
+ JDIMENSION num_cols = cinfo->output_width;
+ int ci;
+
+ while (--num_rows >= 0) {
+ for (ci = 0; ci < num_components; ci++) {
+ inptr = input_buf[ci][input_row];
+ outptr = output_buf[0] + ci;
+ for (count = num_cols; count > 0; count--) {
+ *outptr = *inptr++; /* needn't bother with GETJSAMPLE() here */
+ outptr += num_components;
+ }
+ }
+ input_row++;
+ output_buf++;
+ }
+}
+
+
+/*
+ * Color conversion for grayscale: just copy the data.
+ * This also works for YCbCr -> grayscale conversion, in which
+ * we just copy the Y (luminance) component and ignore chrominance.
+ */
+
+METHODDEF(void)
+grayscale_convert (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION input_row,
+ JSAMPARRAY output_buf, int num_rows)
+{
+ jcopy_sample_rows(input_buf[0], (int) input_row, output_buf, 0,
+ num_rows, cinfo->output_width);
+}
+
+
+/*
+ * Convert grayscale to RGB: just duplicate the graylevel three times.
+ * This is provided to support applications that don't want to cope
+ * with grayscale as a separate case.
+ */
+
+METHODDEF(void)
+gray_rgb_convert (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION input_row,
+ JSAMPARRAY output_buf, int num_rows)
+{
+ register JSAMPROW inptr, outptr;
+ register JDIMENSION col;
+ JDIMENSION num_cols = cinfo->output_width;
+
+ while (--num_rows >= 0) {
+ inptr = input_buf[0][input_row++];
+ outptr = *output_buf++;
+ for (col = 0; col < num_cols; col++) {
+ /* We can dispense with GETJSAMPLE() here */
+ outptr[RGB_RED] = outptr[RGB_GREEN] = outptr[RGB_BLUE] = inptr[col];
+ outptr += RGB_PIXELSIZE;
+ }
+ }
+}
+
+
+/*
+ * Adobe-style YCCK->CMYK conversion.
+ * We convert YCbCr to R=1-C, G=1-M, and B=1-Y using the same
+ * conversion as above, while passing K (black) unchanged.
+ * We assume build_ycc_rgb_table has been called.
+ */
+
+METHODDEF(void)
+ycck_cmyk_convert (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION input_row,
+ JSAMPARRAY output_buf, int num_rows)
+{
+ my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+ register int y, cb, cr;
+ register JSAMPROW outptr;
+ register JSAMPROW inptr0, inptr1, inptr2, inptr3;
+ register JDIMENSION col;
+ JDIMENSION num_cols = cinfo->output_width;
+ /* copy these pointers into registers if possible */
+ register JSAMPLE * range_limit = cinfo->sample_range_limit;
+ register int * Crrtab = cconvert->Cr_r_tab;
+ register int * Cbbtab = cconvert->Cb_b_tab;
+ register INT32 * Crgtab = cconvert->Cr_g_tab;
+ register INT32 * Cbgtab = cconvert->Cb_g_tab;
+ SHIFT_TEMPS
+
+ while (--num_rows >= 0) {
+ inptr0 = input_buf[0][input_row];
+ inptr1 = input_buf[1][input_row];
+ inptr2 = input_buf[2][input_row];
+ inptr3 = input_buf[3][input_row];
+ input_row++;
+ outptr = *output_buf++;
+ for (col = 0; col < num_cols; col++) {
+ y = GETJSAMPLE(inptr0[col]);
+ cb = GETJSAMPLE(inptr1[col]);
+ cr = GETJSAMPLE(inptr2[col]);
+ /* Range-limiting is essential due to noise introduced by DCT losses. */
+ outptr[0] = range_limit[MAXJSAMPLE - (y + Crrtab[cr])]; /* red */
+ outptr[1] = range_limit[MAXJSAMPLE - (y + /* green */
+ ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
+ SCALEBITS)))];
+ outptr[2] = range_limit[MAXJSAMPLE - (y + Cbbtab[cb])]; /* blue */
+ /* K passes through unchanged */
+ outptr[3] = inptr3[col]; /* don't need GETJSAMPLE here */
+ outptr += 4;
+ }
+ }
+}
+
+
+/*
+ * Empty method for start_pass.
+ */
+
+METHODDEF(void)
+start_pass_dcolor (j_decompress_ptr cinfo)
+{
+ /* no work needed */
+}
+
+
+/*
+ * Module initialization routine for output colorspace conversion.
+ */
+
+GLOBAL(void)
+jinit_color_deconverter (j_decompress_ptr cinfo)
+{
+ my_cconvert_ptr cconvert;
+ int ci;
+
+ cconvert = (my_cconvert_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_color_deconverter));
+ cinfo->cconvert = (struct jpeg_color_deconverter *) cconvert;
+ cconvert->pub.start_pass = start_pass_dcolor;
+
+ /* Make sure num_components agrees with jpeg_color_space */
+ switch (cinfo->jpeg_color_space) {
+ case JCS_GRAYSCALE:
+ if (cinfo->num_components != 1)
+ ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+ break;
+
+ case JCS_RGB:
+ case JCS_YCbCr:
+ if (cinfo->num_components != 3)
+ ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+ break;
+
+ case JCS_CMYK:
+ case JCS_YCCK:
+ if (cinfo->num_components != 4)
+ ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+ break;
+
+ default: /* JCS_UNKNOWN can be anything */
+ if (cinfo->num_components < 1)
+ ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+ break;
+ }
+
+ /* Set out_color_components and conversion method based on requested space.
+ * Also clear the component_needed flags for any unused components,
+ * so that earlier pipeline stages can avoid useless computation.
+ */
+
+ switch (cinfo->out_color_space) {
+ case JCS_GRAYSCALE:
+ cinfo->out_color_components = 1;
+ if (cinfo->jpeg_color_space == JCS_GRAYSCALE ||
+ cinfo->jpeg_color_space == JCS_YCbCr) {
+ cconvert->pub.color_convert = grayscale_convert;
+ /* For color->grayscale conversion, only the Y (0) component is needed */
+ for (ci = 1; ci < cinfo->num_components; ci++)
+ cinfo->comp_info[ci].component_needed = FALSE;
+ } else
+ ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+ break;
+
+ case JCS_RGB:
+ cinfo->out_color_components = RGB_PIXELSIZE;
+ if (cinfo->jpeg_color_space == JCS_YCbCr) {
+ cconvert->pub.color_convert = ycc_rgb_convert;
+ build_ycc_rgb_table(cinfo);
+ } else if (cinfo->jpeg_color_space == JCS_GRAYSCALE) {
+ cconvert->pub.color_convert = gray_rgb_convert;
+ } else if (cinfo->jpeg_color_space == JCS_RGB && RGB_PIXELSIZE == 3) {
+ cconvert->pub.color_convert = null_convert;
+ } else
+ ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+ break;
+
+ case JCS_CMYK:
+ cinfo->out_color_components = 4;
+ if (cinfo->jpeg_color_space == JCS_YCCK) {
+ cconvert->pub.color_convert = ycck_cmyk_convert;
+ build_ycc_rgb_table(cinfo);
+ } else if (cinfo->jpeg_color_space == JCS_CMYK) {
+ cconvert->pub.color_convert = null_convert;
+ } else
+ ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+ break;
+
+ default:
+ /* Permit null conversion to same output space */
+ if (cinfo->out_color_space == cinfo->jpeg_color_space) {
+ cinfo->out_color_components = cinfo->num_components;
+ cconvert->pub.color_convert = null_convert;
+ } else /* unsupported non-null conversion */
+ ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+ break;
+ }
+
+ if (cinfo->quantize_colors)
+ cinfo->output_components = 1; /* single colormapped output component */
+ else
+ cinfo->output_components = cinfo->out_color_components;
+}
--- /dev/null
+/*
+ * jdct.h
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This include file contains common declarations for the forward and
+ * inverse DCT modules. These declarations are private to the DCT managers
+ * (jcdctmgr.c, jddctmgr.c) and the individual DCT algorithms.
+ * The individual DCT algorithms are kept in separate files to ease
+ * machine-dependent tuning (e.g., assembly coding).
+ */
+
+
+/*
+ * A forward DCT routine is given a pointer to a work area of type DCTELEM[];
+ * the DCT is to be performed in-place in that buffer. Type DCTELEM is int
+ * for 8-bit samples, INT32 for 12-bit samples. (NOTE: Floating-point DCT
+ * implementations use an array of type FAST_FLOAT, instead.)
+ * The DCT inputs are expected to be signed (range +-CENTERJSAMPLE).
+ * The DCT outputs are returned scaled up by a factor of 8; they therefore
+ * have a range of +-8K for 8-bit data, +-128K for 12-bit data. This
+ * convention improves accuracy in integer implementations and saves some
+ * work in floating-point ones.
+ * Quantization of the output coefficients is done by jcdctmgr.c.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+typedef int DCTELEM; /* 16 or 32 bits is fine */
+#else
+typedef INT32 DCTELEM; /* must have 32 bits */
+#endif
+
+typedef JMETHOD(void, forward_DCT_method_ptr, (DCTELEM * data));
+typedef JMETHOD(void, float_DCT_method_ptr, (FAST_FLOAT * data));
+
+
+/*
+ * An inverse DCT routine is given a pointer to the input JBLOCK and a pointer
+ * to an output sample array. The routine must dequantize the input data as
+ * well as perform the IDCT; for dequantization, it uses the multiplier table
+ * pointed to by compptr->dct_table. The output data is to be placed into the
+ * sample array starting at a specified column. (Any row offset needed will
+ * be applied to the array pointer before it is passed to the IDCT code.)
+ * Note that the number of samples emitted by the IDCT routine is
+ * DCT_scaled_size * DCT_scaled_size.
+ */
+
+/* typedef inverse_DCT_method_ptr is declared in jpegint.h */
+
+/*
+ * Each IDCT routine has its own ideas about the best dct_table element type.
+ */
+
+typedef MULTIPLIER ISLOW_MULT_TYPE; /* short or int, whichever is faster */
+#if BITS_IN_JSAMPLE == 8
+typedef MULTIPLIER IFAST_MULT_TYPE; /* 16 bits is OK, use short if faster */
+#define IFAST_SCALE_BITS 2 /* fractional bits in scale factors */
+#else
+typedef INT32 IFAST_MULT_TYPE; /* need 32 bits for scaled quantizers */
+#define IFAST_SCALE_BITS 13 /* fractional bits in scale factors */
+#endif
+typedef FAST_FLOAT FLOAT_MULT_TYPE; /* preferred floating type */
+
+
+/*
+ * Each IDCT routine is responsible for range-limiting its results and
+ * converting them to unsigned form (0..MAXJSAMPLE). The raw outputs could
+ * be quite far out of range if the input data is corrupt, so a bulletproof
+ * range-limiting step is required. We use a mask-and-table-lookup method
+ * to do the combined operations quickly. See the comments with
+ * prepare_range_limit_table (in jdmaster.c) for more info.
+ */
+
+#define IDCT_range_limit(cinfo) ((cinfo)->sample_range_limit + CENTERJSAMPLE)
+
+#define RANGE_MASK (MAXJSAMPLE * 4 + 3) /* 2 bits wider than legal samples */
+
+
+/* Short forms of external names for systems with brain-damaged linkers. */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_fdct_islow jFDislow
+#define jpeg_fdct_ifast jFDifast
+#define jpeg_fdct_float jFDfloat
+#define jpeg_idct_islow jRDislow
+#define jpeg_idct_ifast jRDifast
+#define jpeg_idct_float jRDfloat
+#define jpeg_idct_4x4 jRD4x4
+#define jpeg_idct_2x2 jRD2x2
+#define jpeg_idct_1x1 jRD1x1
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+/* Extern declarations for the forward and inverse DCT routines. */
+
+EXTERN(void) jpeg_fdct_islow JPP((DCTELEM * data));
+EXTERN(void) jpeg_fdct_ifast JPP((DCTELEM * data));
+EXTERN(void) jpeg_fdct_float JPP((FAST_FLOAT * data));
+
+EXTERN(void) jpeg_idct_islow
+ JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_ifast
+ JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_float
+ JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_4x4
+ JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_2x2
+ JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_1x1
+ JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+
+
+/*
+ * Macros for handling fixed-point arithmetic; these are used by many
+ * but not all of the DCT/IDCT modules.
+ *
+ * All values are expected to be of type INT32.
+ * Fractional constants are scaled left by CONST_BITS bits.
+ * CONST_BITS is defined within each module using these macros,
+ * and may differ from one module to the next.
+ */
+
+#define ONE ((INT32) 1)
+#define CONST_SCALE (ONE << CONST_BITS)
+
+/* Convert a positive real constant to an integer scaled by CONST_SCALE.
+ * Caution: some C compilers fail to reduce "FIX(constant)" at compile time,
+ * thus causing a lot of useless floating-point operations at run time.
+ */
+
+#define FIX(x) ((INT32) ((x) * CONST_SCALE + 0.5))
+
+/* Descale and correctly round an INT32 value that's scaled by N bits.
+ * We assume RIGHT_SHIFT rounds towards minus infinity, so adding
+ * the fudge factor is correct for either sign of X.
+ */
+
+#define DESCALE(x,n) RIGHT_SHIFT((x) + (ONE << ((n)-1)), n)
+
+/* Multiply an INT32 variable by an INT32 constant to yield an INT32 result.
+ * This macro is used only when the two inputs will actually be no more than
+ * 16 bits wide, so that a 16x16->32 bit multiply can be used instead of a
+ * full 32x32 multiply. This provides a useful speedup on many machines.
+ * Unfortunately there is no way to specify a 16x16->32 multiply portably
+ * in C, but some C compilers will do the right thing if you provide the
+ * correct combination of casts.
+ */
+
+#ifdef SHORTxSHORT_32 /* may work if 'int' is 32 bits */
+#define MULTIPLY16C16(var,const) (((INT16) (var)) * ((INT16) (const)))
+#endif
+#ifdef SHORTxLCONST_32 /* known to work with Microsoft C 6.0 */
+#define MULTIPLY16C16(var,const) (((INT16) (var)) * ((INT32) (const)))
+#endif
+
+#ifndef MULTIPLY16C16 /* default definition */
+#define MULTIPLY16C16(var,const) ((var) * (const))
+#endif
+
+/* Same except both inputs are variables. */
+
+#ifdef SHORTxSHORT_32 /* may work if 'int' is 32 bits */
+#define MULTIPLY16V16(var1,var2) (((INT16) (var1)) * ((INT16) (var2)))
+#endif
+
+#ifndef MULTIPLY16V16 /* default definition */
+#define MULTIPLY16V16(var1,var2) ((var1) * (var2))
+#endif
--- /dev/null
+/*
+ * jddctmgr.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * 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 the inverse-DCT management logic.
+ * This code selects a particular IDCT implementation to be used,
+ * and it performs related housekeeping chores. No code in this file
+ * is executed per IDCT step, only during output pass setup.
+ *
+ * Note that the IDCT routines are responsible for performing coefficient
+ * dequantization as well as the IDCT proper. This module sets up the
+ * dequantization multiplier table needed by the IDCT routine.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h" /* Private declarations for DCT subsystem */
+
+
+/*
+ * The decompressor input side (jdinput.c) saves away the appropriate
+ * quantization table for each component at the start of the first scan
+ * involving that component. (This is necessary in order to correctly
+ * decode files that reuse Q-table slots.)
+ * When we are ready to make an output pass, the saved Q-table is converted
+ * to a multiplier table that will actually be used by the IDCT routine.
+ * The multiplier table contents are IDCT-method-dependent. To support
+ * application changes in IDCT method between scans, we can remake the
+ * multiplier tables if necessary.
+ * In buffered-image mode, the first output pass may occur before any data
+ * has been seen for some components, and thus before their Q-tables have
+ * been saved away. To handle this case, multiplier tables are preset
+ * to zeroes; the result of the IDCT will be a neutral gray level.
+ */
+
+
+/* Private subobject for this module */
+
+typedef struct {
+ struct jpeg_inverse_dct pub; /* public fields */
+
+ /* This array contains the IDCT method code that each multiplier table
+ * is currently set up for, or -1 if it's not yet set up.
+ * The actual multiplier tables are pointed to by dct_table in the
+ * per-component comp_info structures.
+ */
+ int cur_method[MAX_COMPONENTS];
+} my_idct_controller;
+
+typedef my_idct_controller * my_idct_ptr;
+
+
+/* Allocated multiplier tables: big enough for any supported variant */
+
+typedef union {
+ ISLOW_MULT_TYPE islow_array[DCTSIZE2];
+#ifdef DCT_IFAST_SUPPORTED
+ IFAST_MULT_TYPE ifast_array[DCTSIZE2];
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+ FLOAT_MULT_TYPE float_array[DCTSIZE2];
+#endif
+} multiplier_table;
+
+
+/* The current scaled-IDCT routines require ISLOW-style multiplier tables,
+ * so be sure to compile that code if either ISLOW or SCALING is requested.
+ */
+#ifdef DCT_ISLOW_SUPPORTED
+#define PROVIDE_ISLOW_TABLES
+#else
+#ifdef IDCT_SCALING_SUPPORTED
+#define PROVIDE_ISLOW_TABLES
+#endif
+#endif
+
+
+/*
+ * Prepare for an output pass.
+ * Here we select the proper IDCT routine for each component and build
+ * a matching multiplier table.
+ */
+
+METHODDEF(void)
+start_pass (j_decompress_ptr cinfo)
+{
+ my_idct_ptr idct = (my_idct_ptr) cinfo->idct;
+ int ci, i;
+ jpeg_component_info *compptr;
+ int method = 0;
+ inverse_DCT_method_ptr method_ptr = NULL;
+ JQUANT_TBL * qtbl;
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ /* Select the proper IDCT routine for this component's scaling */
+ switch (compptr->DCT_scaled_size) {
+#ifdef IDCT_SCALING_SUPPORTED
+ case 1:
+ method_ptr = jpeg_idct_1x1;
+ method = JDCT_ISLOW; /* jidctred uses islow-style table */
+ break;
+ case 2:
+ method_ptr = jpeg_idct_2x2;
+ method = JDCT_ISLOW; /* jidctred uses islow-style table */
+ break;
+ case 4:
+ method_ptr = jpeg_idct_4x4;
+ method = JDCT_ISLOW; /* jidctred uses islow-style table */
+ break;
+#endif
+ case DCTSIZE:
+ switch (cinfo->dct_method) {
+#ifdef DCT_ISLOW_SUPPORTED
+ case JDCT_ISLOW:
+ method_ptr = jpeg_idct_islow;
+ method = JDCT_ISLOW;
+ break;
+#endif
+#ifdef DCT_IFAST_SUPPORTED
+ case JDCT_IFAST:
+ method_ptr = jpeg_idct_ifast;
+ method = JDCT_IFAST;
+ break;
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+ case JDCT_FLOAT:
+ method_ptr = jpeg_idct_float;
+ method = JDCT_FLOAT;
+ break;
+#endif
+ default:
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+ break;
+ }
+ break;
+ default:
+ ERREXIT1(cinfo, JERR_BAD_DCTSIZE, compptr->DCT_scaled_size);
+ break;
+ }
+ idct->pub.inverse_DCT[ci] = method_ptr;
+ /* Create multiplier table from quant table.
+ * However, we can skip this if the component is uninteresting
+ * or if we already built the table. Also, if no quant table
+ * has yet been saved for the component, we leave the
+ * multiplier table all-zero; we'll be reading zeroes from the
+ * coefficient controller's buffer anyway.
+ */
+ if (! compptr->component_needed || idct->cur_method[ci] == method)
+ continue;
+ qtbl = compptr->quant_table;
+ if (qtbl == NULL) /* happens if no data yet for component */
+ continue;
+ idct->cur_method[ci] = method;
+ switch (method) {
+#ifdef PROVIDE_ISLOW_TABLES
+ case JDCT_ISLOW:
+ {
+ /* For LL&M IDCT method, multipliers are equal to raw quantization
+ * coefficients, but are stored as ints to ensure access efficiency.
+ */
+ ISLOW_MULT_TYPE * ismtbl = (ISLOW_MULT_TYPE *) compptr->dct_table;
+ for (i = 0; i < DCTSIZE2; i++) {
+ ismtbl[i] = (ISLOW_MULT_TYPE) qtbl->quantval[i];
+ }
+ }
+ break;
+#endif
+#ifdef DCT_IFAST_SUPPORTED
+ case JDCT_IFAST:
+ {
+ /* For AA&N IDCT method, multipliers are equal to quantization
+ * coefficients scaled by scalefactor[row]*scalefactor[col], where
+ * scalefactor[0] = 1
+ * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7
+ * For integer operation, the multiplier table is to be scaled by
+ * IFAST_SCALE_BITS.
+ */
+ IFAST_MULT_TYPE * ifmtbl = (IFAST_MULT_TYPE *) compptr->dct_table;
+#define CONST_BITS 14
+ static const INT16 aanscales[DCTSIZE2] = {
+ /* precomputed values scaled up by 14 bits */
+ 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
+ 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
+ 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
+ 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
+ 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
+ 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
+ 8867, 12299, 11585, 10426, 8867, 6967, 4799, 2446,
+ 4520, 6270, 5906, 5315, 4520, 3552, 2446, 1247
+ };
+ SHIFT_TEMPS
+
+ for (i = 0; i < DCTSIZE2; i++) {
+ ifmtbl[i] = (IFAST_MULT_TYPE)
+ DESCALE(MULTIPLY16V16((INT32) qtbl->quantval[i],
+ (INT32) aanscales[i]),
+ CONST_BITS-IFAST_SCALE_BITS);
+ }
+ }
+ break;
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+ case JDCT_FLOAT:
+ {
+ /* For float AA&N IDCT method, multipliers are equal to quantization
+ * coefficients scaled by scalefactor[row]*scalefactor[col], where
+ * scalefactor[0] = 1
+ * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7
+ */
+ FLOAT_MULT_TYPE * fmtbl = (FLOAT_MULT_TYPE *) compptr->dct_table;
+ int row, col;
+ static const double aanscalefactor[DCTSIZE] = {
+ 1.0, 1.387039845, 1.306562965, 1.175875602,
+ 1.0, 0.785694958, 0.541196100, 0.275899379
+ };
+
+ i = 0;
+ for (row = 0; row < DCTSIZE; row++) {
+ for (col = 0; col < DCTSIZE; col++) {
+ fmtbl[i] = (FLOAT_MULT_TYPE)
+ ((double) qtbl->quantval[i] *
+ aanscalefactor[row] * aanscalefactor[col]);
+ i++;
+ }
+ }
+ }
+ break;
+#endif
+ default:
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+ break;
+ }
+ }
+}
+
+
+/*
+ * Initialize IDCT manager.
+ */
+
+GLOBAL(void)
+jinit_inverse_dct (j_decompress_ptr cinfo)
+{
+ my_idct_ptr idct;
+ int ci;
+ jpeg_component_info *compptr;
+
+ idct = (my_idct_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_idct_controller));
+ cinfo->idct = (struct jpeg_inverse_dct *) idct;
+ idct->pub.start_pass = start_pass;
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ /* Allocate and pre-zero a multiplier table for each component */
+ compptr->dct_table =
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(multiplier_table));
+ MEMZERO(compptr->dct_table, SIZEOF(multiplier_table));
+ /* Mark multiplier table not yet set up for any method */
+ idct->cur_method[ci] = -1;
+ }
+}
--- /dev/null
+/*
+ * jdhuff.c
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * 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 Huffman entropy decoding routines.
+ *
+ * Much of the complexity here has to do with supporting input suspension.
+ * If the data source module demands suspension, we want to be able to back
+ * up to the start of the current MCU. To do this, we copy state variables
+ * into local working storage, and update them back to the permanent
+ * storage only upon successful completion of an MCU.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdhuff.h" /* Declarations shared with jdphuff.c */
+
+
+/*
+ * Expanded entropy decoder object for Huffman decoding.
+ *
+ * The savable_state subrecord contains fields that change within an MCU,
+ * but must not be updated permanently until we complete the MCU.
+ */
+
+typedef struct {
+ int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
+} savable_state;
+
+/* This macro is to work around compilers with missing or broken
+ * structure assignment. You'll need to fix this code if you have
+ * such a compiler and you change MAX_COMPS_IN_SCAN.
+ */
+
+#ifndef NO_STRUCT_ASSIGN
+#define ASSIGN_STATE(dest,src) ((dest) = (src))
+#else
+#if MAX_COMPS_IN_SCAN == 4
+#define ASSIGN_STATE(dest,src) \
+ ((dest).last_dc_val[0] = (src).last_dc_val[0], \
+ (dest).last_dc_val[1] = (src).last_dc_val[1], \
+ (dest).last_dc_val[2] = (src).last_dc_val[2], \
+ (dest).last_dc_val[3] = (src).last_dc_val[3])
+#endif
+#endif
+
+
+typedef struct {
+ struct jpeg_entropy_decoder pub; /* public fields */
+
+ /* These fields are loaded into local variables at start of each MCU.
+ * In case of suspension, we exit WITHOUT updating them.
+ */
+ bitread_perm_state bitstate; /* Bit buffer at start of MCU */
+ savable_state saved; /* Other state at start of MCU */
+
+ /* These fields are NOT loaded into local working state. */
+ unsigned int restarts_to_go; /* MCUs left in this restart interval */
+
+ /* Pointers to derived tables (these workspaces have image lifespan) */
+ d_derived_tbl * dc_derived_tbls[NUM_HUFF_TBLS];
+ d_derived_tbl * ac_derived_tbls[NUM_HUFF_TBLS];
+
+ /* Precalculated info set up by start_pass for use in decode_mcu: */
+
+ /* Pointers to derived tables to be used for each block within an MCU */
+ d_derived_tbl * dc_cur_tbls[D_MAX_BLOCKS_IN_MCU];
+ d_derived_tbl * ac_cur_tbls[D_MAX_BLOCKS_IN_MCU];
+ /* Whether we care about the DC and AC coefficient values for each block */
+ boolean dc_needed[D_MAX_BLOCKS_IN_MCU];
+ boolean ac_needed[D_MAX_BLOCKS_IN_MCU];
+} huff_entropy_decoder;
+
+typedef huff_entropy_decoder * huff_entropy_ptr;
+
+
+/*
+ * Initialize for a Huffman-compressed scan.
+ */
+
+METHODDEF(void)
+start_pass_huff_decoder (j_decompress_ptr cinfo)
+{
+ huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+ int ci, blkn, dctbl, actbl;
+ jpeg_component_info * compptr;
+
+ /* Check that the scan parameters Ss, Se, Ah/Al are OK for sequential JPEG.
+ * This ought to be an error condition, but we make it a warning because
+ * there are some baseline files out there with all zeroes in these bytes.
+ */
+ if (cinfo->Ss != 0 || cinfo->Se != DCTSIZE2-1 ||
+ cinfo->Ah != 0 || cinfo->Al != 0)
+ WARNMS(cinfo, JWRN_NOT_SEQUENTIAL);
+
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ dctbl = compptr->dc_tbl_no;
+ actbl = compptr->ac_tbl_no;
+ /* Compute derived values for Huffman tables */
+ /* We may do this more than once for a table, but it's not expensive */
+ jpeg_make_d_derived_tbl(cinfo, TRUE, dctbl,
+ & entropy->dc_derived_tbls[dctbl]);
+ jpeg_make_d_derived_tbl(cinfo, FALSE, actbl,
+ & entropy->ac_derived_tbls[actbl]);
+ /* Initialize DC predictions to 0 */
+ entropy->saved.last_dc_val[ci] = 0;
+ }
+
+ /* Precalculate decoding info for each block in an MCU of this scan */
+ for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+ ci = cinfo->MCU_membership[blkn];
+ compptr = cinfo->cur_comp_info[ci];
+ /* Precalculate which table to use for each block */
+ entropy->dc_cur_tbls[blkn] = entropy->dc_derived_tbls[compptr->dc_tbl_no];
+ entropy->ac_cur_tbls[blkn] = entropy->ac_derived_tbls[compptr->ac_tbl_no];
+ /* Decide whether we really care about the coefficient values */
+ if (compptr->component_needed) {
+ entropy->dc_needed[blkn] = TRUE;
+ /* we don't need the ACs if producing a 1/8th-size image */
+ entropy->ac_needed[blkn] = (compptr->DCT_scaled_size > 1);
+ } else {
+ entropy->dc_needed[blkn] = entropy->ac_needed[blkn] = FALSE;
+ }
+ }
+
+ /* Initialize bitread state variables */
+ entropy->bitstate.bits_left = 0;
+ entropy->bitstate.get_buffer = 0; /* unnecessary, but keeps Purify quiet */
+ entropy->pub.insufficient_data = FALSE;
+
+ /* Initialize restart counter */
+ entropy->restarts_to_go = cinfo->restart_interval;
+}
+
+
+/*
+ * Compute the derived values for a Huffman table.
+ * This routine also performs some validation checks on the table.
+ *
+ * Note this is also used by jdphuff.c.
+ */
+
+GLOBAL(void)
+jpeg_make_d_derived_tbl (j_decompress_ptr cinfo, boolean isDC, int tblno,
+ d_derived_tbl ** pdtbl)
+{
+ JHUFF_TBL *htbl;
+ d_derived_tbl *dtbl;
+ int p, i, l, si, numsymbols;
+ int lookbits, ctr;
+ char huffsize[257];
+ unsigned int huffcode[257];
+ unsigned int code;
+
+ /* Note that huffsize[] and huffcode[] are filled in code-length order,
+ * paralleling the order of the symbols themselves in htbl->huffval[].
+ */
+
+ /* Find the input Huffman table */
+ if (tblno < 0 || tblno >= NUM_HUFF_TBLS)
+ ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
+ htbl =
+ isDC ? cinfo->dc_huff_tbl_ptrs[tblno] : cinfo->ac_huff_tbl_ptrs[tblno];
+ if (htbl == NULL)
+ ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
+
+ /* Allocate a workspace if we haven't already done so. */
+ if (*pdtbl == NULL)
+ *pdtbl = (d_derived_tbl *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(d_derived_tbl));
+ dtbl = *pdtbl;
+ dtbl->pub = htbl; /* fill in back link */
+
+ /* Figure C.1: make table of Huffman code length for each symbol */
+
+ p = 0;
+ for (l = 1; l <= 16; l++) {
+ i = (int) htbl->bits[l];
+ if (i < 0 || p + i > 256) /* protect against table overrun */
+ ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+ while (i--)
+ huffsize[p++] = (char) l;
+ }
+ huffsize[p] = 0;
+ numsymbols = p;
+
+ /* Figure C.2: generate the codes themselves */
+ /* We also validate that the counts represent a legal Huffman code tree. */
+
+ code = 0;
+ si = huffsize[0];
+ p = 0;
+ while (huffsize[p]) {
+ while (((int) huffsize[p]) == si) {
+ huffcode[p++] = code;
+ code++;
+ }
+ /* code is now 1 more than the last code used for codelength si; but
+ * it must still fit in si bits, since no code is allowed to be all ones.
+ */
+ if (((INT32) code) >= (((INT32) 1) << si))
+ ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+ code <<= 1;
+ si++;
+ }
+
+ /* Figure F.15: generate decoding tables for bit-sequential decoding */
+
+ p = 0;
+ for (l = 1; l <= 16; l++) {
+ if (htbl->bits[l]) {
+ /* valoffset[l] = huffval[] index of 1st symbol of code length l,
+ * minus the minimum code of length l
+ */
+ dtbl->valoffset[l] = (INT32) p - (INT32) huffcode[p];
+ p += htbl->bits[l];
+ dtbl->maxcode[l] = huffcode[p-1]; /* maximum code of length l */
+ } else {
+ dtbl->maxcode[l] = -1; /* -1 if no codes of this length */
+ }
+ }
+ dtbl->maxcode[17] = 0xFFFFFL; /* ensures jpeg_huff_decode terminates */
+
+ /* Compute lookahead tables to speed up decoding.
+ * First we set all the table entries to 0, indicating "too long";
+ * then we iterate through the Huffman codes that are short enough and
+ * fill in all the entries that correspond to bit sequences starting
+ * with that code.
+ */
+
+ MEMZERO(dtbl->look_nbits, SIZEOF(dtbl->look_nbits));
+
+ p = 0;
+ for (l = 1; l <= HUFF_LOOKAHEAD; l++) {
+ for (i = 1; i <= (int) htbl->bits[l]; i++, p++) {
+ /* l = current code's length, p = its index in huffcode[] & huffval[]. */
+ /* Generate left-justified code followed by all possible bit sequences */
+ lookbits = huffcode[p] << (HUFF_LOOKAHEAD-l);
+ for (ctr = 1 << (HUFF_LOOKAHEAD-l); ctr > 0; ctr--) {
+ dtbl->look_nbits[lookbits] = l;
+ dtbl->look_sym[lookbits] = htbl->huffval[p];
+ lookbits++;
+ }
+ }
+ }
+
+ /* Validate symbols as being reasonable.
+ * For AC tables, we make no check, but accept all byte values 0..255.
+ * For DC tables, we require the symbols to be in range 0..15.
+ * (Tighter bounds could be applied depending on the data depth and mode,
+ * but this is sufficient to ensure safe decoding.)
+ */
+ if (isDC) {
+ for (i = 0; i < numsymbols; i++) {
+ int sym = htbl->huffval[i];
+ if (sym < 0 || sym > 15)
+ ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+ }
+ }
+}
+
+
+/*
+ * Out-of-line code for bit fetching (shared with jdphuff.c).
+ * See jdhuff.h for info about usage.
+ * Note: current values of get_buffer and bits_left are passed as parameters,
+ * but are returned in the corresponding fields of the state struct.
+ *
+ * On most machines MIN_GET_BITS should be 25 to allow the full 32-bit width
+ * of get_buffer to be used. (On machines with wider words, an even larger
+ * buffer could be used.) However, on some machines 32-bit shifts are
+ * quite slow and take time proportional to the number of places shifted.
+ * (This is true with most PC compilers, for instance.) In this case it may
+ * be a win to set MIN_GET_BITS to the minimum value of 15. This reduces the
+ * average shift distance at the cost of more calls to jpeg_fill_bit_buffer.
+ */
+
+#ifdef SLOW_SHIFT_32
+#define MIN_GET_BITS 15 /* minimum allowable value */
+#else
+#define MIN_GET_BITS (BIT_BUF_SIZE-7)
+#endif
+
+
+GLOBAL(boolean)
+jpeg_fill_bit_buffer (bitread_working_state * state,
+ register bit_buf_type get_buffer, register int bits_left,
+ int nbits)
+/* Load up the bit buffer to a depth of at least nbits */
+{
+ /* Copy heavily used state fields into locals (hopefully registers) */
+ register const JOCTET * next_input_byte = state->next_input_byte;
+ register size_t bytes_in_buffer = state->bytes_in_buffer;
+ j_decompress_ptr cinfo = state->cinfo;
+
+ /* Attempt to load at least MIN_GET_BITS bits into get_buffer. */
+ /* (It is assumed that no request will be for more than that many bits.) */
+ /* We fail to do so only if we hit a marker or are forced to suspend. */
+
+ if (cinfo->unread_marker == 0) { /* cannot advance past a marker */
+ while (bits_left < MIN_GET_BITS) {
+ register int c;
+
+ /* Attempt to read a byte */
+ if (bytes_in_buffer == 0) {
+ if (! (*cinfo->src->fill_input_buffer) (cinfo))
+ return FALSE;
+ next_input_byte = cinfo->src->next_input_byte;
+ bytes_in_buffer = cinfo->src->bytes_in_buffer;
+ }
+ bytes_in_buffer--;
+ c = GETJOCTET(*next_input_byte++);
+
+ /* If it's 0xFF, check and discard stuffed zero byte */
+ if (c == 0xFF) {
+ /* Loop here to discard any padding FF's on terminating marker,
+ * so that we can save a valid unread_marker value. NOTE: we will
+ * accept multiple FF's followed by a 0 as meaning a single FF data
+ * byte. This data pattern is not valid according to the standard.
+ */
+ do {
+ if (bytes_in_buffer == 0) {
+ if (! (*cinfo->src->fill_input_buffer) (cinfo))
+ return FALSE;
+ next_input_byte = cinfo->src->next_input_byte;
+ bytes_in_buffer = cinfo->src->bytes_in_buffer;
+ }
+ bytes_in_buffer--;
+ c = GETJOCTET(*next_input_byte++);
+ } while (c == 0xFF);
+
+ if (c == 0) {
+ /* Found FF/00, which represents an FF data byte */
+ c = 0xFF;
+ } else {
+ /* Oops, it's actually a marker indicating end of compressed data.
+ * Save the marker code for later use.
+ * Fine point: it might appear that we should save the marker into
+ * bitread working state, not straight into permanent state. But
+ * once we have hit a marker, we cannot need to suspend within the
+ * current MCU, because we will read no more bytes from the data
+ * source. So it is OK to update permanent state right away.
+ */
+ cinfo->unread_marker = c;
+ /* See if we need to insert some fake zero bits. */
+ goto no_more_bytes;
+ }
+ }
+
+ /* OK, load c into get_buffer */
+ get_buffer = (get_buffer << 8) | c;
+ bits_left += 8;
+ } /* end while */
+ } else {
+ no_more_bytes:
+ /* We get here if we've read the marker that terminates the compressed
+ * data segment. There should be enough bits in the buffer register
+ * to satisfy the request; if so, no problem.
+ */
+ if (nbits > bits_left) {
+ /* Uh-oh. Report corrupted data to user and stuff zeroes into
+ * the data stream, so that we can produce some kind of image.
+ * We use a nonvolatile flag to ensure that only one warning message
+ * appears per data segment.
+ */
+ if (! cinfo->entropy->insufficient_data) {
+ WARNMS(cinfo, JWRN_HIT_MARKER);
+ cinfo->entropy->insufficient_data = TRUE;
+ }
+ /* Fill the buffer with zero bits */
+ get_buffer <<= MIN_GET_BITS - bits_left;
+ bits_left = MIN_GET_BITS;
+ }
+ }
+
+ /* Unload the local registers */
+ state->next_input_byte = next_input_byte;
+ state->bytes_in_buffer = bytes_in_buffer;
+ state->get_buffer = get_buffer;
+ state->bits_left = bits_left;
+
+ return TRUE;
+}
+
+
+/*
+ * Out-of-line code for Huffman code decoding.
+ * See jdhuff.h for info about usage.
+ */
+
+GLOBAL(int)
+jpeg_huff_decode (bitread_working_state * state,
+ register bit_buf_type get_buffer, register int bits_left,
+ d_derived_tbl * htbl, int min_bits)
+{
+ register int l = min_bits;
+ register INT32 code;
+
+ /* HUFF_DECODE has determined that the code is at least min_bits */
+ /* bits long, so fetch that many bits in one swoop. */
+
+ CHECK_BIT_BUFFER(*state, l, return -1);
+ code = GET_BITS(l);
+
+ /* Collect the rest of the Huffman code one bit at a time. */
+ /* This is per Figure F.16 in the JPEG spec. */
+
+ while (code > htbl->maxcode[l]) {
+ code <<= 1;
+ CHECK_BIT_BUFFER(*state, 1, return -1);
+ code |= GET_BITS(1);
+ l++;
+ }
+
+ /* Unload the local registers */
+ state->get_buffer = get_buffer;
+ state->bits_left = bits_left;
+
+ /* With garbage input we may reach the sentinel value l = 17. */
+
+ if (l > 16) {
+ WARNMS(state->cinfo, JWRN_HUFF_BAD_CODE);
+ return 0; /* fake a zero as the safest result */
+ }
+
+ return htbl->pub->huffval[ (int) (code + htbl->valoffset[l]) ];
+}
+
+
+/*
+ * Figure F.12: extend sign bit.
+ * On some machines, a shift and add will be faster than a table lookup.
+ */
+
+#ifdef AVOID_TABLES
+
+#define HUFF_EXTEND(x,s) ((x) < (1<<((s)-1)) ? (x) + (((-1)<<(s)) + 1) : (x))
+
+#else
+
+#define HUFF_EXTEND(x,s) ((x) < extend_test[s] ? (x) + extend_offset[s] : (x))
+
+static const int extend_test[16] = /* entry n is 2**(n-1) */
+ { 0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
+ 0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000 };
+
+static const int extend_offset[16] = /* entry n is (-1 << n) + 1 */
+ { 0, ((-1)<<1) + 1, ((-1)<<2) + 1, ((-1)<<3) + 1, ((-1)<<4) + 1,
+ ((-1)<<5) + 1, ((-1)<<6) + 1, ((-1)<<7) + 1, ((-1)<<8) + 1,
+ ((-1)<<9) + 1, ((-1)<<10) + 1, ((-1)<<11) + 1, ((-1)<<12) + 1,
+ ((-1)<<13) + 1, ((-1)<<14) + 1, ((-1)<<15) + 1 };
+
+#endif /* AVOID_TABLES */
+
+
+/*
+ * Check for a restart marker & resynchronize decoder.
+ * Returns FALSE if must suspend.
+ */
+
+LOCAL(boolean)
+process_restart (j_decompress_ptr cinfo)
+{
+ huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+ int ci;
+
+ /* Throw away any unused bits remaining in bit buffer; */
+ /* include any full bytes in next_marker's count of discarded bytes */
+ cinfo->marker->discarded_bytes += entropy->bitstate.bits_left / 8;
+ entropy->bitstate.bits_left = 0;
+
+ /* Advance past the RSTn marker */
+ if (! (*cinfo->marker->read_restart_marker) (cinfo))
+ return FALSE;
+
+ /* Re-initialize DC predictions to 0 */
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++)
+ entropy->saved.last_dc_val[ci] = 0;
+
+ /* Reset restart counter */
+ entropy->restarts_to_go = cinfo->restart_interval;
+
+ /* Reset out-of-data flag, unless read_restart_marker left us smack up
+ * against a marker. In that case we will end up treating the next data
+ * segment as empty, and we can avoid producing bogus output pixels by
+ * leaving the flag set.
+ */
+ if (cinfo->unread_marker == 0)
+ entropy->pub.insufficient_data = FALSE;
+
+ return TRUE;
+}
+
+
+/*
+ * Decode and return one MCU's worth of Huffman-compressed coefficients.
+ * The coefficients are reordered from zigzag order into natural array order,
+ * but are not dequantized.
+ *
+ * The i'th block of the MCU is stored into the block pointed to by
+ * MCU_data[i]. WE ASSUME THIS AREA HAS BEEN ZEROED BY THE CALLER.
+ * (Wholesale zeroing is usually a little faster than retail...)
+ *
+ * Returns FALSE if data source requested suspension. In that case no
+ * changes have been made to permanent state. (Exception: some output
+ * coefficients may already have been assigned. This is harmless for
+ * this module, since we'll just re-assign them on the next call.)
+ */
+
+METHODDEF(boolean)
+decode_mcu (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+ huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+ int blkn;
+ BITREAD_STATE_VARS;
+ savable_state state;
+
+ /* Process restart marker if needed; may have to suspend */
+ if (cinfo->restart_interval) {
+ if (entropy->restarts_to_go == 0)
+ if (! process_restart(cinfo))
+ return FALSE;
+ }
+
+ /* If we've run out of data, just leave the MCU set to zeroes.
+ * This way, we return uniform gray for the remainder of the segment.
+ */
+ if (! entropy->pub.insufficient_data) {
+
+ /* Load up working state */
+ BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
+ ASSIGN_STATE(state, entropy->saved);
+
+ /* Outer loop handles each block in the MCU */
+
+ for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+ JBLOCKROW block = MCU_data[blkn];
+ d_derived_tbl * dctbl = entropy->dc_cur_tbls[blkn];
+ d_derived_tbl * actbl = entropy->ac_cur_tbls[blkn];
+ register int s, k, r;
+
+ /* Decode a single block's worth of coefficients */
+
+ /* Section F.2.2.1: decode the DC coefficient difference */
+ HUFF_DECODE(s, br_state, dctbl, return FALSE, label1);
+ if (s) {
+ CHECK_BIT_BUFFER(br_state, s, return FALSE);
+ r = GET_BITS(s);
+ s = HUFF_EXTEND(r, s);
+ }
+
+ if (entropy->dc_needed[blkn]) {
+ /* Convert DC difference to actual value, update last_dc_val */
+ int ci = cinfo->MCU_membership[blkn];
+ s += state.last_dc_val[ci];
+ state.last_dc_val[ci] = s;
+ /* Output the DC coefficient (assumes jpeg_natural_order[0] = 0) */
+ (*block)[0] = (JCOEF) s;
+ }
+
+ if (entropy->ac_needed[blkn]) {
+
+ /* Section F.2.2.2: decode the AC coefficients */
+ /* Since zeroes are skipped, output area must be cleared beforehand */
+ for (k = 1; k < DCTSIZE2; k++) {
+ HUFF_DECODE(s, br_state, actbl, return FALSE, label2);
+
+ r = s >> 4;
+ s &= 15;
+
+ if (s) {
+ k += r;
+ CHECK_BIT_BUFFER(br_state, s, return FALSE);
+ r = GET_BITS(s);
+ s = HUFF_EXTEND(r, s);
+ /* Output coefficient in natural (dezigzagged) order.
+ * Note: the extra entries in jpeg_natural_order[] will save us
+ * if k >= DCTSIZE2, which could happen if the data is corrupted.
+ */
+ (*block)[jpeg_natural_order[k]] = (JCOEF) s;
+ } else {
+ if (r != 15)
+ break;
+ k += 15;
+ }
+ }
+
+ } else {
+
+ /* Section F.2.2.2: decode the AC coefficients */
+ /* In this path we just discard the values */
+ for (k = 1; k < DCTSIZE2; k++) {
+ HUFF_DECODE(s, br_state, actbl, return FALSE, label3);
+
+ r = s >> 4;
+ s &= 15;
+
+ if (s) {
+ k += r;
+ CHECK_BIT_BUFFER(br_state, s, return FALSE);
+ DROP_BITS(s);
+ } else {
+ if (r != 15)
+ break;
+ k += 15;
+ }
+ }
+
+ }
+ }
+
+ /* Completed MCU, so update state */
+ BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
+ ASSIGN_STATE(entropy->saved, state);
+ }
+
+ /* Account for restart interval (no-op if not using restarts) */
+ entropy->restarts_to_go--;
+
+ return TRUE;
+}
+
+
+/*
+ * Module initialization routine for Huffman entropy decoding.
+ */
+
+GLOBAL(void)
+jinit_huff_decoder (j_decompress_ptr cinfo)
+{
+ huff_entropy_ptr entropy;
+ int i;
+
+ entropy = (huff_entropy_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(huff_entropy_decoder));
+ cinfo->entropy = (struct jpeg_entropy_decoder *) entropy;
+ entropy->pub.start_pass = start_pass_huff_decoder;
+ entropy->pub.decode_mcu = decode_mcu;
+
+ /* Mark tables unallocated */
+ for (i = 0; i < NUM_HUFF_TBLS; i++) {
+ entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL;
+ }
+}
--- /dev/null
+/*
+ * jdhuff.h
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * 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 declarations for Huffman entropy decoding routines
+ * that are shared between the sequential decoder (jdhuff.c) and the
+ * progressive decoder (jdphuff.c). No other modules need to see these.
+ */
+
+/* Short forms of external names for systems with brain-damaged linkers. */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_make_d_derived_tbl jMkDDerived
+#define jpeg_fill_bit_buffer jFilBitBuf
+#define jpeg_huff_decode jHufDecode
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+
+/* Derived data constructed for each Huffman table */
+
+#define HUFF_LOOKAHEAD 8 /* # of bits of lookahead */
+
+typedef struct {
+ /* Basic tables: (element [0] of each array is unused) */
+ INT32 maxcode[18]; /* largest code of length k (-1 if none) */
+ /* (maxcode[17] is a sentinel to ensure jpeg_huff_decode terminates) */
+ INT32 valoffset[17]; /* huffval[] offset for codes of length k */
+ /* valoffset[k] = huffval[] index of 1st symbol of code length k, less
+ * the smallest code of length k; so given a code of length k, the
+ * corresponding symbol is huffval[code + valoffset[k]]
+ */
+
+ /* Link to public Huffman table (needed only in jpeg_huff_decode) */
+ JHUFF_TBL *pub;
+
+ /* Lookahead tables: indexed by the next HUFF_LOOKAHEAD bits of
+ * the input data stream. If the next Huffman code is no more
+ * than HUFF_LOOKAHEAD bits long, we can obtain its length and
+ * the corresponding symbol directly from these tables.
+ */
+ int look_nbits[1<<HUFF_LOOKAHEAD]; /* # bits, or 0 if too long */
+ UINT8 look_sym[1<<HUFF_LOOKAHEAD]; /* symbol, or unused */
+} d_derived_tbl;
+
+/* Expand a Huffman table definition into the derived format */
+EXTERN(void) jpeg_make_d_derived_tbl
+ JPP((j_decompress_ptr cinfo, boolean isDC, int tblno,
+ d_derived_tbl ** pdtbl));
+
+
+/*
+ * Fetching the next N bits from the input stream is a time-critical operation
+ * for the Huffman decoders. We implement it with a combination of inline
+ * macros and out-of-line subroutines. Note that N (the number of bits
+ * demanded at one time) never exceeds 15 for JPEG use.
+ *
+ * We read source bytes into get_buffer and dole out bits as needed.
+ * If get_buffer already contains enough bits, they are fetched in-line
+ * by the macros CHECK_BIT_BUFFER and GET_BITS. When there aren't enough
+ * bits, jpeg_fill_bit_buffer is called; it will attempt to fill get_buffer
+ * as full as possible (not just to the number of bits needed; this
+ * prefetching reduces the overhead cost of calling jpeg_fill_bit_buffer).
+ * Note that jpeg_fill_bit_buffer may return FALSE to indicate suspension.
+ * On TRUE return, jpeg_fill_bit_buffer guarantees that get_buffer contains
+ * at least the requested number of bits --- dummy zeroes are inserted if
+ * necessary.
+ */
+
+typedef INT32 bit_buf_type; /* type of bit-extraction buffer */
+#define BIT_BUF_SIZE 32 /* size of buffer in bits */
+
+/* If long is > 32 bits on your machine, and shifting/masking longs is
+ * reasonably fast, making bit_buf_type be long and setting BIT_BUF_SIZE
+ * appropriately should be a win. Unfortunately we can't define the size
+ * with something like #define BIT_BUF_SIZE (sizeof(bit_buf_type)*8)
+ * because not all machines measure sizeof in 8-bit bytes.
+ */
+
+typedef struct { /* Bitreading state saved across MCUs */
+ bit_buf_type get_buffer; /* current bit-extraction buffer */
+ int bits_left; /* # of unused bits in it */
+} bitread_perm_state;
+
+typedef struct { /* Bitreading working state within an MCU */
+ /* Current data source location */
+ /* We need a copy, rather than munging the original, in case of suspension */
+ const JOCTET * next_input_byte; /* => next byte to read from source */
+ size_t bytes_in_buffer; /* # of bytes remaining in source buffer */
+ /* Bit input buffer --- note these values are kept in register variables,
+ * not in this struct, inside the inner loops.
+ */
+ bit_buf_type get_buffer; /* current bit-extraction buffer */
+ int bits_left; /* # of unused bits in it */
+ /* Pointer needed by jpeg_fill_bit_buffer. */
+ j_decompress_ptr cinfo; /* back link to decompress master record */
+} bitread_working_state;
+
+/* Macros to declare and load/save bitread local variables. */
+#define BITREAD_STATE_VARS \
+ register bit_buf_type get_buffer; \
+ register int bits_left; \
+ bitread_working_state br_state
+
+#define BITREAD_LOAD_STATE(cinfop,permstate) \
+ br_state.cinfo = cinfop; \
+ br_state.next_input_byte = cinfop->src->next_input_byte; \
+ br_state.bytes_in_buffer = cinfop->src->bytes_in_buffer; \
+ get_buffer = permstate.get_buffer; \
+ bits_left = permstate.bits_left;
+
+#define BITREAD_SAVE_STATE(cinfop,permstate) \
+ cinfop->src->next_input_byte = br_state.next_input_byte; \
+ cinfop->src->bytes_in_buffer = br_state.bytes_in_buffer; \
+ permstate.get_buffer = get_buffer; \
+ permstate.bits_left = bits_left
+
+/*
+ * These macros provide the in-line portion of bit fetching.
+ * Use CHECK_BIT_BUFFER to ensure there are N bits in get_buffer
+ * before using GET_BITS, PEEK_BITS, or DROP_BITS.
+ * The variables get_buffer and bits_left are assumed to be locals,
+ * but the state struct might not be (jpeg_huff_decode needs this).
+ * CHECK_BIT_BUFFER(state,n,action);
+ * Ensure there are N bits in get_buffer; if suspend, take action.
+ * val = GET_BITS(n);
+ * Fetch next N bits.
+ * val = PEEK_BITS(n);
+ * Fetch next N bits without removing them from the buffer.
+ * DROP_BITS(n);
+ * Discard next N bits.
+ * The value N should be a simple variable, not an expression, because it
+ * is evaluated multiple times.
+ */
+
+#define CHECK_BIT_BUFFER(state,nbits,action) \
+ { if (bits_left < (nbits)) { \
+ if (! jpeg_fill_bit_buffer(&(state),get_buffer,bits_left,nbits)) \
+ { action; } \
+ get_buffer = (state).get_buffer; bits_left = (state).bits_left; } }
+
+#define GET_BITS(nbits) \
+ (((int) (get_buffer >> (bits_left -= (nbits)))) & ((1<<(nbits))-1))
+
+#define PEEK_BITS(nbits) \
+ (((int) (get_buffer >> (bits_left - (nbits)))) & ((1<<(nbits))-1))
+
+#define DROP_BITS(nbits) \
+ (bits_left -= (nbits))
+
+/* Load up the bit buffer to a depth of at least nbits */
+EXTERN(boolean) jpeg_fill_bit_buffer
+ JPP((bitread_working_state * state, register bit_buf_type get_buffer,
+ register int bits_left, int nbits));
+
+
+/*
+ * Code for extracting next Huffman-coded symbol from input bit stream.
+ * Again, this is time-critical and we make the main paths be macros.
+ *
+ * We use a lookahead table to process codes of up to HUFF_LOOKAHEAD bits
+ * without looping. Usually, more than 95% of the Huffman codes will be 8
+ * or fewer bits long. The few overlength codes are handled with a loop,
+ * which need not be inline code.
+ *
+ * Notes about the HUFF_DECODE macro:
+ * 1. Near the end of the data segment, we may fail to get enough bits
+ * for a lookahead. In that case, we do it the hard way.
+ * 2. If the lookahead table contains no entry, the next code must be
+ * more than HUFF_LOOKAHEAD bits long.
+ * 3. jpeg_huff_decode returns -1 if forced to suspend.
+ */
+
+#define HUFF_DECODE(result,state,htbl,failaction,slowlabel) \
+{ register int nb, look; \
+ if (bits_left < HUFF_LOOKAHEAD) { \
+ if (! jpeg_fill_bit_buffer(&state,get_buffer,bits_left, 0)) {failaction;} \
+ get_buffer = state.get_buffer; bits_left = state.bits_left; \
+ if (bits_left < HUFF_LOOKAHEAD) { \
+ nb = 1; goto slowlabel; \
+ } \
+ } \
+ look = PEEK_BITS(HUFF_LOOKAHEAD); \
+ if ((nb = htbl->look_nbits[look]) != 0) { \
+ DROP_BITS(nb); \
+ result = htbl->look_sym[look]; \
+ } else { \
+ nb = HUFF_LOOKAHEAD+1; \
+slowlabel: \
+ if ((result=jpeg_huff_decode(&state,get_buffer,bits_left,htbl,nb)) < 0) \
+ { failaction; } \
+ get_buffer = state.get_buffer; bits_left = state.bits_left; \
+ } \
+}
+
+/* Out-of-line case for Huffman code fetching */
+EXTERN(int) jpeg_huff_decode
+ JPP((bitread_working_state * state, register bit_buf_type get_buffer,
+ register int bits_left, d_derived_tbl * htbl, int min_bits));
--- /dev/null
+/*
+ * jdinput.c
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * 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 input control logic for the JPEG decompressor.
+ * These routines are concerned with controlling the decompressor's input
+ * processing (marker reading and coefficient decoding). The actual input
+ * reading is done in jdmarker.c, jdhuff.c, and jdphuff.c.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private state */
+
+typedef struct {
+ struct jpeg_input_controller pub; /* public fields */
+
+ boolean inheaders; /* TRUE until first SOS is reached */
+} my_input_controller;
+
+typedef my_input_controller * my_inputctl_ptr;
+
+
+/* Forward declarations */
+METHODDEF(int) consume_markers JPP((j_decompress_ptr cinfo));
+
+
+/*
+ * Routines to calculate various quantities related to the size of the image.
+ */
+
+LOCAL(void)
+initial_setup (j_decompress_ptr cinfo)
+/* Called once, when first SOS marker is reached */
+{
+ int ci;
+ jpeg_component_info *compptr;
+
+ /* Make sure image isn't bigger than I can handle */
+ if ((long) cinfo->image_height > (long) JPEG_MAX_DIMENSION ||
+ (long) cinfo->image_width > (long) JPEG_MAX_DIMENSION)
+ ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) JPEG_MAX_DIMENSION);
+
+ /* For now, precision must match compiled-in value... */
+ if (cinfo->data_precision != BITS_IN_JSAMPLE)
+ ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
+
+ /* Check that number of components won't exceed internal array sizes */
+ if (cinfo->num_components > MAX_COMPONENTS)
+ ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
+ MAX_COMPONENTS);
+
+ /* Compute maximum sampling factors; check factor validity */
+ cinfo->max_h_samp_factor = 1;
+ cinfo->max_v_samp_factor = 1;
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ if (compptr->h_samp_factor<=0 || compptr->h_samp_factor>MAX_SAMP_FACTOR ||
+ compptr->v_samp_factor<=0 || compptr->v_samp_factor>MAX_SAMP_FACTOR)
+ ERREXIT(cinfo, JERR_BAD_SAMPLING);
+ cinfo->max_h_samp_factor = MAX(cinfo->max_h_samp_factor,
+ compptr->h_samp_factor);
+ cinfo->max_v_samp_factor = MAX(cinfo->max_v_samp_factor,
+ compptr->v_samp_factor);
+ }
+
+ /* We initialize DCT_scaled_size and min_DCT_scaled_size to DCTSIZE.
+ * In the full decompressor, this will be overridden by jdmaster.c;
+ * but in the transcoder, jdmaster.c is not used, so we must do it here.
+ */
+ cinfo->min_DCT_scaled_size = DCTSIZE;
+
+ /* Compute dimensions of components */
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ compptr->DCT_scaled_size = DCTSIZE;
+ /* Size in DCT blocks */
+ compptr->width_in_blocks = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,
+ (long) (cinfo->max_h_samp_factor * DCTSIZE));
+ compptr->height_in_blocks = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,
+ (long) (cinfo->max_v_samp_factor * DCTSIZE));
+ /* downsampled_width and downsampled_height will also be overridden by
+ * jdmaster.c if we are doing full decompression. The transcoder library
+ * doesn't use these values, but the calling application might.
+ */
+ /* Size in samples */
+ compptr->downsampled_width = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,
+ (long) cinfo->max_h_samp_factor);
+ compptr->downsampled_height = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,
+ (long) cinfo->max_v_samp_factor);
+ /* Mark component needed, until color conversion says otherwise */
+ compptr->component_needed = TRUE;
+ /* Mark no quantization table yet saved for component */
+ compptr->quant_table = NULL;
+ }
+
+ /* Compute number of fully interleaved MCU rows. */
+ cinfo->total_iMCU_rows = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_height,
+ (long) (cinfo->max_v_samp_factor*DCTSIZE));
+
+ /* Decide whether file contains multiple scans */
+ if (cinfo->comps_in_scan < cinfo->num_components || cinfo->progressive_mode)
+ cinfo->inputctl->has_multiple_scans = TRUE;
+ else
+ cinfo->inputctl->has_multiple_scans = FALSE;
+}
+
+
+LOCAL(void)
+per_scan_setup (j_decompress_ptr cinfo)
+/* Do computations that are needed before processing a JPEG scan */
+/* cinfo->comps_in_scan and cinfo->cur_comp_info[] were set from SOS marker */
+{
+ int ci, mcublks, tmp;
+ jpeg_component_info *compptr;
+
+ if (cinfo->comps_in_scan == 1) {
+
+ /* Noninterleaved (single-component) scan */
+ compptr = cinfo->cur_comp_info[0];
+
+ /* Overall image size in MCUs */
+ cinfo->MCUs_per_row = compptr->width_in_blocks;
+ cinfo->MCU_rows_in_scan = compptr->height_in_blocks;
+
+ /* For noninterleaved scan, always one block per MCU */
+ compptr->MCU_width = 1;
+ compptr->MCU_height = 1;
+ compptr->MCU_blocks = 1;
+ compptr->MCU_sample_width = compptr->DCT_scaled_size;
+ compptr->last_col_width = 1;
+ /* For noninterleaved scans, it is convenient to define last_row_height
+ * as the number of block rows present in the last iMCU row.
+ */
+ tmp = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
+ if (tmp == 0) tmp = compptr->v_samp_factor;
+ compptr->last_row_height = tmp;
+
+ /* Prepare array describing MCU composition */
+ cinfo->blocks_in_MCU = 1;
+ cinfo->MCU_membership[0] = 0;
+
+ } else {
+
+ /* Interleaved (multi-component) scan */
+ if (cinfo->comps_in_scan <= 0 || cinfo->comps_in_scan > MAX_COMPS_IN_SCAN)
+ ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->comps_in_scan,
+ MAX_COMPS_IN_SCAN);
+
+ /* Overall image size in MCUs */
+ cinfo->MCUs_per_row = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_width,
+ (long) (cinfo->max_h_samp_factor*DCTSIZE));
+ cinfo->MCU_rows_in_scan = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_height,
+ (long) (cinfo->max_v_samp_factor*DCTSIZE));
+
+ cinfo->blocks_in_MCU = 0;
+
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ /* Sampling factors give # of blocks of component in each MCU */
+ compptr->MCU_width = compptr->h_samp_factor;
+ compptr->MCU_height = compptr->v_samp_factor;
+ compptr->MCU_blocks = compptr->MCU_width * compptr->MCU_height;
+ compptr->MCU_sample_width = compptr->MCU_width * compptr->DCT_scaled_size;
+ /* Figure number of non-dummy blocks in last MCU column & row */
+ tmp = (int) (compptr->width_in_blocks % compptr->MCU_width);
+ if (tmp == 0) tmp = compptr->MCU_width;
+ compptr->last_col_width = tmp;
+ tmp = (int) (compptr->height_in_blocks % compptr->MCU_height);
+ if (tmp == 0) tmp = compptr->MCU_height;
+ compptr->last_row_height = tmp;
+ /* Prepare array describing MCU composition */
+ mcublks = compptr->MCU_blocks;
+ if (cinfo->blocks_in_MCU + mcublks > D_MAX_BLOCKS_IN_MCU)
+ ERREXIT(cinfo, JERR_BAD_MCU_SIZE);
+ while (mcublks-- > 0) {
+ cinfo->MCU_membership[cinfo->blocks_in_MCU++] = ci;
+ }
+ }
+
+ }
+}
+
+
+/*
+ * Save away a copy of the Q-table referenced by each component present
+ * in the current scan, unless already saved during a prior scan.
+ *
+ * In a multiple-scan JPEG file, the encoder could assign different components
+ * the same Q-table slot number, but change table definitions between scans
+ * so that each component uses a different Q-table. (The IJG encoder is not
+ * currently capable of doing this, but other encoders might.) Since we want
+ * to be able to dequantize all the components at the end of the file, this
+ * means that we have to save away the table actually used for each component.
+ * We do this by copying the table at the start of the first scan containing
+ * the component.
+ * The JPEG spec prohibits the encoder from changing the contents of a Q-table
+ * slot between scans of a component using that slot. If the encoder does so
+ * anyway, this decoder will simply use the Q-table values that were current
+ * at the start of the first scan for the component.
+ *
+ * The decompressor output side looks only at the saved quant tables,
+ * not at the current Q-table slots.
+ */
+
+LOCAL(void)
+latch_quant_tables (j_decompress_ptr cinfo)
+{
+ int ci, qtblno;
+ jpeg_component_info *compptr;
+ JQUANT_TBL * qtbl;
+
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ /* No work if we already saved Q-table for this component */
+ if (compptr->quant_table != NULL)
+ continue;
+ /* Make sure specified quantization table is present */
+ qtblno = compptr->quant_tbl_no;
+ if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS ||
+ cinfo->quant_tbl_ptrs[qtblno] == NULL)
+ ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno);
+ /* OK, save away the quantization table */
+ qtbl = (JQUANT_TBL *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(JQUANT_TBL));
+ MEMCOPY(qtbl, cinfo->quant_tbl_ptrs[qtblno], SIZEOF(JQUANT_TBL));
+ compptr->quant_table = qtbl;
+ }
+}
+
+
+/*
+ * Initialize the input modules to read a scan of compressed data.
+ * The first call to this is done by jdmaster.c after initializing
+ * the entire decompressor (during jpeg_start_decompress).
+ * Subsequent calls come from consume_markers, below.
+ */
+
+METHODDEF(void)
+start_input_pass (j_decompress_ptr cinfo)
+{
+ per_scan_setup(cinfo);
+ latch_quant_tables(cinfo);
+ (*cinfo->entropy->start_pass) (cinfo);
+ (*cinfo->coef->start_input_pass) (cinfo);
+ cinfo->inputctl->consume_input = cinfo->coef->consume_data;
+}
+
+
+/*
+ * Finish up after inputting a compressed-data scan.
+ * This is called by the coefficient controller after it's read all
+ * the expected data of the scan.
+ */
+
+METHODDEF(void)
+finish_input_pass (j_decompress_ptr cinfo)
+{
+ cinfo->inputctl->consume_input = consume_markers;
+}
+
+
+/*
+ * Read JPEG markers before, between, or after compressed-data scans.
+ * Change state as necessary when a new scan is reached.
+ * Return value is JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
+ *
+ * The consume_input method pointer points either here or to the
+ * coefficient controller's consume_data routine, depending on whether
+ * we are reading a compressed data segment or inter-segment markers.
+ */
+
+METHODDEF(int)
+consume_markers (j_decompress_ptr cinfo)
+{
+ my_inputctl_ptr inputctl = (my_inputctl_ptr) cinfo->inputctl;
+ int val;
+
+ if (inputctl->pub.eoi_reached) /* After hitting EOI, read no further */
+ return JPEG_REACHED_EOI;
+
+ val = (*cinfo->marker->read_markers) (cinfo);
+
+ switch (val) {
+ case JPEG_REACHED_SOS: /* Found SOS */
+ if (inputctl->inheaders) { /* 1st SOS */
+ initial_setup(cinfo);
+ inputctl->inheaders = FALSE;
+ /* Note: start_input_pass must be called by jdmaster.c
+ * before any more input can be consumed. jdapimin.c is
+ * responsible for enforcing this sequencing.
+ */
+ } else { /* 2nd or later SOS marker */
+ if (! inputctl->pub.has_multiple_scans)
+ ERREXIT(cinfo, JERR_EOI_EXPECTED); /* Oops, I wasn't expecting this! */
+ start_input_pass(cinfo);
+ }
+ break;
+ case JPEG_REACHED_EOI: /* Found EOI */
+ inputctl->pub.eoi_reached = TRUE;
+ if (inputctl->inheaders) { /* Tables-only datastream, apparently */
+ if (cinfo->marker->saw_SOF)
+ ERREXIT(cinfo, JERR_SOF_NO_SOS);
+ } else {
+ /* Prevent infinite loop in coef ctlr's decompress_data routine
+ * if user set output_scan_number larger than number of scans.
+ */
+ if (cinfo->output_scan_number > cinfo->input_scan_number)
+ cinfo->output_scan_number = cinfo->input_scan_number;
+ }
+ break;
+ case JPEG_SUSPENDED:
+ break;
+ }
+
+ return val;
+}
+
+
+/*
+ * Reset state to begin a fresh datastream.
+ */
+
+METHODDEF(void)
+reset_input_controller (j_decompress_ptr cinfo)
+{
+ my_inputctl_ptr inputctl = (my_inputctl_ptr) cinfo->inputctl;
+
+ inputctl->pub.consume_input = consume_markers;
+ inputctl->pub.has_multiple_scans = FALSE; /* "unknown" would be better */
+ inputctl->pub.eoi_reached = FALSE;
+ inputctl->inheaders = TRUE;
+ /* Reset other modules */
+ (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
+ (*cinfo->marker->reset_marker_reader) (cinfo);
+ /* Reset progression state -- would be cleaner if entropy decoder did this */
+ cinfo->coef_bits = NULL;
+}
+
+
+/*
+ * Initialize the input controller module.
+ * This is called only once, when the decompression object is created.
+ */
+
+GLOBAL(void)
+jinit_input_controller (j_decompress_ptr cinfo)
+{
+ my_inputctl_ptr inputctl;
+
+ /* Create subobject in permanent pool */
+ inputctl = (my_inputctl_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+ SIZEOF(my_input_controller));
+ cinfo->inputctl = (struct jpeg_input_controller *) inputctl;
+ /* Initialize method pointers */
+ inputctl->pub.consume_input = consume_markers;
+ inputctl->pub.reset_input_controller = reset_input_controller;
+ inputctl->pub.start_input_pass = start_input_pass;
+ inputctl->pub.finish_input_pass = finish_input_pass;
+ /* Initialize state: can't use reset_input_controller since we don't
+ * want to try to reset other modules yet.
+ */
+ inputctl->pub.has_multiple_scans = FALSE; /* "unknown" would be better */
+ inputctl->pub.eoi_reached = FALSE;
+ inputctl->inheaders = TRUE;
+}
--- /dev/null
+/*
+ * jdmainct.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * 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 the main buffer controller for decompression.
+ * The main buffer lies between the JPEG decompressor proper and the
+ * post-processor; it holds downsampled data in the JPEG colorspace.
+ *
+ * Note that this code is bypassed in raw-data mode, since the application
+ * supplies the equivalent of the main buffer in that case.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * In the current system design, the main buffer need never be a full-image
+ * buffer; any full-height buffers will be found inside the coefficient or
+ * postprocessing controllers. Nonetheless, the main controller is not
+ * trivial. Its responsibility is to provide context rows for upsampling/
+ * rescaling, and doing this in an efficient fashion is a bit tricky.
+ *
+ * Postprocessor input data is counted in "row groups". A row group
+ * is defined to be (v_samp_factor * DCT_scaled_size / min_DCT_scaled_size)
+ * sample rows of each component. (We require DCT_scaled_size values to be
+ * chosen such that these numbers are integers. In practice DCT_scaled_size
+ * values will likely be powers of two, so we actually have the stronger
+ * condition that DCT_scaled_size / min_DCT_scaled_size is an integer.)
+ * Upsampling will typically produce max_v_samp_factor pixel rows from each
+ * row group (times any additional scale factor that the upsampler is
+ * applying).
+ *
+ * The coefficient controller will deliver data to us one iMCU row at a time;
+ * each iMCU row contains v_samp_factor * DCT_scaled_size sample rows, or
+ * exactly min_DCT_scaled_size row groups. (This amount of data corresponds
+ * to one row of MCUs when the image is fully interleaved.) Note that the
+ * number of sample rows varies across components, but the number of row
+ * groups does not. Some garbage sample rows may be included in the last iMCU
+ * row at the bottom of the image.
+ *
+ * Depending on the vertical scaling algorithm used, the upsampler may need
+ * access to the sample row(s) above and below its current input row group.
+ * The upsampler is required to set need_context_rows TRUE at global selection
+ * time if so. When need_context_rows is FALSE, this controller can simply
+ * obtain one iMCU row at a time from the coefficient controller and dole it
+ * out as row groups to the postprocessor.
+ *
+ * When need_context_rows is TRUE, this controller guarantees that the buffer
+ * passed to postprocessing contains at least one row group's worth of samples
+ * above and below the row group(s) being processed. Note that the context
+ * rows "above" the first passed row group appear at negative row offsets in
+ * the passed buffer. At the top and bottom of the image, the required
+ * context rows are manufactured by duplicating the first or last real sample
+ * row; this avoids having special cases in the upsampling inner loops.
+ *
+ * The amount of context is fixed at one row group just because that's a
+ * convenient number for this controller to work with. The existing
+ * upsamplers really only need one sample row of context. An upsampler
+ * supporting arbitrary output rescaling might wish for more than one row
+ * group of context when shrinking the image; tough, we don't handle that.
+ * (This is justified by the assumption that downsizing will be handled mostly
+ * by adjusting the DCT_scaled_size values, so that the actual scale factor at
+ * the upsample step needn't be much less than one.)
+ *
+ * To provide the desired context, we have to retain the last two row groups
+ * of one iMCU row while reading in the next iMCU row. (The last row group
+ * can't be processed until we have another row group for its below-context,
+ * and so we have to save the next-to-last group too for its above-context.)
+ * We could do this most simply by copying data around in our buffer, but
+ * that'd be very slow. We can avoid copying any data by creating a rather
+ * strange pointer structure. Here's how it works. We allocate a workspace
+ * consisting of M+2 row groups (where M = min_DCT_scaled_size is the number
+ * of row groups per iMCU row). We create two sets of redundant pointers to
+ * the workspace. Labeling the physical row groups 0 to M+1, the synthesized
+ * pointer lists look like this:
+ * M+1 M-1
+ * master pointer --> 0 master pointer --> 0
+ * 1 1
+ * ... ...
+ * M-3 M-3
+ * M-2 M
+ * M-1 M+1
+ * M M-2
+ * M+1 M-1
+ * 0 0
+ * We read alternate iMCU rows using each master pointer; thus the last two
+ * row groups of the previous iMCU row remain un-overwritten in the workspace.
+ * The pointer lists are set up so that the required context rows appear to
+ * be adjacent to the proper places when we pass the pointer lists to the
+ * upsampler.
+ *
+ * The above pictures describe the normal state of the pointer lists.
+ * At top and bottom of the image, we diddle the pointer lists to duplicate
+ * the first or last sample row as necessary (this is cheaper than copying
+ * sample rows around).
+ *
+ * This scheme breaks down if M < 2, ie, min_DCT_scaled_size is 1. In that
+ * situation each iMCU row provides only one row group so the buffering logic
+ * must be different (eg, we must read two iMCU rows before we can emit the
+ * first row group). For now, we simply do not support providing context
+ * rows when min_DCT_scaled_size is 1. That combination seems unlikely to
+ * be worth providing --- if someone wants a 1/8th-size preview, they probably
+ * want it quick and dirty, so a context-free upsampler is sufficient.
+ */
+
+
+/* Private buffer controller object */
+
+typedef struct {
+ struct jpeg_d_main_controller pub; /* public fields */
+
+ /* Pointer to allocated workspace (M or M+2 row groups). */
+ JSAMPARRAY buffer[MAX_COMPONENTS];
+
+ boolean buffer_full; /* Have we gotten an iMCU row from decoder? */
+ JDIMENSION rowgroup_ctr; /* counts row groups output to postprocessor */
+
+ /* Remaining fields are only used in the context case. */
+
+ /* These are the master pointers to the funny-order pointer lists. */
+ JSAMPIMAGE xbuffer[2]; /* pointers to weird pointer lists */
+
+ int whichptr; /* indicates which pointer set is now in use */
+ int context_state; /* process_data state machine status */
+ JDIMENSION rowgroups_avail; /* row groups available to postprocessor */
+ JDIMENSION iMCU_row_ctr; /* counts iMCU rows to detect image top/bot */
+} my_main_controller;
+
+typedef my_main_controller * my_main_ptr;
+
+/* context_state values: */
+#define CTX_PREPARE_FOR_IMCU 0 /* need to prepare for MCU row */
+#define CTX_PROCESS_IMCU 1 /* feeding iMCU to postprocessor */
+#define CTX_POSTPONED_ROW 2 /* feeding postponed row group */
+
+
+/* Forward declarations */
+METHODDEF(void) process_data_simple_main
+ JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf,
+ JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail));
+METHODDEF(void) process_data_context_main
+ JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf,
+ JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail));
+#ifdef QUANT_2PASS_SUPPORTED
+METHODDEF(void) process_data_crank_post
+ JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf,
+ JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail));
+#endif
+
+
+LOCAL(void)
+alloc_funny_pointers (j_decompress_ptr cinfo)
+/* Allocate space for the funny pointer lists.
+ * This is done only once, not once per pass.
+ */
+{
+ my_main_ptr main = (my_main_ptr) cinfo->main;
+ int ci, rgroup;
+ int M = cinfo->min_DCT_scaled_size;
+ jpeg_component_info *compptr;
+ JSAMPARRAY xbuf;
+
+ /* Get top-level space for component array pointers.
+ * We alloc both arrays with one call to save a few cycles.
+ */
+ main->xbuffer[0] = (JSAMPIMAGE)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ cinfo->num_components * 2 * SIZEOF(JSAMPARRAY));
+ main->xbuffer[1] = main->xbuffer[0] + cinfo->num_components;
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
+ cinfo->min_DCT_scaled_size; /* height of a row group of component */
+ /* Get space for pointer lists --- M+4 row groups in each list.
+ * We alloc both pointer lists with one call to save a few cycles.
+ */
+ xbuf = (JSAMPARRAY)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ 2 * (rgroup * (M + 4)) * SIZEOF(JSAMPROW));
+ xbuf += rgroup; /* want one row group at negative offsets */
+ main->xbuffer[0][ci] = xbuf;
+ xbuf += rgroup * (M + 4);
+ main->xbuffer[1][ci] = xbuf;
+ }
+}
+
+
+LOCAL(void)
+make_funny_pointers (j_decompress_ptr cinfo)
+/* Create the funny pointer lists discussed in the comments above.
+ * The actual workspace is already allocated (in main->buffer),
+ * and the space for the pointer lists is allocated too.
+ * This routine just fills in the curiously ordered lists.
+ * This will be repeated at the beginning of each pass.
+ */
+{
+ my_main_ptr main = (my_main_ptr) cinfo->main;
+ int ci, i, rgroup;
+ int M = cinfo->min_DCT_scaled_size;
+ jpeg_component_info *compptr;
+ JSAMPARRAY buf, xbuf0, xbuf1;
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
+ cinfo->min_DCT_scaled_size; /* height of a row group of component */
+ xbuf0 = main->xbuffer[0][ci];
+ xbuf1 = main->xbuffer[1][ci];
+ /* First copy the workspace pointers as-is */
+ buf = main->buffer[ci];
+ for (i = 0; i < rgroup * (M + 2); i++) {
+ xbuf0[i] = xbuf1[i] = buf[i];
+ }
+ /* In the second list, put the last four row groups in swapped order */
+ for (i = 0; i < rgroup * 2; i++) {
+ xbuf1[rgroup*(M-2) + i] = buf[rgroup*M + i];
+ xbuf1[rgroup*M + i] = buf[rgroup*(M-2) + i];
+ }
+ /* The wraparound pointers at top and bottom will be filled later
+ * (see set_wraparound_pointers, below). Initially we want the "above"
+ * pointers to duplicate the first actual data line. This only needs
+ * to happen in xbuffer[0].
+ */
+ for (i = 0; i < rgroup; i++) {
+ xbuf0[i - rgroup] = xbuf0[0];
+ }
+ }
+}
+
+
+LOCAL(void)
+set_wraparound_pointers (j_decompress_ptr cinfo)
+/* Set up the "wraparound" pointers at top and bottom of the pointer lists.
+ * This changes the pointer list state from top-of-image to the normal state.
+ */
+{
+ my_main_ptr main = (my_main_ptr) cinfo->main;
+ int ci, i, rgroup;
+ int M = cinfo->min_DCT_scaled_size;
+ jpeg_component_info *compptr;
+ JSAMPARRAY xbuf0, xbuf1;
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
+ cinfo->min_DCT_scaled_size; /* height of a row group of component */
+ xbuf0 = main->xbuffer[0][ci];
+ xbuf1 = main->xbuffer[1][ci];
+ for (i = 0; i < rgroup; i++) {
+ xbuf0[i - rgroup] = xbuf0[rgroup*(M+1) + i];
+ xbuf1[i - rgroup] = xbuf1[rgroup*(M+1) + i];
+ xbuf0[rgroup*(M+2) + i] = xbuf0[i];
+ xbuf1[rgroup*(M+2) + i] = xbuf1[i];
+ }
+ }
+}
+
+
+LOCAL(void)
+set_bottom_pointers (j_decompress_ptr cinfo)
+/* Change the pointer lists to duplicate the last sample row at the bottom
+ * of the image. whichptr indicates which xbuffer holds the final iMCU row.
+ * Also sets rowgroups_avail to indicate number of nondummy row groups in row.
+ */
+{
+ my_main_ptr main = (my_main_ptr) cinfo->main;
+ int ci, i, rgroup, iMCUheight, rows_left;
+ jpeg_component_info *compptr;
+ JSAMPARRAY xbuf;
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ /* Count sample rows in one iMCU row and in one row group */
+ iMCUheight = compptr->v_samp_factor * compptr->DCT_scaled_size;
+ rgroup = iMCUheight / cinfo->min_DCT_scaled_size;
+ /* Count nondummy sample rows remaining for this component */
+ rows_left = (int) (compptr->downsampled_height % (JDIMENSION) iMCUheight);
+ if (rows_left == 0) rows_left = iMCUheight;
+ /* Count nondummy row groups. Should get same answer for each component,
+ * so we need only do it once.
+ */
+ if (ci == 0) {
+ main->rowgroups_avail = (JDIMENSION) ((rows_left-1) / rgroup + 1);
+ }
+ /* Duplicate the last real sample row rgroup*2 times; this pads out the
+ * last partial rowgroup and ensures at least one full rowgroup of context.
+ */
+ xbuf = main->xbuffer[main->whichptr][ci];
+ for (i = 0; i < rgroup * 2; i++) {
+ xbuf[rows_left + i] = xbuf[rows_left-1];
+ }
+ }
+}
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF(void)
+start_pass_main (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+ my_main_ptr main = (my_main_ptr) cinfo->main;
+
+ switch (pass_mode) {
+ case JBUF_PASS_THRU:
+ if (cinfo->upsample->need_context_rows) {
+ main->pub.process_data = process_data_context_main;
+ make_funny_pointers(cinfo); /* Create the xbuffer[] lists */
+ main->whichptr = 0; /* Read first iMCU row into xbuffer[0] */
+ main->context_state = CTX_PREPARE_FOR_IMCU;
+ main->iMCU_row_ctr = 0;
+ } else {
+ /* Simple case with no context needed */
+ main->pub.process_data = process_data_simple_main;
+ }
+ main->buffer_full = FALSE; /* Mark buffer empty */
+ main->rowgroup_ctr = 0;
+ break;
+#ifdef QUANT_2PASS_SUPPORTED
+ case JBUF_CRANK_DEST:
+ /* For last pass of 2-pass quantization, just crank the postprocessor */
+ main->pub.process_data = process_data_crank_post;
+ break;
+#endif
+ default:
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+ break;
+ }
+}
+
+
+/*
+ * Process some data.
+ * This handles the simple case where no context is required.
+ */
+
+METHODDEF(void)
+process_data_simple_main (j_decompress_ptr cinfo,
+ JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail)
+{
+ my_main_ptr main = (my_main_ptr) cinfo->main;
+ JDIMENSION rowgroups_avail;
+
+ /* Read input data if we haven't filled the main buffer yet */
+ if (! main->buffer_full) {
+ if (! (*cinfo->coef->decompress_data) (cinfo, main->buffer))
+ return; /* suspension forced, can do nothing more */
+ main->buffer_full = TRUE; /* OK, we have an iMCU row to work with */
+ }
+
+ /* There are always min_DCT_scaled_size row groups in an iMCU row. */
+ rowgroups_avail = (JDIMENSION) cinfo->min_DCT_scaled_size;
+ /* Note: at the bottom of the image, we may pass extra garbage row groups
+ * to the postprocessor. The postprocessor has to check for bottom
+ * of image anyway (at row resolution), so no point in us doing it too.
+ */
+
+ /* Feed the postprocessor */
+ (*cinfo->post->post_process_data) (cinfo, main->buffer,
+ &main->rowgroup_ctr, rowgroups_avail,
+ output_buf, out_row_ctr, out_rows_avail);
+
+ /* Has postprocessor consumed all the data yet? If so, mark buffer empty */
+ if (main->rowgroup_ctr >= rowgroups_avail) {
+ main->buffer_full = FALSE;
+ main->rowgroup_ctr = 0;
+ }
+}
+
+
+/*
+ * Process some data.
+ * This handles the case where context rows must be provided.
+ */
+
+METHODDEF(void)
+process_data_context_main (j_decompress_ptr cinfo,
+ JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail)
+{
+ my_main_ptr main = (my_main_ptr) cinfo->main;
+
+ /* Read input data if we haven't filled the main buffer yet */
+ if (! main->buffer_full) {
+ if (! (*cinfo->coef->decompress_data) (cinfo,
+ main->xbuffer[main->whichptr]))
+ return; /* suspension forced, can do nothing more */
+ main->buffer_full = TRUE; /* OK, we have an iMCU row to work with */
+ main->iMCU_row_ctr++; /* count rows received */
+ }
+
+ /* Postprocessor typically will not swallow all the input data it is handed
+ * in one call (due to filling the output buffer first). Must be prepared
+ * to exit and restart. This switch lets us keep track of how far we got.
+ * Note that each case falls through to the next on successful completion.
+ */
+ switch (main->context_state) {
+ case CTX_POSTPONED_ROW:
+ /* Call postprocessor using previously set pointers for postponed row */
+ (*cinfo->post->post_process_data) (cinfo, main->xbuffer[main->whichptr],
+ &main->rowgroup_ctr, main->rowgroups_avail,
+ output_buf, out_row_ctr, out_rows_avail);
+ if (main->rowgroup_ctr < main->rowgroups_avail)
+ return; /* Need to suspend */
+ main->context_state = CTX_PREPARE_FOR_IMCU;
+ if (*out_row_ctr >= out_rows_avail)
+ return; /* Postprocessor exactly filled output buf */
+ /*FALLTHROUGH*/
+ case CTX_PREPARE_FOR_IMCU:
+ /* Prepare to process first M-1 row groups of this iMCU row */
+ main->rowgroup_ctr = 0;
+ main->rowgroups_avail = (JDIMENSION) (cinfo->min_DCT_scaled_size - 1);
+ /* Check for bottom of image: if so, tweak pointers to "duplicate"
+ * the last sample row, and adjust rowgroups_avail to ignore padding rows.
+ */
+ if (main->iMCU_row_ctr == cinfo->total_iMCU_rows)
+ set_bottom_pointers(cinfo);
+ main->context_state = CTX_PROCESS_IMCU;
+ /*FALLTHROUGH*/
+ case CTX_PROCESS_IMCU:
+ /* Call postprocessor using previously set pointers */
+ (*cinfo->post->post_process_data) (cinfo, main->xbuffer[main->whichptr],
+ &main->rowgroup_ctr, main->rowgroups_avail,
+ output_buf, out_row_ctr, out_rows_avail);
+ if (main->rowgroup_ctr < main->rowgroups_avail)
+ return; /* Need to suspend */
+ /* After the first iMCU, change wraparound pointers to normal state */
+ if (main->iMCU_row_ctr == 1)
+ set_wraparound_pointers(cinfo);
+ /* Prepare to load new iMCU row using other xbuffer list */
+ main->whichptr ^= 1; /* 0=>1 or 1=>0 */
+ main->buffer_full = FALSE;
+ /* Still need to process last row group of this iMCU row, */
+ /* which is saved at index M+1 of the other xbuffer */
+ main->rowgroup_ctr = (JDIMENSION) (cinfo->min_DCT_scaled_size + 1);
+ main->rowgroups_avail = (JDIMENSION) (cinfo->min_DCT_scaled_size + 2);
+ main->context_state = CTX_POSTPONED_ROW;
+ }
+}
+
+
+/*
+ * Process some data.
+ * Final pass of two-pass quantization: just call the postprocessor.
+ * Source data will be the postprocessor controller's internal buffer.
+ */
+
+#ifdef QUANT_2PASS_SUPPORTED
+
+METHODDEF(void)
+process_data_crank_post (j_decompress_ptr cinfo,
+ JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail)
+{
+ (*cinfo->post->post_process_data) (cinfo, (JSAMPIMAGE) NULL,
+ (JDIMENSION *) NULL, (JDIMENSION) 0,
+ output_buf, out_row_ctr, out_rows_avail);
+}
+
+#endif /* QUANT_2PASS_SUPPORTED */
+
+
+/*
+ * Initialize main buffer controller.
+ */
+
+GLOBAL(void)
+jinit_d_main_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
+{
+ my_main_ptr main;
+ int ci, rgroup, ngroups;
+ jpeg_component_info *compptr;
+
+ main = (my_main_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_main_controller));
+ cinfo->main = (struct jpeg_d_main_controller *) main;
+ main->pub.start_pass = start_pass_main;
+
+ if (need_full_buffer) /* shouldn't happen */
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+
+ /* Allocate the workspace.
+ * ngroups is the number of row groups we need.
+ */
+ if (cinfo->upsample->need_context_rows) {
+ if (cinfo->min_DCT_scaled_size < 2) /* unsupported, see comments above */
+ ERREXIT(cinfo, JERR_NOTIMPL);
+ alloc_funny_pointers(cinfo); /* Alloc space for xbuffer[] lists */
+ ngroups = cinfo->min_DCT_scaled_size + 2;
+ } else {
+ ngroups = cinfo->min_DCT_scaled_size;
+ }
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
+ cinfo->min_DCT_scaled_size; /* height of a row group of component */
+ main->buffer[ci] = (*cinfo->mem->alloc_sarray)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ compptr->width_in_blocks * compptr->DCT_scaled_size,
+ (JDIMENSION) (rgroup * ngroups));
+ }
+}
--- /dev/null
+/*
+ * jdmarker.c
+ *
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * 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 routines to decode JPEG datastream markers.
+ * Most of the complexity arises from our desire to support input
+ * suspension: if not all of the data for a marker is available,
+ * we must exit back to the application. On resumption, we reprocess
+ * the marker.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+typedef enum { /* JPEG marker codes */
+ M_SOF0 = 0xc0,
+ M_SOF1 = 0xc1,
+ M_SOF2 = 0xc2,
+ M_SOF3 = 0xc3,
+
+ M_SOF5 = 0xc5,
+ M_SOF6 = 0xc6,
+ M_SOF7 = 0xc7,
+
+ M_JPG = 0xc8,
+ M_SOF9 = 0xc9,
+ M_SOF10 = 0xca,
+ M_SOF11 = 0xcb,
+
+ M_SOF13 = 0xcd,
+ M_SOF14 = 0xce,
+ M_SOF15 = 0xcf,
+
+ M_DHT = 0xc4,
+
+ M_DAC = 0xcc,
+
+ M_RST0 = 0xd0,
+ M_RST1 = 0xd1,
+ M_RST2 = 0xd2,
+ M_RST3 = 0xd3,
+ M_RST4 = 0xd4,
+ M_RST5 = 0xd5,
+ M_RST6 = 0xd6,
+ M_RST7 = 0xd7,
+
+ M_SOI = 0xd8,
+ M_EOI = 0xd9,
+ M_SOS = 0xda,
+ M_DQT = 0xdb,
+ M_DNL = 0xdc,
+ M_DRI = 0xdd,
+ M_DHP = 0xde,
+ M_EXP = 0xdf,
+
+ M_APP0 = 0xe0,
+ M_APP1 = 0xe1,
+ M_APP2 = 0xe2,
+ M_APP3 = 0xe3,
+ M_APP4 = 0xe4,
+ M_APP5 = 0xe5,
+ M_APP6 = 0xe6,
+ M_APP7 = 0xe7,
+ M_APP8 = 0xe8,
+ M_APP9 = 0xe9,
+ M_APP10 = 0xea,
+ M_APP11 = 0xeb,
+ M_APP12 = 0xec,
+ M_APP13 = 0xed,
+ M_APP14 = 0xee,
+ M_APP15 = 0xef,
+
+ M_JPG0 = 0xf0,
+ M_JPG13 = 0xfd,
+ M_COM = 0xfe,
+
+ M_TEM = 0x01,
+
+ M_ERROR = 0x100
+} JPEG_MARKER;
+
+
+/* Private state */
+
+typedef struct {
+ struct jpeg_marker_reader pub; /* public fields */
+
+ /* Application-overridable marker processing methods */
+ jpeg_marker_parser_method process_COM;
+ jpeg_marker_parser_method process_APPn[16];
+
+ /* Limit on marker data length to save for each marker type */
+ unsigned int length_limit_COM;
+ unsigned int length_limit_APPn[16];
+
+ /* Status of COM/APPn marker saving */
+ jpeg_saved_marker_ptr cur_marker; /* NULL if not processing a marker */
+ unsigned int bytes_read; /* data bytes read so far in marker */
+ /* Note: cur_marker is not linked into marker_list until it's all read. */
+} my_marker_reader;
+
+typedef my_marker_reader * my_marker_ptr;
+
+
+/*
+ * Macros for fetching data from the data source module.
+ *
+ * At all times, cinfo->src->next_input_byte and ->bytes_in_buffer reflect
+ * the current restart point; we update them only when we have reached a
+ * suitable place to restart if a suspension occurs.
+ */
+
+/* Declare and initialize local copies of input pointer/count */
+#define INPUT_VARS(cinfo) \
+ struct jpeg_source_mgr * datasrc = (cinfo)->src; \
+ const JOCTET * next_input_byte = datasrc->next_input_byte; \
+ size_t bytes_in_buffer = datasrc->bytes_in_buffer
+
+/* Unload the local copies --- do this only at a restart boundary */
+#define INPUT_SYNC(cinfo) \
+ ( datasrc->next_input_byte = next_input_byte, \
+ datasrc->bytes_in_buffer = bytes_in_buffer )
+
+/* Reload the local copies --- used only in MAKE_BYTE_AVAIL */
+#define INPUT_RELOAD(cinfo) \
+ ( next_input_byte = datasrc->next_input_byte, \
+ bytes_in_buffer = datasrc->bytes_in_buffer )
+
+/* Internal macro for INPUT_BYTE and INPUT_2BYTES: make a byte available.
+ * Note we do *not* do INPUT_SYNC before calling fill_input_buffer,
+ * but we must reload the local copies after a successful fill.
+ */
+#define MAKE_BYTE_AVAIL(cinfo,action) \
+ if (bytes_in_buffer == 0) { \
+ if (! (*datasrc->fill_input_buffer) (cinfo)) \
+ { action; } \
+ INPUT_RELOAD(cinfo); \
+ }
+
+/* Read a byte into variable V.
+ * If must suspend, take the specified action (typically "return FALSE").
+ */
+#define INPUT_BYTE(cinfo,V,action) \
+ MAKESTMT( MAKE_BYTE_AVAIL(cinfo,action); \
+ bytes_in_buffer--; \
+ V = GETJOCTET(*next_input_byte++); )
+
+/* As above, but read two bytes interpreted as an unsigned 16-bit integer.
+ * V should be declared unsigned int or perhaps INT32.
+ */
+#define INPUT_2BYTES(cinfo,V,action) \
+ MAKESTMT( MAKE_BYTE_AVAIL(cinfo,action); \
+ bytes_in_buffer--; \
+ V = ((unsigned int) GETJOCTET(*next_input_byte++)) << 8; \
+ MAKE_BYTE_AVAIL(cinfo,action); \
+ bytes_in_buffer--; \
+ V += GETJOCTET(*next_input_byte++); )
+
+
+/*
+ * Routines to process JPEG markers.
+ *
+ * Entry condition: JPEG marker itself has been read and its code saved
+ * in cinfo->unread_marker; input restart point is just after the marker.
+ *
+ * Exit: if return TRUE, have read and processed any parameters, and have
+ * updated the restart point to point after the parameters.
+ * If return FALSE, was forced to suspend before reaching end of
+ * marker parameters; restart point has not been moved. Same routine
+ * will be called again after application supplies more input data.
+ *
+ * This approach to suspension assumes that all of a marker's parameters
+ * can fit into a single input bufferload. This should hold for "normal"
+ * markers. Some COM/APPn markers might have large parameter segments
+ * that might not fit. If we are simply dropping such a marker, we use
+ * skip_input_data to get past it, and thereby put the problem on the
+ * source manager's shoulders. If we are saving the marker's contents
+ * into memory, we use a slightly different convention: when forced to
+ * suspend, the marker processor updates the restart point to the end of
+ * what it's consumed (ie, the end of the buffer) before returning FALSE.
+ * On resumption, cinfo->unread_marker still contains the marker code,
+ * but the data source will point to the next chunk of marker data.
+ * The marker processor must retain internal state to deal with this.
+ *
+ * Note that we don't bother to avoid duplicate trace messages if a
+ * suspension occurs within marker parameters. Other side effects
+ * require more care.
+ */
+
+
+LOCAL(boolean)
+get_soi (j_decompress_ptr cinfo)
+/* Process an SOI marker */
+{
+ int i;
+
+ TRACEMS(cinfo, 1, JTRC_SOI);
+
+ if (cinfo->marker->saw_SOI)
+ ERREXIT(cinfo, JERR_SOI_DUPLICATE);
+
+ /* Reset all parameters that are defined to be reset by SOI */
+
+ for (i = 0; i < NUM_ARITH_TBLS; i++) {
+ cinfo->arith_dc_L[i] = 0;
+ cinfo->arith_dc_U[i] = 1;
+ cinfo->arith_ac_K[i] = 5;
+ }
+ cinfo->restart_interval = 0;
+
+ /* Set initial assumptions for colorspace etc */
+
+ cinfo->jpeg_color_space = JCS_UNKNOWN;
+ cinfo->CCIR601_sampling = FALSE; /* Assume non-CCIR sampling??? */
+
+ cinfo->saw_JFIF_marker = FALSE;
+ cinfo->JFIF_major_version = 1; /* set default JFIF APP0 values */
+ cinfo->JFIF_minor_version = 1;
+ cinfo->density_unit = 0;
+ cinfo->X_density = 1;
+ cinfo->Y_density = 1;
+ cinfo->saw_Adobe_marker = FALSE;
+ cinfo->Adobe_transform = 0;
+
+ cinfo->marker->saw_SOI = TRUE;
+
+ return TRUE;
+}
+
+
+LOCAL(boolean)
+get_sof (j_decompress_ptr cinfo, boolean is_prog, boolean is_arith)
+/* Process a SOFn marker */
+{
+ INT32 length;
+ int c, ci;
+ jpeg_component_info * compptr;
+ INPUT_VARS(cinfo);
+
+ cinfo->progressive_mode = is_prog;
+ cinfo->arith_code = is_arith;
+
+ INPUT_2BYTES(cinfo, length, return FALSE);
+
+ INPUT_BYTE(cinfo, cinfo->data_precision, return FALSE);
+ INPUT_2BYTES(cinfo, cinfo->image_height, return FALSE);
+ INPUT_2BYTES(cinfo, cinfo->image_width, return FALSE);
+ INPUT_BYTE(cinfo, cinfo->num_components, return FALSE);
+
+ length -= 8;
+
+ TRACEMS4(cinfo, 1, JTRC_SOF, cinfo->unread_marker,
+ (int) cinfo->image_width, (int) cinfo->image_height,
+ cinfo->num_components);
+
+ if (cinfo->marker->saw_SOF)
+ ERREXIT(cinfo, JERR_SOF_DUPLICATE);
+
+ /* We don't support files in which the image height is initially specified */
+ /* as 0 and is later redefined by DNL. As long as we have to check that, */
+ /* might as well have a general sanity check. */
+ if (cinfo->image_height <= 0 || cinfo->image_width <= 0
+ || cinfo->num_components <= 0)
+ ERREXIT(cinfo, JERR_EMPTY_IMAGE);
+
+ if (length != (cinfo->num_components * 3))
+ ERREXIT(cinfo, JERR_BAD_LENGTH);
+
+ if (cinfo->comp_info == NULL) /* do only once, even if suspend */
+ cinfo->comp_info = (jpeg_component_info *) (*cinfo->mem->alloc_small)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ cinfo->num_components * SIZEOF(jpeg_component_info));
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ compptr->component_index = ci;
+ INPUT_BYTE(cinfo, compptr->component_id, return FALSE);
+ INPUT_BYTE(cinfo, c, return FALSE);
+ compptr->h_samp_factor = (c >> 4) & 15;
+ compptr->v_samp_factor = (c ) & 15;
+ INPUT_BYTE(cinfo, compptr->quant_tbl_no, return FALSE);
+
+ TRACEMS4(cinfo, 1, JTRC_SOF_COMPONENT,
+ compptr->component_id, compptr->h_samp_factor,
+ compptr->v_samp_factor, compptr->quant_tbl_no);
+ }
+
+ cinfo->marker->saw_SOF = TRUE;
+
+ INPUT_SYNC(cinfo);
+ return TRUE;
+}
+
+
+LOCAL(boolean)
+get_sos (j_decompress_ptr cinfo)
+/* Process a SOS marker */
+{
+ INT32 length;
+ int i, ci, n, c, cc;
+ jpeg_component_info * compptr;
+ INPUT_VARS(cinfo);
+
+ if (! cinfo->marker->saw_SOF)
+ ERREXIT(cinfo, JERR_SOS_NO_SOF);
+
+ INPUT_2BYTES(cinfo, length, return FALSE);
+
+ INPUT_BYTE(cinfo, n, return FALSE); /* Number of components */
+
+ TRACEMS1(cinfo, 1, JTRC_SOS, n);
+
+ if (length != (n * 2 + 6) || n < 1 || n > MAX_COMPS_IN_SCAN)
+ ERREXIT(cinfo, JERR_BAD_LENGTH);
+
+ cinfo->comps_in_scan = n;
+
+ /* Collect the component-spec parameters */
+
+ for (i = 0; i < n; i++) {
+ INPUT_BYTE(cinfo, cc, return FALSE);
+ INPUT_BYTE(cinfo, c, return FALSE);
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ if (cc == compptr->component_id)
+ goto id_found;
+ }
+
+ ERREXIT1(cinfo, JERR_BAD_COMPONENT_ID, cc);
+
+ id_found:
+
+ cinfo->cur_comp_info[i] = compptr;
+ compptr->dc_tbl_no = (c >> 4) & 15;
+ compptr->ac_tbl_no = (c ) & 15;
+
+ TRACEMS3(cinfo, 1, JTRC_SOS_COMPONENT, cc,
+ compptr->dc_tbl_no, compptr->ac_tbl_no);
+ }
+
+ /* Collect the additional scan parameters Ss, Se, Ah/Al. */
+ INPUT_BYTE(cinfo, c, return FALSE);
+ cinfo->Ss = c;
+ INPUT_BYTE(cinfo, c, return FALSE);
+ cinfo->Se = c;
+ INPUT_BYTE(cinfo, c, return FALSE);
+ cinfo->Ah = (c >> 4) & 15;
+ cinfo->Al = (c ) & 15;
+
+ TRACEMS4(cinfo, 1, JTRC_SOS_PARAMS, cinfo->Ss, cinfo->Se,
+ cinfo->Ah, cinfo->Al);
+
+ /* Prepare to scan data & restart markers */
+ cinfo->marker->next_restart_num = 0;
+
+ /* Count another SOS marker */
+ cinfo->input_scan_number++;
+
+ INPUT_SYNC(cinfo);
+ return TRUE;
+}
+
+
+#ifdef D_ARITH_CODING_SUPPORTED
+
+LOCAL(boolean)
+get_dac (j_decompress_ptr cinfo)
+/* Process a DAC marker */
+{
+ INT32 length;
+ int index, val;
+ INPUT_VARS(cinfo);
+
+ INPUT_2BYTES(cinfo, length, return FALSE);
+ length -= 2;
+
+ while (length > 0) {
+ INPUT_BYTE(cinfo, index, return FALSE);
+ INPUT_BYTE(cinfo, val, return FALSE);
+
+ length -= 2;
+
+ TRACEMS2(cinfo, 1, JTRC_DAC, index, val);
+
+ if (index < 0 || index >= (2*NUM_ARITH_TBLS))
+ ERREXIT1(cinfo, JERR_DAC_INDEX, index);
+
+ if (index >= NUM_ARITH_TBLS) { /* define AC table */
+ cinfo->arith_ac_K[index-NUM_ARITH_TBLS] = (UINT8) val;
+ } else { /* define DC table */
+ cinfo->arith_dc_L[index] = (UINT8) (val & 0x0F);
+ cinfo->arith_dc_U[index] = (UINT8) (val >> 4);
+ if (cinfo->arith_dc_L[index] > cinfo->arith_dc_U[index])
+ ERREXIT1(cinfo, JERR_DAC_VALUE, val);
+ }
+ }
+
+ if (length != 0)
+ ERREXIT(cinfo, JERR_BAD_LENGTH);
+
+ INPUT_SYNC(cinfo);
+ return TRUE;
+}
+
+#else /* ! D_ARITH_CODING_SUPPORTED */
+
+#define get_dac(cinfo) skip_variable(cinfo)
+
+#endif /* D_ARITH_CODING_SUPPORTED */
+
+
+LOCAL(boolean)
+get_dht (j_decompress_ptr cinfo)
+/* Process a DHT marker */
+{
+ INT32 length;
+ UINT8 bits[17];
+ UINT8 huffval[256];
+ int i, index, count;
+ JHUFF_TBL **htblptr;
+ INPUT_VARS(cinfo);
+
+ INPUT_2BYTES(cinfo, length, return FALSE);
+ length -= 2;
+
+ while (length > 16) {
+ INPUT_BYTE(cinfo, index, return FALSE);
+
+ TRACEMS1(cinfo, 1, JTRC_DHT, index);
+
+ bits[0] = 0;
+ count = 0;
+ for (i = 1; i <= 16; i++) {
+ INPUT_BYTE(cinfo, bits[i], return FALSE);
+ count += bits[i];
+ }
+
+ length -= 1 + 16;
+
+ TRACEMS8(cinfo, 2, JTRC_HUFFBITS,
+ bits[1], bits[2], bits[3], bits[4],
+ bits[5], bits[6], bits[7], bits[8]);
+ TRACEMS8(cinfo, 2, JTRC_HUFFBITS,
+ bits[9], bits[10], bits[11], bits[12],
+ bits[13], bits[14], bits[15], bits[16]);
+
+ /* Here we just do minimal validation of the counts to avoid walking
+ * off the end of our table space. jdhuff.c will check more carefully.
+ */
+ if (count > 256 || ((INT32) count) > length)
+ ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+
+ for (i = 0; i < count; i++)
+ INPUT_BYTE(cinfo, huffval[i], return FALSE);
+
+ length -= count;
+
+ if (index & 0x10) { /* AC table definition */
+ index -= 0x10;
+ htblptr = &cinfo->ac_huff_tbl_ptrs[index];
+ } else { /* DC table definition */
+ htblptr = &cinfo->dc_huff_tbl_ptrs[index];
+ }
+
+ if (index < 0 || index >= NUM_HUFF_TBLS)
+ ERREXIT1(cinfo, JERR_DHT_INDEX, index);
+
+ if (*htblptr == NULL)
+ *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
+
+ MEMCOPY((*htblptr)->bits, bits, SIZEOF((*htblptr)->bits));
+ MEMCOPY((*htblptr)->huffval, huffval, SIZEOF((*htblptr)->huffval));
+ }
+
+ if (length != 0)
+ ERREXIT(cinfo, JERR_BAD_LENGTH);
+
+ INPUT_SYNC(cinfo);
+ return TRUE;
+}
+
+
+LOCAL(boolean)
+get_dqt (j_decompress_ptr cinfo)
+/* Process a DQT marker */
+{
+ INT32 length;
+ int n, i, prec;
+ unsigned int tmp;
+ JQUANT_TBL *quant_ptr;
+ INPUT_VARS(cinfo);
+
+ INPUT_2BYTES(cinfo, length, return FALSE);
+ length -= 2;
+
+ while (length > 0) {
+ INPUT_BYTE(cinfo, n, return FALSE);
+ prec = n >> 4;
+ n &= 0x0F;
+
+ TRACEMS2(cinfo, 1, JTRC_DQT, n, prec);
+
+ if (n >= NUM_QUANT_TBLS)
+ ERREXIT1(cinfo, JERR_DQT_INDEX, n);
+
+ if (cinfo->quant_tbl_ptrs[n] == NULL)
+ cinfo->quant_tbl_ptrs[n] = jpeg_alloc_quant_table((j_common_ptr) cinfo);
+ quant_ptr = cinfo->quant_tbl_ptrs[n];
+
+ for (i = 0; i < DCTSIZE2; i++) {
+ if (prec)
+ INPUT_2BYTES(cinfo, tmp, return FALSE);
+ else
+ INPUT_BYTE(cinfo, tmp, return FALSE);
+ /* We convert the zigzag-order table to natural array order. */
+ quant_ptr->quantval[jpeg_natural_order[i]] = (UINT16) tmp;
+ }
+
+ if (cinfo->err->trace_level >= 2) {
+ for (i = 0; i < DCTSIZE2; i += 8) {
+ TRACEMS8(cinfo, 2, JTRC_QUANTVALS,
+ quant_ptr->quantval[i], quant_ptr->quantval[i+1],
+ quant_ptr->quantval[i+2], quant_ptr->quantval[i+3],
+ quant_ptr->quantval[i+4], quant_ptr->quantval[i+5],
+ quant_ptr->quantval[i+6], quant_ptr->quantval[i+7]);
+ }
+ }
+
+ length -= DCTSIZE2+1;
+ if (prec) length -= DCTSIZE2;
+ }
+
+ if (length != 0)
+ ERREXIT(cinfo, JERR_BAD_LENGTH);
+
+ INPUT_SYNC(cinfo);
+ return TRUE;
+}
+
+
+LOCAL(boolean)
+get_dri (j_decompress_ptr cinfo)
+/* Process a DRI marker */
+{
+ INT32 length;
+ unsigned int tmp;
+ INPUT_VARS(cinfo);
+
+ INPUT_2BYTES(cinfo, length, return FALSE);
+
+ if (length != 4)
+ ERREXIT(cinfo, JERR_BAD_LENGTH);
+
+ INPUT_2BYTES(cinfo, tmp, return FALSE);
+
+ TRACEMS1(cinfo, 1, JTRC_DRI, tmp);
+
+ cinfo->restart_interval = tmp;
+
+ INPUT_SYNC(cinfo);
+ return TRUE;
+}
+
+
+/*
+ * Routines for processing APPn and COM markers.
+ * These are either saved in memory or discarded, per application request.
+ * APP0 and APP14 are specially checked to see if they are
+ * JFIF and Adobe markers, respectively.
+ */
+
+#define APP0_DATA_LEN 14 /* Length of interesting data in APP0 */
+#define APP14_DATA_LEN 12 /* Length of interesting data in APP14 */
+#define APPN_DATA_LEN 14 /* Must be the largest of the above!! */
+
+
+LOCAL(void)
+examine_app0 (j_decompress_ptr cinfo, JOCTET FAR * data,
+ unsigned int datalen, INT32 remaining)
+/* Examine first few bytes from an APP0.
+ * Take appropriate action if it is a JFIF marker.
+ * datalen is # of bytes at data[], remaining is length of rest of marker data.
+ */
+{
+ INT32 totallen = (INT32) datalen + remaining;
+
+ if (datalen >= APP0_DATA_LEN &&
+ GETJOCTET(data[0]) == 0x4A &&
+ GETJOCTET(data[1]) == 0x46 &&
+ GETJOCTET(data[2]) == 0x49 &&
+ GETJOCTET(data[3]) == 0x46 &&
+ GETJOCTET(data[4]) == 0) {
+ /* Found JFIF APP0 marker: save info */
+ cinfo->saw_JFIF_marker = TRUE;
+ cinfo->JFIF_major_version = GETJOCTET(data[5]);
+ cinfo->JFIF_minor_version = GETJOCTET(data[6]);
+ cinfo->density_unit = GETJOCTET(data[7]);
+ cinfo->X_density = (GETJOCTET(data[8]) << 8) + GETJOCTET(data[9]);
+ cinfo->Y_density = (GETJOCTET(data[10]) << 8) + GETJOCTET(data[11]);
+ /* Check version.
+ * Major version must be 1, anything else signals an incompatible change.
+ * (We used to treat this as an error, but now it's a nonfatal warning,
+ * because some bozo at Hijaak couldn't read the spec.)
+ * Minor version should be 0..2, but process anyway if newer.
+ */
+ if (cinfo->JFIF_major_version != 1)
+ WARNMS2(cinfo, JWRN_JFIF_MAJOR,
+ cinfo->JFIF_major_version, cinfo->JFIF_minor_version);
+ /* Generate trace messages */
+ TRACEMS5(cinfo, 1, JTRC_JFIF,
+ cinfo->JFIF_major_version, cinfo->JFIF_minor_version,
+ cinfo->X_density, cinfo->Y_density, cinfo->density_unit);
+ /* Validate thumbnail dimensions and issue appropriate messages */
+ if (GETJOCTET(data[12]) | GETJOCTET(data[13]))
+ TRACEMS2(cinfo, 1, JTRC_JFIF_THUMBNAIL,
+ GETJOCTET(data[12]), GETJOCTET(data[13]));
+ totallen -= APP0_DATA_LEN;
+ if (totallen !=
+ ((INT32)GETJOCTET(data[12]) * (INT32)GETJOCTET(data[13]) * (INT32) 3))
+ TRACEMS1(cinfo, 1, JTRC_JFIF_BADTHUMBNAILSIZE, (int) totallen);
+ } else if (datalen >= 6 &&
+ GETJOCTET(data[0]) == 0x4A &&
+ GETJOCTET(data[1]) == 0x46 &&
+ GETJOCTET(data[2]) == 0x58 &&
+ GETJOCTET(data[3]) == 0x58 &&
+ GETJOCTET(data[4]) == 0) {
+ /* Found JFIF "JFXX" extension APP0 marker */
+ /* The library doesn't actually do anything with these,
+ * but we try to produce a helpful trace message.
+ */
+ switch (GETJOCTET(data[5])) {
+ case 0x10:
+ TRACEMS1(cinfo, 1, JTRC_THUMB_JPEG, (int) totallen);
+ break;
+ case 0x11:
+ TRACEMS1(cinfo, 1, JTRC_THUMB_PALETTE, (int) totallen);
+ break;
+ case 0x13:
+ TRACEMS1(cinfo, 1, JTRC_THUMB_RGB, (int) totallen);
+ break;
+ default:
+ TRACEMS2(cinfo, 1, JTRC_JFIF_EXTENSION,
+ GETJOCTET(data[5]), (int) totallen);
+ break;
+ }
+ } else {
+ /* Start of APP0 does not match "JFIF" or "JFXX", or too short */
+ TRACEMS1(cinfo, 1, JTRC_APP0, (int) totallen);
+ }
+}
+
+
+LOCAL(void)
+examine_app14 (j_decompress_ptr cinfo, JOCTET FAR * data,
+ unsigned int datalen, INT32 remaining)
+/* Examine first few bytes from an APP14.
+ * Take appropriate action if it is an Adobe marker.
+ * datalen is # of bytes at data[], remaining is length of rest of marker data.
+ */
+{
+ unsigned int version, flags0, flags1, transform;
+
+ if (datalen >= APP14_DATA_LEN &&
+ GETJOCTET(data[0]) == 0x41 &&
+ GETJOCTET(data[1]) == 0x64 &&
+ GETJOCTET(data[2]) == 0x6F &&
+ GETJOCTET(data[3]) == 0x62 &&
+ GETJOCTET(data[4]) == 0x65) {
+ /* Found Adobe APP14 marker */
+ version = (GETJOCTET(data[5]) << 8) + GETJOCTET(data[6]);
+ flags0 = (GETJOCTET(data[7]) << 8) + GETJOCTET(data[8]);
+ flags1 = (GETJOCTET(data[9]) << 8) + GETJOCTET(data[10]);
+ transform = GETJOCTET(data[11]);
+ TRACEMS4(cinfo, 1, JTRC_ADOBE, version, flags0, flags1, transform);
+ cinfo->saw_Adobe_marker = TRUE;
+ cinfo->Adobe_transform = (UINT8) transform;
+ } else {
+ /* Start of APP14 does not match "Adobe", or too short */
+ TRACEMS1(cinfo, 1, JTRC_APP14, (int) (datalen + remaining));
+ }
+}
+
+
+METHODDEF(boolean)
+get_interesting_appn (j_decompress_ptr cinfo)
+/* Process an APP0 or APP14 marker without saving it */
+{
+ INT32 length;
+ JOCTET b[APPN_DATA_LEN];
+ unsigned int i, numtoread;
+ INPUT_VARS(cinfo);
+
+ INPUT_2BYTES(cinfo, length, return FALSE);
+ length -= 2;
+
+ /* get the interesting part of the marker data */
+ if (length >= APPN_DATA_LEN)
+ numtoread = APPN_DATA_LEN;
+ else if (length > 0)
+ numtoread = (unsigned int) length;
+ else
+ numtoread = 0;
+ for (i = 0; i < numtoread; i++)
+ INPUT_BYTE(cinfo, b[i], return FALSE);
+ length -= numtoread;
+
+ /* process it */
+ switch (cinfo->unread_marker) {
+ case M_APP0:
+ examine_app0(cinfo, (JOCTET FAR *) b, numtoread, length);
+ break;
+ case M_APP14:
+ examine_app14(cinfo, (JOCTET FAR *) b, numtoread, length);
+ break;
+ default:
+ /* can't get here unless jpeg_save_markers chooses wrong processor */
+ ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, cinfo->unread_marker);
+ break;
+ }
+
+ /* skip any remaining data -- could be lots */
+ INPUT_SYNC(cinfo);
+ if (length > 0)
+ (*cinfo->src->skip_input_data) (cinfo, (long) length);
+
+ return TRUE;
+}
+
+
+#ifdef SAVE_MARKERS_SUPPORTED
+
+METHODDEF(boolean)
+save_marker (j_decompress_ptr cinfo)
+/* Save an APPn or COM marker into the marker list */
+{
+ my_marker_ptr marker = (my_marker_ptr) cinfo->marker;
+ jpeg_saved_marker_ptr cur_marker = marker->cur_marker;
+ unsigned int bytes_read, data_length;
+ JOCTET FAR * data;
+ INT32 length = 0;
+ INPUT_VARS(cinfo);
+
+ if (cur_marker == NULL) {
+ /* begin reading a marker */
+ INPUT_2BYTES(cinfo, length, return FALSE);
+ length -= 2;
+ if (length >= 0) { /* watch out for bogus length word */
+ /* figure out how much we want to save */
+ unsigned int limit;
+ if (cinfo->unread_marker == (int) M_COM)
+ limit = marker->length_limit_COM;
+ else
+ limit = marker->length_limit_APPn[cinfo->unread_marker - (int) M_APP0];
+ if ((unsigned int) length < limit)
+ limit = (unsigned int) length;
+ /* allocate and initialize the marker item */
+ cur_marker = (jpeg_saved_marker_ptr)
+ (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(struct jpeg_marker_struct) + limit);
+ cur_marker->next = NULL;
+ cur_marker->marker = (UINT8) cinfo->unread_marker;
+ cur_marker->original_length = (unsigned int) length;
+ cur_marker->data_length = limit;
+ /* data area is just beyond the jpeg_marker_struct */
+ data = cur_marker->data = (JOCTET FAR *) (cur_marker + 1);
+ marker->cur_marker = cur_marker;
+ marker->bytes_read = 0;
+ bytes_read = 0;
+ data_length = limit;
+ } else {
+ /* deal with bogus length word */
+ bytes_read = data_length = 0;
+ data = NULL;
+ }
+ } else {
+ /* resume reading a marker */
+ bytes_read = marker->bytes_read;
+ data_length = cur_marker->data_length;
+ data = cur_marker->data + bytes_read;
+ }
+
+ while (bytes_read < data_length) {
+ INPUT_SYNC(cinfo); /* move the restart point to here */
+ marker->bytes_read = bytes_read;
+ /* If there's not at least one byte in buffer, suspend */
+ MAKE_BYTE_AVAIL(cinfo, return FALSE);
+ /* Copy bytes with reasonable rapidity */
+ while (bytes_read < data_length && bytes_in_buffer > 0) {
+ *data++ = *next_input_byte++;
+ bytes_in_buffer--;
+ bytes_read++;
+ }
+ }
+
+ /* Done reading what we want to read */
+ if (cur_marker != NULL) { /* will be NULL if bogus length word */
+ /* Add new marker to end of list */
+ if (cinfo->marker_list == NULL) {
+ cinfo->marker_list = cur_marker;
+ } else {
+ jpeg_saved_marker_ptr prev = cinfo->marker_list;
+ while (prev->next != NULL)
+ prev = prev->next;
+ prev->next = cur_marker;
+ }
+ /* Reset pointer & calc remaining data length */
+ data = cur_marker->data;
+ length = cur_marker->original_length - data_length;
+ }
+ /* Reset to initial state for next marker */
+ marker->cur_marker = NULL;
+
+ /* Process the marker if interesting; else just make a generic trace msg */
+ switch (cinfo->unread_marker) {
+ case M_APP0:
+ examine_app0(cinfo, data, data_length, length);
+ break;
+ case M_APP14:
+ examine_app14(cinfo, data, data_length, length);
+ break;
+ default:
+ TRACEMS2(cinfo, 1, JTRC_MISC_MARKER, cinfo->unread_marker,
+ (int) (data_length + length));
+ break;
+ }
+
+ /* skip any remaining data -- could be lots */
+ INPUT_SYNC(cinfo); /* do before skip_input_data */
+ if (length > 0)
+ (*cinfo->src->skip_input_data) (cinfo, (long) length);
+
+ return TRUE;
+}
+
+#endif /* SAVE_MARKERS_SUPPORTED */
+
+
+METHODDEF(boolean)
+skip_variable (j_decompress_ptr cinfo)
+/* Skip over an unknown or uninteresting variable-length marker */
+{
+ INT32 length;
+ INPUT_VARS(cinfo);
+
+ INPUT_2BYTES(cinfo, length, return FALSE);
+ length -= 2;
+
+ TRACEMS2(cinfo, 1, JTRC_MISC_MARKER, cinfo->unread_marker, (int) length);
+
+ INPUT_SYNC(cinfo); /* do before skip_input_data */
+ if (length > 0)
+ (*cinfo->src->skip_input_data) (cinfo, (long) length);
+
+ return TRUE;
+}
+
+
+/*
+ * Find the next JPEG marker, save it in cinfo->unread_marker.
+ * Returns FALSE if had to suspend before reaching a marker;
+ * in that case cinfo->unread_marker is unchanged.
+ *
+ * Note that the result might not be a valid marker code,
+ * but it will never be 0 or FF.
+ */
+
+LOCAL(boolean)
+next_marker (j_decompress_ptr cinfo)
+{
+ int c;
+ INPUT_VARS(cinfo);
+
+ for (;;) {
+ INPUT_BYTE(cinfo, c, return FALSE);
+ /* Skip any non-FF bytes.
+ * This may look a bit inefficient, but it will not occur in a valid file.
+ * We sync after each discarded byte so that a suspending data source
+ * can discard the byte from its buffer.
+ */
+ while (c != 0xFF) {
+ cinfo->marker->discarded_bytes++;
+ INPUT_SYNC(cinfo);
+ INPUT_BYTE(cinfo, c, return FALSE);
+ }
+ /* This loop swallows any duplicate FF bytes. Extra FFs are legal as
+ * pad bytes, so don't count them in discarded_bytes. We assume there
+ * will not be so many consecutive FF bytes as to overflow a suspending
+ * data source's input buffer.
+ */
+ do {
+ INPUT_BYTE(cinfo, c, return FALSE);
+ } while (c == 0xFF);
+ if (c != 0)
+ break; /* found a valid marker, exit loop */
+ /* Reach here if we found a stuffed-zero data sequence (FF/00).
+ * Discard it and loop back to try again.
+ */
+ cinfo->marker->discarded_bytes += 2;
+ INPUT_SYNC(cinfo);
+ }
+
+ if (cinfo->marker->discarded_bytes != 0) {
+ WARNMS2(cinfo, JWRN_EXTRANEOUS_DATA, cinfo->marker->discarded_bytes, c);
+ cinfo->marker->discarded_bytes = 0;
+ }
+
+ cinfo->unread_marker = c;
+
+ INPUT_SYNC(cinfo);
+ return TRUE;
+}
+
+
+LOCAL(boolean)
+first_marker (j_decompress_ptr cinfo)
+/* Like next_marker, but used to obtain the initial SOI marker. */
+/* For this marker, we do not allow preceding garbage or fill; otherwise,
+ * we might well scan an entire input file before realizing it ain't JPEG.
+ * If an application wants to process non-JFIF files, it must seek to the
+ * SOI before calling the JPEG library.
+ */
+{
+ int c, c2;
+ INPUT_VARS(cinfo);
+
+ INPUT_BYTE(cinfo, c, return FALSE);
+ INPUT_BYTE(cinfo, c2, return FALSE);
+ if (c != 0xFF || c2 != (int) M_SOI)
+ ERREXIT2(cinfo, JERR_NO_SOI, c, c2);
+
+ cinfo->unread_marker = c2;
+
+ INPUT_SYNC(cinfo);
+ return TRUE;
+}
+
+
+/*
+ * Read markers until SOS or EOI.
+ *
+ * Returns same codes as are defined for jpeg_consume_input:
+ * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
+ */
+
+METHODDEF(int)
+read_markers (j_decompress_ptr cinfo)
+{
+ /* Outer loop repeats once for each marker. */
+ for (;;) {
+ /* Collect the marker proper, unless we already did. */
+ /* NB: first_marker() enforces the requirement that SOI appear first. */
+ if (cinfo->unread_marker == 0) {
+ if (! cinfo->marker->saw_SOI) {
+ if (! first_marker(cinfo))
+ return JPEG_SUSPENDED;
+ } else {
+ if (! next_marker(cinfo))
+ return JPEG_SUSPENDED;
+ }
+ }
+ /* At this point cinfo->unread_marker contains the marker code and the
+ * input point is just past the marker proper, but before any parameters.
+ * A suspension will cause us to return with this state still true.
+ */
+ switch (cinfo->unread_marker) {
+ case M_SOI:
+ if (! get_soi(cinfo))
+ return JPEG_SUSPENDED;
+ break;
+
+ case M_SOF0: /* Baseline */
+ case M_SOF1: /* Extended sequential, Huffman */
+ if (! get_sof(cinfo, FALSE, FALSE))
+ return JPEG_SUSPENDED;
+ break;
+
+ case M_SOF2: /* Progressive, Huffman */
+ if (! get_sof(cinfo, TRUE, FALSE))
+ return JPEG_SUSPENDED;
+ break;
+
+ case M_SOF9: /* Extended sequential, arithmetic */
+ if (! get_sof(cinfo, FALSE, TRUE))
+ return JPEG_SUSPENDED;
+ break;
+
+ case M_SOF10: /* Progressive, arithmetic */
+ if (! get_sof(cinfo, TRUE, TRUE))
+ return JPEG_SUSPENDED;
+ break;
+
+ /* Currently unsupported SOFn types */
+ case M_SOF3: /* Lossless, Huffman */
+ case M_SOF5: /* Differential sequential, Huffman */
+ case M_SOF6: /* Differential progressive, Huffman */
+ case M_SOF7: /* Differential lossless, Huffman */
+ case M_JPG: /* Reserved for JPEG extensions */
+ case M_SOF11: /* Lossless, arithmetic */
+ case M_SOF13: /* Differential sequential, arithmetic */
+ case M_SOF14: /* Differential progressive, arithmetic */
+ case M_SOF15: /* Differential lossless, arithmetic */
+ ERREXIT1(cinfo, JERR_SOF_UNSUPPORTED, cinfo->unread_marker);
+ break;
+
+ case M_SOS:
+ if (! get_sos(cinfo))
+ return JPEG_SUSPENDED;
+ cinfo->unread_marker = 0; /* processed the marker */
+ return JPEG_REACHED_SOS;
+
+ case M_EOI:
+ TRACEMS(cinfo, 1, JTRC_EOI);
+ cinfo->unread_marker = 0; /* processed the marker */
+ return JPEG_REACHED_EOI;
+
+ case M_DAC:
+ if (! get_dac(cinfo))
+ return JPEG_SUSPENDED;
+ break;
+
+ case M_DHT:
+ if (! get_dht(cinfo))
+ return JPEG_SUSPENDED;
+ break;
+
+ case M_DQT:
+ if (! get_dqt(cinfo))
+ return JPEG_SUSPENDED;
+ break;
+
+ case M_DRI:
+ if (! get_dri(cinfo))
+ return JPEG_SUSPENDED;
+ break;
+
+ case M_APP0:
+ case M_APP1:
+ case M_APP2:
+ case M_APP3:
+ case M_APP4:
+ case M_APP5:
+ case M_APP6:
+ case M_APP7:
+ case M_APP8:
+ case M_APP9:
+ case M_APP10:
+ case M_APP11:
+ case M_APP12:
+ case M_APP13:
+ case M_APP14:
+ case M_APP15:
+ if (! (*((my_marker_ptr) cinfo->marker)->process_APPn[
+ cinfo->unread_marker - (int) M_APP0]) (cinfo))
+ return JPEG_SUSPENDED;
+ break;
+
+ case M_COM:
+ if (! (*((my_marker_ptr) cinfo->marker)->process_COM) (cinfo))
+ return JPEG_SUSPENDED;
+ break;
+
+ case M_RST0: /* these are all parameterless */
+ case M_RST1:
+ case M_RST2:
+ case M_RST3:
+ case M_RST4:
+ case M_RST5:
+ case M_RST6:
+ case M_RST7:
+ case M_TEM:
+ TRACEMS1(cinfo, 1, JTRC_PARMLESS_MARKER, cinfo->unread_marker);
+ break;
+
+ case M_DNL: /* Ignore DNL ... perhaps the wrong thing */
+ if (! skip_variable(cinfo))
+ return JPEG_SUSPENDED;
+ break;
+
+ default: /* must be DHP, EXP, JPGn, or RESn */
+ /* For now, we treat the reserved markers as fatal errors since they are
+ * likely to be used to signal incompatible JPEG Part 3 extensions.
+ * Once the JPEG 3 version-number marker is well defined, this code
+ * ought to change!
+ */
+ ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, cinfo->unread_marker);
+ break;
+ }
+ /* Successfully processed marker, so reset state variable */
+ cinfo->unread_marker = 0;
+ } /* end loop */
+}
+
+
+/*
+ * Read a restart marker, which is expected to appear next in the datastream;
+ * if the marker is not there, take appropriate recovery action.
+ * Returns FALSE if suspension is required.
+ *
+ * This is called by the entropy decoder after it has read an appropriate
+ * number of MCUs. cinfo->unread_marker may be nonzero if the entropy decoder
+ * has already read a marker from the data source. Under normal conditions
+ * cinfo->unread_marker will be reset to 0 before returning; if not reset,
+ * it holds a marker which the decoder will be unable to read past.
+ */
+
+METHODDEF(boolean)
+read_restart_marker (j_decompress_ptr cinfo)
+{
+ /* Obtain a marker unless we already did. */
+ /* Note that next_marker will complain if it skips any data. */
+ if (cinfo->unread_marker == 0) {
+ if (! next_marker(cinfo))
+ return FALSE;
+ }
+
+ if (cinfo->unread_marker ==
+ ((int) M_RST0 + cinfo->marker->next_restart_num)) {
+ /* Normal case --- swallow the marker and let entropy decoder continue */
+ TRACEMS1(cinfo, 3, JTRC_RST, cinfo->marker->next_restart_num);
+ cinfo->unread_marker = 0;
+ } else {
+ /* Uh-oh, the restart markers have been messed up. */
+ /* Let the data source manager determine how to resync. */
+ if (! (*cinfo->src->resync_to_restart) (cinfo,
+ cinfo->marker->next_restart_num))
+ return FALSE;
+ }
+
+ /* Update next-restart state */
+ cinfo->marker->next_restart_num = (cinfo->marker->next_restart_num + 1) & 7;
+
+ return TRUE;
+}
+
+
+/*
+ * This is the default resync_to_restart method for data source managers
+ * to use if they don't have any better approach. Some data source managers
+ * may be able to back up, or may have additional knowledge about the data
+ * which permits a more intelligent recovery strategy; such managers would
+ * presumably supply their own resync method.
+ *
+ * read_restart_marker calls resync_to_restart if it finds a marker other than
+ * the restart marker it was expecting. (This code is *not* used unless
+ * a nonzero restart interval has been declared.) cinfo->unread_marker is
+ * the marker code actually found (might be anything, except 0 or FF).
+ * The desired restart marker number (0..7) is passed as a parameter.
+ * This routine is supposed to apply whatever error recovery strategy seems
+ * appropriate in order to position the input stream to the next data segment.
+ * Note that cinfo->unread_marker is treated as a marker appearing before
+ * the current data-source input point; usually it should be reset to zero
+ * before returning.
+ * Returns FALSE if suspension is required.
+ *
+ * This implementation is substantially constrained by wanting to treat the
+ * input as a data stream; this means we can't back up. Therefore, we have
+ * only the following actions to work with:
+ * 1. Simply discard the marker and let the entropy decoder resume at next
+ * byte of file.
+ * 2. Read forward until we find another marker, discarding intervening
+ * data. (In theory we could look ahead within the current bufferload,
+ * without having to discard data if we don't find the desired marker.
+ * This idea is not implemented here, in part because it makes behavior
+ * dependent on buffer size and chance buffer-boundary positions.)
+ * 3. Leave the marker unread (by failing to zero cinfo->unread_marker).
+ * This will cause the entropy decoder to process an empty data segment,
+ * inserting dummy zeroes, and then we will reprocess the marker.
+ *
+ * #2 is appropriate if we think the desired marker lies ahead, while #3 is
+ * appropriate if the found marker is a future restart marker (indicating
+ * that we have missed the desired restart marker, probably because it got
+ * corrupted).
+ * We apply #2 or #3 if the found marker is a restart marker no more than
+ * two counts behind or ahead of the expected one. We also apply #2 if the
+ * found marker is not a legal JPEG marker code (it's certainly bogus data).
+ * If the found marker is a restart marker more than 2 counts away, we do #1
+ * (too much risk that the marker is erroneous; with luck we will be able to
+ * resync at some future point).
+ * For any valid non-restart JPEG marker, we apply #3. This keeps us from
+ * overrunning the end of a scan. An implementation limited to single-scan
+ * files might find it better to apply #2 for markers other than EOI, since
+ * any other marker would have to be bogus data in that case.
+ */
+
+GLOBAL(boolean)
+jpeg_resync_to_restart (j_decompress_ptr cinfo, int desired)
+{
+ int marker = cinfo->unread_marker;
+ int action = 1;
+
+ /* Always put up a warning. */
+ WARNMS2(cinfo, JWRN_MUST_RESYNC, marker, desired);
+
+ /* Outer loop handles repeated decision after scanning forward. */
+ for (;;) {
+ if (marker < (int) M_SOF0)
+ action = 2; /* invalid marker */
+ else if (marker < (int) M_RST0 || marker > (int) M_RST7)
+ action = 3; /* valid non-restart marker */
+ else {
+ if (marker == ((int) M_RST0 + ((desired+1) & 7)) ||
+ marker == ((int) M_RST0 + ((desired+2) & 7)))
+ action = 3; /* one of the next two expected restarts */
+ else if (marker == ((int) M_RST0 + ((desired-1) & 7)) ||
+ marker == ((int) M_RST0 + ((desired-2) & 7)))
+ action = 2; /* a prior restart, so advance */
+ else
+ action = 1; /* desired restart or too far away */
+ }
+ TRACEMS2(cinfo, 4, JTRC_RECOVERY_ACTION, marker, action);
+ switch (action) {
+ case 1:
+ /* Discard marker and let entropy decoder resume processing. */
+ cinfo->unread_marker = 0;
+ return TRUE;
+ case 2:
+ /* Scan to the next marker, and repeat the decision loop. */
+ if (! next_marker(cinfo))
+ return FALSE;
+ marker = cinfo->unread_marker;
+ break;
+ case 3:
+ /* Return without advancing past this marker. */
+ /* Entropy decoder will be forced to process an empty segment. */
+ return TRUE;
+ }
+ } /* end loop */
+}
+
+
+/*
+ * Reset marker processing state to begin a fresh datastream.
+ */
+
+METHODDEF(void)
+reset_marker_reader (j_decompress_ptr cinfo)
+{
+ my_marker_ptr marker = (my_marker_ptr) cinfo->marker;
+
+ cinfo->comp_info = NULL; /* until allocated by get_sof */
+ cinfo->input_scan_number = 0; /* no SOS seen yet */
+ cinfo->unread_marker = 0; /* no pending marker */
+ marker->pub.saw_SOI = FALSE; /* set internal state too */
+ marker->pub.saw_SOF = FALSE;
+ marker->pub.discarded_bytes = 0;
+ marker->cur_marker = NULL;
+}
+
+
+/*
+ * Initialize the marker reader module.
+ * This is called only once, when the decompression object is created.
+ */
+
+GLOBAL(void)
+jinit_marker_reader (j_decompress_ptr cinfo)
+{
+ my_marker_ptr marker;
+ int i;
+
+ /* Create subobject in permanent pool */
+ marker = (my_marker_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+ SIZEOF(my_marker_reader));
+ cinfo->marker = (struct jpeg_marker_reader *) marker;
+ /* Initialize public method pointers */
+ marker->pub.reset_marker_reader = reset_marker_reader;
+ marker->pub.read_markers = read_markers;
+ marker->pub.read_restart_marker = read_restart_marker;
+ /* Initialize COM/APPn processing.
+ * By default, we examine and then discard APP0 and APP14,
+ * but simply discard COM and all other APPn.
+ */
+ marker->process_COM = skip_variable;
+ marker->length_limit_COM = 0;
+ for (i = 0; i < 16; i++) {
+ marker->process_APPn[i] = skip_variable;
+ marker->length_limit_APPn[i] = 0;
+ }
+ marker->process_APPn[0] = get_interesting_appn;
+ marker->process_APPn[14] = get_interesting_appn;
+ /* Reset marker processing state */
+ reset_marker_reader(cinfo);
+}
+
+
+/*
+ * Control saving of COM and APPn markers into marker_list.
+ */
+
+#ifdef SAVE_MARKERS_SUPPORTED
+
+GLOBAL(void)
+jpeg_save_markers (j_decompress_ptr cinfo, int marker_code,
+ unsigned int length_limit)
+{
+ my_marker_ptr marker = (my_marker_ptr) cinfo->marker;
+ long maxlength;
+ jpeg_marker_parser_method processor;
+
+ /* Length limit mustn't be larger than what we can allocate
+ * (should only be a concern in a 16-bit environment).
+ */
+ maxlength = cinfo->mem->max_alloc_chunk - SIZEOF(struct jpeg_marker_struct);
+ if (((long) length_limit) > maxlength)
+ length_limit = (unsigned int) maxlength;
+
+ /* Choose processor routine to use.
+ * APP0/APP14 have special requirements.
+ */
+ if (length_limit) {
+ processor = save_marker;
+ /* If saving APP0/APP14, save at least enough for our internal use. */
+ if (marker_code == (int) M_APP0 && length_limit < APP0_DATA_LEN)
+ length_limit = APP0_DATA_LEN;
+ else if (marker_code == (int) M_APP14 && length_limit < APP14_DATA_LEN)
+ length_limit = APP14_DATA_LEN;
+ } else {
+ processor = skip_variable;
+ /* If discarding APP0/APP14, use our regular on-the-fly processor. */
+ if (marker_code == (int) M_APP0 || marker_code == (int) M_APP14)
+ processor = get_interesting_appn;
+ }
+
+ if (marker_code == (int) M_COM) {
+ marker->process_COM = processor;
+ marker->length_limit_COM = length_limit;
+ } else if (marker_code >= (int) M_APP0 && marker_code <= (int) M_APP15) {
+ marker->process_APPn[marker_code - (int) M_APP0] = processor;
+ marker->length_limit_APPn[marker_code - (int) M_APP0] = length_limit;
+ } else
+ ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, marker_code);
+}
+
+#endif /* SAVE_MARKERS_SUPPORTED */
+
+
+/*
+ * Install a special processing method for COM or APPn markers.
+ */
+
+GLOBAL(void)
+jpeg_set_marker_processor (j_decompress_ptr cinfo, int marker_code,
+ jpeg_marker_parser_method routine)
+{
+ my_marker_ptr marker = (my_marker_ptr) cinfo->marker;
+
+ if (marker_code == (int) M_COM)
+ marker->process_COM = routine;
+ else if (marker_code >= (int) M_APP0 && marker_code <= (int) M_APP15)
+ marker->process_APPn[marker_code - (int) M_APP0] = routine;
+ else
+ ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, marker_code);
+}
--- /dev/null
+/*
+ * jdmaster.c
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * 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 master control logic for the JPEG decompressor.
+ * These routines are concerned with selecting the modules to be executed
+ * and with determining the number of passes and the work to be done in each
+ * pass.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private state */
+
+typedef struct {
+ struct jpeg_decomp_master pub; /* public fields */
+
+ int pass_number; /* # of passes completed */
+
+ boolean using_merged_upsample; /* TRUE if using merged upsample/cconvert */
+
+ /* Saved references to initialized quantizer modules,
+ * in case we need to switch modes.
+ */
+ struct jpeg_color_quantizer * quantizer_1pass;
+ struct jpeg_color_quantizer * quantizer_2pass;
+} my_decomp_master;
+
+typedef my_decomp_master * my_master_ptr;
+
+
+/*
+ * Determine whether merged upsample/color conversion should be used.
+ * CRUCIAL: this must match the actual capabilities of jdmerge.c!
+ */
+
+LOCAL(boolean)
+use_merged_upsample (j_decompress_ptr cinfo)
+{
+#ifdef UPSAMPLE_MERGING_SUPPORTED
+ /* Merging is the equivalent of plain box-filter upsampling */
+ if (cinfo->do_fancy_upsampling || cinfo->CCIR601_sampling)
+ return FALSE;
+ /* jdmerge.c only supports YCC=>RGB color conversion */
+ if (cinfo->jpeg_color_space != JCS_YCbCr || cinfo->num_components != 3 ||
+ cinfo->out_color_space != JCS_RGB ||
+ cinfo->out_color_components != RGB_PIXELSIZE)
+ return FALSE;
+ /* and it only handles 2h1v or 2h2v sampling ratios */
+ if (cinfo->comp_info[0].h_samp_factor != 2 ||
+ cinfo->comp_info[1].h_samp_factor != 1 ||
+ cinfo->comp_info[2].h_samp_factor != 1 ||
+ cinfo->comp_info[0].v_samp_factor > 2 ||
+ cinfo->comp_info[1].v_samp_factor != 1 ||
+ cinfo->comp_info[2].v_samp_factor != 1)
+ return FALSE;
+ /* furthermore, it doesn't work if we've scaled the IDCTs differently */
+ if (cinfo->comp_info[0].DCT_scaled_size != cinfo->min_DCT_scaled_size ||
+ cinfo->comp_info[1].DCT_scaled_size != cinfo->min_DCT_scaled_size ||
+ cinfo->comp_info[2].DCT_scaled_size != cinfo->min_DCT_scaled_size)
+ return FALSE;
+ /* ??? also need to test for upsample-time rescaling, when & if supported */
+ return TRUE; /* by golly, it'll work... */
+#else
+ return FALSE;
+#endif
+}
+
+
+/*
+ * Compute output image dimensions and related values.
+ * NOTE: this is exported for possible use by application.
+ * Hence it mustn't do anything that can't be done twice.
+ * Also note that it may be called before the master module is initialized!
+ */
+
+GLOBAL(void)
+jpeg_calc_output_dimensions (j_decompress_ptr cinfo)
+/* Do computations that are needed before master selection phase */
+{
+#ifdef IDCT_SCALING_SUPPORTED
+ int ci;
+ jpeg_component_info *compptr;
+#endif
+
+ /* Prevent application from calling me at wrong times */
+ if (cinfo->global_state != DSTATE_READY)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+#ifdef IDCT_SCALING_SUPPORTED
+
+ /* Compute actual output image dimensions and DCT scaling choices. */
+ if (cinfo->scale_num * 8 <= cinfo->scale_denom) {
+ /* Provide 1/8 scaling */
+ cinfo->output_width = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_width, 8L);
+ cinfo->output_height = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_height, 8L);
+ cinfo->min_DCT_scaled_size = 1;
+ } else if (cinfo->scale_num * 4 <= cinfo->scale_denom) {
+ /* Provide 1/4 scaling */
+ cinfo->output_width = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_width, 4L);
+ cinfo->output_height = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_height, 4L);
+ cinfo->min_DCT_scaled_size = 2;
+ } else if (cinfo->scale_num * 2 <= cinfo->scale_denom) {
+ /* Provide 1/2 scaling */
+ cinfo->output_width = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_width, 2L);
+ cinfo->output_height = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_height, 2L);
+ cinfo->min_DCT_scaled_size = 4;
+ } else {
+ /* Provide 1/1 scaling */
+ cinfo->output_width = cinfo->image_width;
+ cinfo->output_height = cinfo->image_height;
+ cinfo->min_DCT_scaled_size = DCTSIZE;
+ }
+ /* In selecting the actual DCT scaling for each component, we try to
+ * scale up the chroma components via IDCT scaling rather than upsampling.
+ * This saves time if the upsampler gets to use 1:1 scaling.
+ * Note this code assumes that the supported DCT scalings are powers of 2.
+ */
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ int ssize = cinfo->min_DCT_scaled_size;
+ while (ssize < DCTSIZE &&
+ (compptr->h_samp_factor * ssize * 2 <=
+ cinfo->max_h_samp_factor * cinfo->min_DCT_scaled_size) &&
+ (compptr->v_samp_factor * ssize * 2 <=
+ cinfo->max_v_samp_factor * cinfo->min_DCT_scaled_size)) {
+ ssize = ssize * 2;
+ }
+ compptr->DCT_scaled_size = ssize;
+ }
+
+ /* Recompute downsampled dimensions of components;
+ * application needs to know these if using raw downsampled data.
+ */
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ /* Size in samples, after IDCT scaling */
+ compptr->downsampled_width = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_width *
+ (long) (compptr->h_samp_factor * compptr->DCT_scaled_size),
+ (long) (cinfo->max_h_samp_factor * DCTSIZE));
+ compptr->downsampled_height = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_height *
+ (long) (compptr->v_samp_factor * compptr->DCT_scaled_size),
+ (long) (cinfo->max_v_samp_factor * DCTSIZE));
+ }
+
+#else /* !IDCT_SCALING_SUPPORTED */
+
+ /* Hardwire it to "no scaling" */
+ cinfo->output_width = cinfo->image_width;
+ cinfo->output_height = cinfo->image_height;
+ /* jdinput.c has already initialized DCT_scaled_size to DCTSIZE,
+ * and has computed unscaled downsampled_width and downsampled_height.
+ */
+
+#endif /* IDCT_SCALING_SUPPORTED */
+
+ /* Report number of components in selected colorspace. */
+ /* Probably this should be in the color conversion module... */
+ switch (cinfo->out_color_space) {
+ case JCS_GRAYSCALE:
+ cinfo->out_color_components = 1;
+ break;
+ case JCS_RGB:
+#if RGB_PIXELSIZE != 3
+ cinfo->out_color_components = RGB_PIXELSIZE;
+ break;
+#endif /* else share code with YCbCr */
+ case JCS_YCbCr:
+ cinfo->out_color_components = 3;
+ break;
+ case JCS_CMYK:
+ case JCS_YCCK:
+ cinfo->out_color_components = 4;
+ break;
+ default: /* else must be same colorspace as in file */
+ cinfo->out_color_components = cinfo->num_components;
+ break;
+ }
+ cinfo->output_components = (cinfo->quantize_colors ? 1 :
+ cinfo->out_color_components);
+
+ /* See if upsampler will want to emit more than one row at a time */
+ if (use_merged_upsample(cinfo))
+ cinfo->rec_outbuf_height = cinfo->max_v_samp_factor;
+ else
+ cinfo->rec_outbuf_height = 1;
+}
+
+
+/*
+ * Several decompression processes need to range-limit values to the range
+ * 0..MAXJSAMPLE; the input value may fall somewhat outside this range
+ * due to noise introduced by quantization, roundoff error, etc. These
+ * processes are inner loops and need to be as fast as possible. On most
+ * machines, particularly CPUs with pipelines or instruction prefetch,
+ * a (subscript-check-less) C table lookup
+ * x = sample_range_limit[x];
+ * is faster than explicit tests
+ * if (x < 0) x = 0;
+ * else if (x > MAXJSAMPLE) x = MAXJSAMPLE;
+ * These processes all use a common table prepared by the routine below.
+ *
+ * For most steps we can mathematically guarantee that the initial value
+ * of x is within MAXJSAMPLE+1 of the legal range, so a table running from
+ * -(MAXJSAMPLE+1) to 2*MAXJSAMPLE+1 is sufficient. But for the initial
+ * limiting step (just after the IDCT), a wildly out-of-range value is
+ * possible if the input data is corrupt. To avoid any chance of indexing
+ * off the end of memory and getting a bad-pointer trap, we perform the
+ * post-IDCT limiting thus:
+ * x = range_limit[x & MASK];
+ * where MASK is 2 bits wider than legal sample data, ie 10 bits for 8-bit
+ * samples. Under normal circumstances this is more than enough range and
+ * a correct output will be generated; with bogus input data the mask will
+ * cause wraparound, and we will safely generate a bogus-but-in-range output.
+ * For the post-IDCT step, we want to convert the data from signed to unsigned
+ * representation by adding CENTERJSAMPLE at the same time that we limit it.
+ * So the post-IDCT limiting table ends up looking like this:
+ * CENTERJSAMPLE,CENTERJSAMPLE+1,...,MAXJSAMPLE,
+ * MAXJSAMPLE (repeat 2*(MAXJSAMPLE+1)-CENTERJSAMPLE times),
+ * 0 (repeat 2*(MAXJSAMPLE+1)-CENTERJSAMPLE times),
+ * 0,1,...,CENTERJSAMPLE-1
+ * Negative inputs select values from the upper half of the table after
+ * masking.
+ *
+ * We can save some space by overlapping the start of the post-IDCT table
+ * with the simpler range limiting table. The post-IDCT table begins at
+ * sample_range_limit + CENTERJSAMPLE.
+ *
+ * Note that the table is allocated in near data space on PCs; it's small
+ * enough and used often enough to justify this.
+ */
+
+LOCAL(void)
+prepare_range_limit_table (j_decompress_ptr cinfo)
+/* Allocate and fill in the sample_range_limit table */
+{
+ JSAMPLE * table;
+ int i;
+
+ table = (JSAMPLE *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (5 * (MAXJSAMPLE+1) + CENTERJSAMPLE) * SIZEOF(JSAMPLE));
+ table += (MAXJSAMPLE+1); /* allow negative subscripts of simple table */
+ cinfo->sample_range_limit = table;
+ /* First segment of "simple" table: limit[x] = 0 for x < 0 */
+ MEMZERO(table - (MAXJSAMPLE+1), (MAXJSAMPLE+1) * SIZEOF(JSAMPLE));
+ /* Main part of "simple" table: limit[x] = x */
+ for (i = 0; i <= MAXJSAMPLE; i++)
+ table[i] = (JSAMPLE) i;
+ table += CENTERJSAMPLE; /* Point to where post-IDCT table starts */
+ /* End of simple table, rest of first half of post-IDCT table */
+ for (i = CENTERJSAMPLE; i < 2*(MAXJSAMPLE+1); i++)
+ table[i] = MAXJSAMPLE;
+ /* Second half of post-IDCT table */
+ MEMZERO(table + (2 * (MAXJSAMPLE+1)),
+ (2 * (MAXJSAMPLE+1) - CENTERJSAMPLE) * SIZEOF(JSAMPLE));
+ MEMCOPY(table + (4 * (MAXJSAMPLE+1) - CENTERJSAMPLE),
+ cinfo->sample_range_limit, CENTERJSAMPLE * SIZEOF(JSAMPLE));
+}
+
+
+/*
+ * Master selection of decompression modules.
+ * This is done once at jpeg_start_decompress time. We determine
+ * which modules will be used and give them appropriate initialization calls.
+ * We also initialize the decompressor input side to begin consuming data.
+ *
+ * Since jpeg_read_header has finished, we know what is in the SOF
+ * and (first) SOS markers. We also have all the application parameter
+ * settings.
+ */
+
+LOCAL(void)
+master_selection (j_decompress_ptr cinfo)
+{
+ my_master_ptr master = (my_master_ptr) cinfo->master;
+ boolean use_c_buffer;
+ long samplesperrow;
+ JDIMENSION jd_samplesperrow;
+
+ /* Initialize dimensions and other stuff */
+ jpeg_calc_output_dimensions(cinfo);
+ prepare_range_limit_table(cinfo);
+
+ /* Width of an output scanline must be representable as JDIMENSION. */
+ samplesperrow = (long) cinfo->output_width * (long) cinfo->out_color_components;
+ jd_samplesperrow = (JDIMENSION) samplesperrow;
+ if ((long) jd_samplesperrow != samplesperrow)
+ ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
+
+ /* Initialize my private state */
+ master->pass_number = 0;
+ master->using_merged_upsample = use_merged_upsample(cinfo);
+
+ /* Color quantizer selection */
+ master->quantizer_1pass = NULL;
+ master->quantizer_2pass = NULL;
+ /* No mode changes if not using buffered-image mode. */
+ if (! cinfo->quantize_colors || ! cinfo->buffered_image) {
+ cinfo->enable_1pass_quant = FALSE;
+ cinfo->enable_external_quant = FALSE;
+ cinfo->enable_2pass_quant = FALSE;
+ }
+ if (cinfo->quantize_colors) {
+ if (cinfo->raw_data_out)
+ ERREXIT(cinfo, JERR_NOTIMPL);
+ /* 2-pass quantizer only works in 3-component color space. */
+ if (cinfo->out_color_components != 3) {
+ cinfo->enable_1pass_quant = TRUE;
+ cinfo->enable_external_quant = FALSE;
+ cinfo->enable_2pass_quant = FALSE;
+ cinfo->colormap = NULL;
+ } else if (cinfo->colormap != NULL) {
+ cinfo->enable_external_quant = TRUE;
+ } else if (cinfo->two_pass_quantize) {
+ cinfo->enable_2pass_quant = TRUE;
+ } else {
+ cinfo->enable_1pass_quant = TRUE;
+ }
+
+ if (cinfo->enable_1pass_quant) {
+#ifdef QUANT_1PASS_SUPPORTED
+ jinit_1pass_quantizer(cinfo);
+ master->quantizer_1pass = cinfo->cquantize;
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+ }
+
+ /* We use the 2-pass code to map to external colormaps. */
+ if (cinfo->enable_2pass_quant || cinfo->enable_external_quant) {
+#ifdef QUANT_2PASS_SUPPORTED
+ jinit_2pass_quantizer(cinfo);
+ master->quantizer_2pass = cinfo->cquantize;
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+ }
+ /* If both quantizers are initialized, the 2-pass one is left active;
+ * this is necessary for starting with quantization to an external map.
+ */
+ }
+
+ /* Post-processing: in particular, color conversion first */
+ if (! cinfo->raw_data_out) {
+ if (master->using_merged_upsample) {
+#ifdef UPSAMPLE_MERGING_SUPPORTED
+ jinit_merged_upsampler(cinfo); /* does color conversion too */
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+ } else {
+ jinit_color_deconverter(cinfo);
+ jinit_upsampler(cinfo);
+ }
+ jinit_d_post_controller(cinfo, cinfo->enable_2pass_quant);
+ }
+ /* Inverse DCT */
+ jinit_inverse_dct(cinfo);
+ /* Entropy decoding: either Huffman or arithmetic coding. */
+ if (cinfo->arith_code) {
+ ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
+ } else {
+ if (cinfo->progressive_mode) {
+#ifdef D_PROGRESSIVE_SUPPORTED
+ jinit_phuff_decoder(cinfo);
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+ } else
+ jinit_huff_decoder(cinfo);
+ }
+
+ /* Initialize principal buffer controllers. */
+ use_c_buffer = cinfo->inputctl->has_multiple_scans || cinfo->buffered_image;
+ jinit_d_coef_controller(cinfo, use_c_buffer);
+
+ if (! cinfo->raw_data_out)
+ jinit_d_main_controller(cinfo, FALSE /* never need full buffer here */);
+
+ /* We can now tell the memory manager to allocate virtual arrays. */
+ (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo);
+
+ /* Initialize input side of decompressor to consume first scan. */
+ (*cinfo->inputctl->start_input_pass) (cinfo);
+
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+ /* If jpeg_start_decompress will read the whole file, initialize
+ * progress monitoring appropriately. The input step is counted
+ * as one pass.
+ */
+ if (cinfo->progress != NULL && ! cinfo->buffered_image &&
+ cinfo->inputctl->has_multiple_scans) {
+ int nscans;
+ /* Estimate number of scans to set pass_limit. */
+ if (cinfo->progressive_mode) {
+ /* Arbitrarily estimate 2 interleaved DC scans + 3 AC scans/component. */
+ nscans = 2 + 3 * cinfo->num_components;
+ } else {
+ /* For a nonprogressive multiscan file, estimate 1 scan per component. */
+ nscans = cinfo->num_components;
+ }
+ cinfo->progress->pass_counter = 0L;
+ cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows * nscans;
+ cinfo->progress->completed_passes = 0;
+ cinfo->progress->total_passes = (cinfo->enable_2pass_quant ? 3 : 2);
+ /* Count the input pass as done */
+ master->pass_number++;
+ }
+#endif /* D_MULTISCAN_FILES_SUPPORTED */
+}
+
+
+/*
+ * Per-pass setup.
+ * This is called at the beginning of each output pass. We determine which
+ * modules will be active during this pass and give them appropriate
+ * start_pass calls. We also set is_dummy_pass to indicate whether this
+ * is a "real" output pass or a dummy pass for color quantization.
+ * (In the latter case, jdapistd.c will crank the pass to completion.)
+ */
+
+METHODDEF(void)
+prepare_for_output_pass (j_decompress_ptr cinfo)
+{
+ my_master_ptr master = (my_master_ptr) cinfo->master;
+
+ if (master->pub.is_dummy_pass) {
+#ifdef QUANT_2PASS_SUPPORTED
+ /* Final pass of 2-pass quantization */
+ master->pub.is_dummy_pass = FALSE;
+ (*cinfo->cquantize->start_pass) (cinfo, FALSE);
+ (*cinfo->post->start_pass) (cinfo, JBUF_CRANK_DEST);
+ (*cinfo->main->start_pass) (cinfo, JBUF_CRANK_DEST);
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif /* QUANT_2PASS_SUPPORTED */
+ } else {
+ if (cinfo->quantize_colors && cinfo->colormap == NULL) {
+ /* Select new quantization method */
+ if (cinfo->two_pass_quantize && cinfo->enable_2pass_quant) {
+ cinfo->cquantize = master->quantizer_2pass;
+ master->pub.is_dummy_pass = TRUE;
+ } else if (cinfo->enable_1pass_quant) {
+ cinfo->cquantize = master->quantizer_1pass;
+ } else {
+ ERREXIT(cinfo, JERR_MODE_CHANGE);
+ }
+ }
+ (*cinfo->idct->start_pass) (cinfo);
+ (*cinfo->coef->start_output_pass) (cinfo);
+ if (! cinfo->raw_data_out) {
+ if (! master->using_merged_upsample)
+ (*cinfo->cconvert->start_pass) (cinfo);
+ (*cinfo->upsample->start_pass) (cinfo);
+ if (cinfo->quantize_colors)
+ (*cinfo->cquantize->start_pass) (cinfo, master->pub.is_dummy_pass);
+ (*cinfo->post->start_pass) (cinfo,
+ (master->pub.is_dummy_pass ? JBUF_SAVE_AND_PASS : JBUF_PASS_THRU));
+ (*cinfo->main->start_pass) (cinfo, JBUF_PASS_THRU);
+ }
+ }
+
+ /* Set up progress monitor's pass info if present */
+ if (cinfo->progress != NULL) {
+ cinfo->progress->completed_passes = master->pass_number;
+ cinfo->progress->total_passes = master->pass_number +
+ (master->pub.is_dummy_pass ? 2 : 1);
+ /* In buffered-image mode, we assume one more output pass if EOI not
+ * yet reached, but no more passes if EOI has been reached.
+ */
+ if (cinfo->buffered_image && ! cinfo->inputctl->eoi_reached) {
+ cinfo->progress->total_passes += (cinfo->enable_2pass_quant ? 2 : 1);
+ }
+ }
+}
+
+
+/*
+ * Finish up at end of an output pass.
+ */
+
+METHODDEF(void)
+finish_output_pass (j_decompress_ptr cinfo)
+{
+ my_master_ptr master = (my_master_ptr) cinfo->master;
+
+ if (cinfo->quantize_colors)
+ (*cinfo->cquantize->finish_pass) (cinfo);
+ master->pass_number++;
+}
+
+
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+
+/*
+ * Switch to a new external colormap between output passes.
+ */
+
+GLOBAL(void)
+jpeg_new_colormap (j_decompress_ptr cinfo)
+{
+ my_master_ptr master = (my_master_ptr) cinfo->master;
+
+ /* Prevent application from calling me at wrong times */
+ if (cinfo->global_state != DSTATE_BUFIMAGE)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+ if (cinfo->quantize_colors && cinfo->enable_external_quant &&
+ cinfo->colormap != NULL) {
+ /* Select 2-pass quantizer for external colormap use */
+ cinfo->cquantize = master->quantizer_2pass;
+ /* Notify quantizer of colormap change */
+ (*cinfo->cquantize->new_color_map) (cinfo);
+ master->pub.is_dummy_pass = FALSE; /* just in case */
+ } else
+ ERREXIT(cinfo, JERR_MODE_CHANGE);
+}
+
+#endif /* D_MULTISCAN_FILES_SUPPORTED */
+
+
+/*
+ * Initialize master decompression control and select active modules.
+ * This is performed at the start of jpeg_start_decompress.
+ */
+
+GLOBAL(void)
+jinit_master_decompress (j_decompress_ptr cinfo)
+{
+ my_master_ptr master;
+
+ master = (my_master_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_decomp_master));
+ cinfo->master = (struct jpeg_decomp_master *) master;
+ master->pub.prepare_for_output_pass = prepare_for_output_pass;
+ master->pub.finish_output_pass = finish_output_pass;
+
+ master->pub.is_dummy_pass = FALSE;
+
+ master_selection(cinfo);
+}
--- /dev/null
+/*
+ * jdmerge.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * 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 code for merged upsampling/color conversion.
+ *
+ * This file combines functions from jdsample.c and jdcolor.c;
+ * read those files first to understand what's going on.
+ *
+ * When the chroma components are to be upsampled by simple replication
+ * (ie, box filtering), we can save some work in color conversion by
+ * calculating all the output pixels corresponding to a pair of chroma
+ * samples at one time. In the conversion equations
+ * R = Y + K1 * Cr
+ * G = Y + K2 * Cb + K3 * Cr
+ * B = Y + K4 * Cb
+ * only the Y term varies among the group of pixels corresponding to a pair
+ * of chroma samples, so the rest of the terms can be calculated just once.
+ * At typical sampling ratios, this eliminates half or three-quarters of the
+ * multiplications needed for color conversion.
+ *
+ * This file currently provides implementations for the following cases:
+ * YCbCr => RGB color conversion only.
+ * Sampling ratios of 2h1v or 2h2v.
+ * No scaling needed at upsample time.
+ * Corner-aligned (non-CCIR601) sampling alignment.
+ * Other special cases could be added, but in most applications these are
+ * the only common cases. (For uncommon cases we fall back on the more
+ * general code in jdsample.c and jdcolor.c.)
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+#ifdef UPSAMPLE_MERGING_SUPPORTED
+
+
+/* Private subobject */
+
+typedef struct {
+ struct jpeg_upsampler pub; /* public fields */
+
+ /* Pointer to routine to do actual upsampling/conversion of one row group */
+ JMETHOD(void, upmethod, (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+ JSAMPARRAY output_buf));
+
+ /* Private state for YCC->RGB conversion */
+ int * Cr_r_tab; /* => table for Cr to R conversion */
+ int * Cb_b_tab; /* => table for Cb to B conversion */
+ INT32 * Cr_g_tab; /* => table for Cr to G conversion */
+ INT32 * Cb_g_tab; /* => table for Cb to G conversion */
+
+ /* For 2:1 vertical sampling, we produce two output rows at a time.
+ * We need a "spare" row buffer to hold the second output row if the
+ * application provides just a one-row buffer; we also use the spare
+ * to discard the dummy last row if the image height is odd.
+ */
+ JSAMPROW spare_row;
+ boolean spare_full; /* T if spare buffer is occupied */
+
+ JDIMENSION out_row_width; /* samples per output row */
+ JDIMENSION rows_to_go; /* counts rows remaining in image */
+} my_upsampler;
+
+typedef my_upsampler * my_upsample_ptr;
+
+#define SCALEBITS 16 /* speediest right-shift on some machines */
+#define ONE_HALF ((INT32) 1 << (SCALEBITS-1))
+#define FIX(x) ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
+
+
+/*
+ * Initialize tables for YCC->RGB colorspace conversion.
+ * This is taken directly from jdcolor.c; see that file for more info.
+ */
+
+LOCAL(void)
+build_ycc_rgb_table (j_decompress_ptr cinfo)
+{
+ my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
+ int i;
+ INT32 x;
+ SHIFT_TEMPS
+
+ upsample->Cr_r_tab = (int *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (MAXJSAMPLE+1) * SIZEOF(int));
+ upsample->Cb_b_tab = (int *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (MAXJSAMPLE+1) * SIZEOF(int));
+ upsample->Cr_g_tab = (INT32 *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (MAXJSAMPLE+1) * SIZEOF(INT32));
+ upsample->Cb_g_tab = (INT32 *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (MAXJSAMPLE+1) * SIZEOF(INT32));
+
+ for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
+ /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
+ /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
+ /* Cr=>R value is nearest int to 1.40200 * x */
+ upsample->Cr_r_tab[i] = (int)
+ RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS);
+ /* Cb=>B value is nearest int to 1.77200 * x */
+ upsample->Cb_b_tab[i] = (int)
+ RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS);
+ /* Cr=>G value is scaled-up -0.71414 * x */
+ upsample->Cr_g_tab[i] = (- FIX(0.71414)) * x;
+ /* Cb=>G value is scaled-up -0.34414 * x */
+ /* We also add in ONE_HALF so that need not do it in inner loop */
+ upsample->Cb_g_tab[i] = (- FIX(0.34414)) * x + ONE_HALF;
+ }
+}
+
+
+/*
+ * Initialize for an upsampling pass.
+ */
+
+METHODDEF(void)
+start_pass_merged_upsample (j_decompress_ptr cinfo)
+{
+ my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
+
+ /* Mark the spare buffer empty */
+ upsample->spare_full = FALSE;
+ /* Initialize total-height counter for detecting bottom of image */
+ upsample->rows_to_go = cinfo->output_height;
+}
+
+
+/*
+ * Control routine to do upsampling (and color conversion).
+ *
+ * The control routine just handles the row buffering considerations.
+ */
+
+METHODDEF(void)
+merged_2v_upsample (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+ JDIMENSION in_row_groups_avail,
+ JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail)
+/* 2:1 vertical sampling case: may need a spare row. */
+{
+ my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
+ JSAMPROW work_ptrs[2];
+ JDIMENSION num_rows; /* number of rows returned to caller */
+
+ if (upsample->spare_full) {
+ /* If we have a spare row saved from a previous cycle, just return it. */
+ jcopy_sample_rows(& upsample->spare_row, 0, output_buf + *out_row_ctr, 0,
+ 1, upsample->out_row_width);
+ num_rows = 1;
+ upsample->spare_full = FALSE;
+ } else {
+ /* Figure number of rows to return to caller. */
+ num_rows = 2;
+ /* Not more than the distance to the end of the image. */
+ if (num_rows > upsample->rows_to_go)
+ num_rows = upsample->rows_to_go;
+ /* And not more than what the client can accept: */
+ out_rows_avail -= *out_row_ctr;
+ if (num_rows > out_rows_avail)
+ num_rows = out_rows_avail;
+ /* Create output pointer array for upsampler. */
+ work_ptrs[0] = output_buf[*out_row_ctr];
+ if (num_rows > 1) {
+ work_ptrs[1] = output_buf[*out_row_ctr + 1];
+ } else {
+ work_ptrs[1] = upsample->spare_row;
+ upsample->spare_full = TRUE;
+ }
+ /* Now do the upsampling. */
+ (*upsample->upmethod) (cinfo, input_buf, *in_row_group_ctr, work_ptrs);
+ }
+
+ /* Adjust counts */
+ *out_row_ctr += num_rows;
+ upsample->rows_to_go -= num_rows;
+ /* When the buffer is emptied, declare this input row group consumed */
+ if (! upsample->spare_full)
+ (*in_row_group_ctr)++;
+}
+
+
+METHODDEF(void)
+merged_1v_upsample (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+ JDIMENSION in_row_groups_avail,
+ JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail)
+/* 1:1 vertical sampling case: much easier, never need a spare row. */
+{
+ my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
+
+ /* Just do the upsampling. */
+ (*upsample->upmethod) (cinfo, input_buf, *in_row_group_ctr,
+ output_buf + *out_row_ctr);
+ /* Adjust counts */
+ (*out_row_ctr)++;
+ (*in_row_group_ctr)++;
+}
+
+
+/*
+ * These are the routines invoked by the control routines to do
+ * the actual upsampling/conversion. One row group is processed per call.
+ *
+ * Note: since we may be writing directly into application-supplied buffers,
+ * we have to be honest about the output width; we can't assume the buffer
+ * has been rounded up to an even width.
+ */
+
+
+/*
+ * Upsample and color convert for the case of 2:1 horizontal and 1:1 vertical.
+ */
+
+METHODDEF(void)
+h2v1_merged_upsample (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+ JSAMPARRAY output_buf)
+{
+ my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
+ register int y, cred, cgreen, cblue;
+ int cb, cr;
+ register JSAMPROW outptr;
+ JSAMPROW inptr0, inptr1, inptr2;
+ JDIMENSION col;
+ /* copy these pointers into registers if possible */
+ register JSAMPLE * range_limit = cinfo->sample_range_limit;
+ int * Crrtab = upsample->Cr_r_tab;
+ int * Cbbtab = upsample->Cb_b_tab;
+ INT32 * Crgtab = upsample->Cr_g_tab;
+ INT32 * Cbgtab = upsample->Cb_g_tab;
+ SHIFT_TEMPS
+
+ inptr0 = input_buf[0][in_row_group_ctr];
+ inptr1 = input_buf[1][in_row_group_ctr];
+ inptr2 = input_buf[2][in_row_group_ctr];
+ outptr = output_buf[0];
+ /* Loop for each pair of output pixels */
+ for (col = cinfo->output_width >> 1; col > 0; col--) {
+ /* Do the chroma part of the calculation */
+ cb = GETJSAMPLE(*inptr1++);
+ cr = GETJSAMPLE(*inptr2++);
+ cred = Crrtab[cr];
+ cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+ cblue = Cbbtab[cb];
+ /* Fetch 2 Y values and emit 2 pixels */
+ y = GETJSAMPLE(*inptr0++);
+ outptr[RGB_RED] = range_limit[y + cred];
+ outptr[RGB_GREEN] = range_limit[y + cgreen];
+ outptr[RGB_BLUE] = range_limit[y + cblue];
+ outptr += RGB_PIXELSIZE;
+ y = GETJSAMPLE(*inptr0++);
+ outptr[RGB_RED] = range_limit[y + cred];
+ outptr[RGB_GREEN] = range_limit[y + cgreen];
+ outptr[RGB_BLUE] = range_limit[y + cblue];
+ outptr += RGB_PIXELSIZE;
+ }
+ /* If image width is odd, do the last output column separately */
+ if (cinfo->output_width & 1) {
+ cb = GETJSAMPLE(*inptr1);
+ cr = GETJSAMPLE(*inptr2);
+ cred = Crrtab[cr];
+ cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+ cblue = Cbbtab[cb];
+ y = GETJSAMPLE(*inptr0);
+ outptr[RGB_RED] = range_limit[y + cred];
+ outptr[RGB_GREEN] = range_limit[y + cgreen];
+ outptr[RGB_BLUE] = range_limit[y + cblue];
+ }
+}
+
+
+/*
+ * Upsample and color convert for the case of 2:1 horizontal and 2:1 vertical.
+ */
+
+METHODDEF(void)
+h2v2_merged_upsample (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+ JSAMPARRAY output_buf)
+{
+ my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
+ register int y, cred, cgreen, cblue;
+ int cb, cr;
+ register JSAMPROW outptr0, outptr1;
+ JSAMPROW inptr00, inptr01, inptr1, inptr2;
+ JDIMENSION col;
+ /* copy these pointers into registers if possible */
+ register JSAMPLE * range_limit = cinfo->sample_range_limit;
+ int * Crrtab = upsample->Cr_r_tab;
+ int * Cbbtab = upsample->Cb_b_tab;
+ INT32 * Crgtab = upsample->Cr_g_tab;
+ INT32 * Cbgtab = upsample->Cb_g_tab;
+ SHIFT_TEMPS
+
+ inptr00 = input_buf[0][in_row_group_ctr*2];
+ inptr01 = input_buf[0][in_row_group_ctr*2 + 1];
+ inptr1 = input_buf[1][in_row_group_ctr];
+ inptr2 = input_buf[2][in_row_group_ctr];
+ outptr0 = output_buf[0];
+ outptr1 = output_buf[1];
+ /* Loop for each group of output pixels */
+ for (col = cinfo->output_width >> 1; col > 0; col--) {
+ /* Do the chroma part of the calculation */
+ cb = GETJSAMPLE(*inptr1++);
+ cr = GETJSAMPLE(*inptr2++);
+ cred = Crrtab[cr];
+ cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+ cblue = Cbbtab[cb];
+ /* Fetch 4 Y values and emit 4 pixels */
+ y = GETJSAMPLE(*inptr00++);
+ outptr0[RGB_RED] = range_limit[y + cred];
+ outptr0[RGB_GREEN] = range_limit[y + cgreen];
+ outptr0[RGB_BLUE] = range_limit[y + cblue];
+ outptr0 += RGB_PIXELSIZE;
+ y = GETJSAMPLE(*inptr00++);
+ outptr0[RGB_RED] = range_limit[y + cred];
+ outptr0[RGB_GREEN] = range_limit[y + cgreen];
+ outptr0[RGB_BLUE] = range_limit[y + cblue];
+ outptr0 += RGB_PIXELSIZE;
+ y = GETJSAMPLE(*inptr01++);
+ outptr1[RGB_RED] = range_limit[y + cred];
+ outptr1[RGB_GREEN] = range_limit[y + cgreen];
+ outptr1[RGB_BLUE] = range_limit[y + cblue];
+ outptr1 += RGB_PIXELSIZE;
+ y = GETJSAMPLE(*inptr01++);
+ outptr1[RGB_RED] = range_limit[y + cred];
+ outptr1[RGB_GREEN] = range_limit[y + cgreen];
+ outptr1[RGB_BLUE] = range_limit[y + cblue];
+ outptr1 += RGB_PIXELSIZE;
+ }
+ /* If image width is odd, do the last output column separately */
+ if (cinfo->output_width & 1) {
+ cb = GETJSAMPLE(*inptr1);
+ cr = GETJSAMPLE(*inptr2);
+ cred = Crrtab[cr];
+ cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+ cblue = Cbbtab[cb];
+ y = GETJSAMPLE(*inptr00);
+ outptr0[RGB_RED] = range_limit[y + cred];
+ outptr0[RGB_GREEN] = range_limit[y + cgreen];
+ outptr0[RGB_BLUE] = range_limit[y + cblue];
+ y = GETJSAMPLE(*inptr01);
+ outptr1[RGB_RED] = range_limit[y + cred];
+ outptr1[RGB_GREEN] = range_limit[y + cgreen];
+ outptr1[RGB_BLUE] = range_limit[y + cblue];
+ }
+}
+
+
+/*
+ * Module initialization routine for merged upsampling/color conversion.
+ *
+ * NB: this is called under the conditions determined by use_merged_upsample()
+ * in jdmaster.c. That routine MUST correspond to the actual capabilities
+ * of this module; no safety checks are made here.
+ */
+
+GLOBAL(void)
+jinit_merged_upsampler (j_decompress_ptr cinfo)
+{
+ my_upsample_ptr upsample;
+
+ upsample = (my_upsample_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_upsampler));
+ cinfo->upsample = (struct jpeg_upsampler *) upsample;
+ upsample->pub.start_pass = start_pass_merged_upsample;
+ upsample->pub.need_context_rows = FALSE;
+
+ upsample->out_row_width = cinfo->output_width * cinfo->out_color_components;
+
+ if (cinfo->max_v_samp_factor == 2) {
+ upsample->pub.upsample = merged_2v_upsample;
+ upsample->upmethod = h2v2_merged_upsample;
+ /* Allocate a spare row buffer */
+ upsample->spare_row = (JSAMPROW)
+ (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (size_t) (upsample->out_row_width * SIZEOF(JSAMPLE)));
+ } else {
+ upsample->pub.upsample = merged_1v_upsample;
+ upsample->upmethod = h2v1_merged_upsample;
+ /* No spare row needed */
+ upsample->spare_row = NULL;
+ }
+
+ build_ycc_rgb_table(cinfo);
+}
+
+#endif /* UPSAMPLE_MERGING_SUPPORTED */
--- /dev/null
+/*
+ * jdphuff.c
+ *
+ * Copyright (C) 1995-1997, Thomas G. Lane.
+ * 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 Huffman entropy decoding routines for progressive JPEG.
+ *
+ * Much of the complexity here has to do with supporting input suspension.
+ * If the data source module demands suspension, we want to be able to back
+ * up to the start of the current MCU. To do this, we copy state variables
+ * into local working storage, and update them back to the permanent
+ * storage only upon successful completion of an MCU.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdhuff.h" /* Declarations shared with jdhuff.c */
+
+
+#ifdef D_PROGRESSIVE_SUPPORTED
+
+/*
+ * Expanded entropy decoder object for progressive Huffman decoding.
+ *
+ * The savable_state subrecord contains fields that change within an MCU,
+ * but must not be updated permanently until we complete the MCU.
+ */
+
+typedef struct {
+ unsigned int EOBRUN; /* remaining EOBs in EOBRUN */
+ int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
+} savable_state;
+
+/* This macro is to work around compilers with missing or broken
+ * structure assignment. You'll need to fix this code if you have
+ * such a compiler and you change MAX_COMPS_IN_SCAN.
+ */
+
+#ifndef NO_STRUCT_ASSIGN
+#define ASSIGN_STATE(dest,src) ((dest) = (src))
+#else
+#if MAX_COMPS_IN_SCAN == 4
+#define ASSIGN_STATE(dest,src) \
+ ((dest).EOBRUN = (src).EOBRUN, \
+ (dest).last_dc_val[0] = (src).last_dc_val[0], \
+ (dest).last_dc_val[1] = (src).last_dc_val[1], \
+ (dest).last_dc_val[2] = (src).last_dc_val[2], \
+ (dest).last_dc_val[3] = (src).last_dc_val[3])
+#endif
+#endif
+
+
+typedef struct {
+ struct jpeg_entropy_decoder pub; /* public fields */
+
+ /* These fields are loaded into local variables at start of each MCU.
+ * In case of suspension, we exit WITHOUT updating them.
+ */
+ bitread_perm_state bitstate; /* Bit buffer at start of MCU */
+ savable_state saved; /* Other state at start of MCU */
+
+ /* These fields are NOT loaded into local working state. */
+ unsigned int restarts_to_go; /* MCUs left in this restart interval */
+
+ /* Pointers to derived tables (these workspaces have image lifespan) */
+ d_derived_tbl * derived_tbls[NUM_HUFF_TBLS];
+
+ d_derived_tbl * ac_derived_tbl; /* active table during an AC scan */
+} phuff_entropy_decoder;
+
+typedef phuff_entropy_decoder * phuff_entropy_ptr;
+
+/* Forward declarations */
+METHODDEF(boolean) decode_mcu_DC_first JPP((j_decompress_ptr cinfo,
+ JBLOCKROW *MCU_data));
+METHODDEF(boolean) decode_mcu_AC_first JPP((j_decompress_ptr cinfo,
+ JBLOCKROW *MCU_data));
+METHODDEF(boolean) decode_mcu_DC_refine JPP((j_decompress_ptr cinfo,
+ JBLOCKROW *MCU_data));
+METHODDEF(boolean) decode_mcu_AC_refine JPP((j_decompress_ptr cinfo,
+ JBLOCKROW *MCU_data));
+
+
+/*
+ * Initialize for a Huffman-compressed scan.
+ */
+
+METHODDEF(void)
+start_pass_phuff_decoder (j_decompress_ptr cinfo)
+{
+ phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+ boolean is_DC_band, bad;
+ int ci, coefi, tbl;
+ int *coef_bit_ptr;
+ jpeg_component_info * compptr;
+
+ is_DC_band = (cinfo->Ss == 0);
+
+ /* Validate scan parameters */
+ bad = FALSE;
+ if (is_DC_band) {
+ if (cinfo->Se != 0)
+ bad = TRUE;
+ } else {
+ /* need not check Ss/Se < 0 since they came from unsigned bytes */
+ if (cinfo->Ss > cinfo->Se || cinfo->Se >= DCTSIZE2)
+ bad = TRUE;
+ /* AC scans may have only one component */
+ if (cinfo->comps_in_scan != 1)
+ bad = TRUE;
+ }
+ if (cinfo->Ah != 0) {
+ /* Successive approximation refinement scan: must have Al = Ah-1. */
+ if (cinfo->Al != cinfo->Ah-1)
+ bad = TRUE;
+ }
+ if (cinfo->Al > 13) /* need not check for < 0 */
+ bad = TRUE;
+ /* Arguably the maximum Al value should be less than 13 for 8-bit precision,
+ * but the spec doesn't say so, and we try to be liberal about what we
+ * accept. Note: large Al values could result in out-of-range DC
+ * coefficients during early scans, leading to bizarre displays due to
+ * overflows in the IDCT math. But we won't crash.
+ */
+ if (bad)
+ ERREXIT4(cinfo, JERR_BAD_PROGRESSION,
+ cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al);
+ /* Update progression status, and verify that scan order is legal.
+ * Note that inter-scan inconsistencies are treated as warnings
+ * not fatal errors ... not clear if this is right way to behave.
+ */
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ int cindex = cinfo->cur_comp_info[ci]->component_index;
+ coef_bit_ptr = & cinfo->coef_bits[cindex][0];
+ if (!is_DC_band && coef_bit_ptr[0] < 0) /* AC without prior DC scan */
+ WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, 0);
+ for (coefi = cinfo->Ss; coefi <= cinfo->Se; coefi++) {
+ int expected = (coef_bit_ptr[coefi] < 0) ? 0 : coef_bit_ptr[coefi];
+ if (cinfo->Ah != expected)
+ WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, coefi);
+ coef_bit_ptr[coefi] = cinfo->Al;
+ }
+ }
+
+ /* Select MCU decoding routine */
+ if (cinfo->Ah == 0) {
+ if (is_DC_band)
+ entropy->pub.decode_mcu = decode_mcu_DC_first;
+ else
+ entropy->pub.decode_mcu = decode_mcu_AC_first;
+ } else {
+ if (is_DC_band)
+ entropy->pub.decode_mcu = decode_mcu_DC_refine;
+ else
+ entropy->pub.decode_mcu = decode_mcu_AC_refine;
+ }
+
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ /* Make sure requested tables are present, and compute derived tables.
+ * We may build same derived table more than once, but it's not expensive.
+ */
+ if (is_DC_band) {
+ if (cinfo->Ah == 0) { /* DC refinement needs no table */
+ tbl = compptr->dc_tbl_no;
+ jpeg_make_d_derived_tbl(cinfo, TRUE, tbl,
+ & entropy->derived_tbls[tbl]);
+ }
+ } else {
+ tbl = compptr->ac_tbl_no;
+ jpeg_make_d_derived_tbl(cinfo, FALSE, tbl,
+ & entropy->derived_tbls[tbl]);
+ /* remember the single active table */
+ entropy->ac_derived_tbl = entropy->derived_tbls[tbl];
+ }
+ /* Initialize DC predictions to 0 */
+ entropy->saved.last_dc_val[ci] = 0;
+ }
+
+ /* Initialize bitread state variables */
+ entropy->bitstate.bits_left = 0;
+ entropy->bitstate.get_buffer = 0; /* unnecessary, but keeps Purify quiet */
+ entropy->pub.insufficient_data = FALSE;
+
+ /* Initialize private state variables */
+ entropy->saved.EOBRUN = 0;
+
+ /* Initialize restart counter */
+ entropy->restarts_to_go = cinfo->restart_interval;
+}
+
+
+/*
+ * Figure F.12: extend sign bit.
+ * On some machines, a shift and add will be faster than a table lookup.
+ */
+
+#ifdef AVOID_TABLES
+
+#define HUFF_EXTEND(x,s) ((x) < (1<<((s)-1)) ? (x) + (((-1)<<(s)) + 1) : (x))
+
+#else
+
+#define HUFF_EXTEND(x,s) ((x) < extend_test[s] ? (x) + extend_offset[s] : (x))
+
+static const int extend_test[16] = /* entry n is 2**(n-1) */
+ { 0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
+ 0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000 };
+
+static const int extend_offset[16] = /* entry n is (-1 << n) + 1 */
+ { 0, ((-1)<<1) + 1, ((-1)<<2) + 1, ((-1)<<3) + 1, ((-1)<<4) + 1,
+ ((-1)<<5) + 1, ((-1)<<6) + 1, ((-1)<<7) + 1, ((-1)<<8) + 1,
+ ((-1)<<9) + 1, ((-1)<<10) + 1, ((-1)<<11) + 1, ((-1)<<12) + 1,
+ ((-1)<<13) + 1, ((-1)<<14) + 1, ((-1)<<15) + 1 };
+
+#endif /* AVOID_TABLES */
+
+
+/*
+ * Check for a restart marker & resynchronize decoder.
+ * Returns FALSE if must suspend.
+ */
+
+LOCAL(boolean)
+process_restart (j_decompress_ptr cinfo)
+{
+ phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+ int ci;
+
+ /* Throw away any unused bits remaining in bit buffer; */
+ /* include any full bytes in next_marker's count of discarded bytes */
+ cinfo->marker->discarded_bytes += entropy->bitstate.bits_left / 8;
+ entropy->bitstate.bits_left = 0;
+
+ /* Advance past the RSTn marker */
+ if (! (*cinfo->marker->read_restart_marker) (cinfo))
+ return FALSE;
+
+ /* Re-initialize DC predictions to 0 */
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++)
+ entropy->saved.last_dc_val[ci] = 0;
+ /* Re-init EOB run count, too */
+ entropy->saved.EOBRUN = 0;
+
+ /* Reset restart counter */
+ entropy->restarts_to_go = cinfo->restart_interval;
+
+ /* Reset out-of-data flag, unless read_restart_marker left us smack up
+ * against a marker. In that case we will end up treating the next data
+ * segment as empty, and we can avoid producing bogus output pixels by
+ * leaving the flag set.
+ */
+ if (cinfo->unread_marker == 0)
+ entropy->pub.insufficient_data = FALSE;
+
+ return TRUE;
+}
+
+
+/*
+ * Huffman MCU decoding.
+ * Each of these routines decodes and returns one MCU's worth of
+ * Huffman-compressed coefficients.
+ * The coefficients are reordered from zigzag order into natural array order,
+ * but are not dequantized.
+ *
+ * The i'th block of the MCU is stored into the block pointed to by
+ * MCU_data[i]. WE ASSUME THIS AREA IS INITIALLY ZEROED BY THE CALLER.
+ *
+ * We return FALSE if data source requested suspension. In that case no
+ * changes have been made to permanent state. (Exception: some output
+ * coefficients may already have been assigned. This is harmless for
+ * spectral selection, since we'll just re-assign them on the next call.
+ * Successive approximation AC refinement has to be more careful, however.)
+ */
+
+/*
+ * MCU decoding for DC initial scan (either spectral selection,
+ * or first pass of successive approximation).
+ */
+
+METHODDEF(boolean)
+decode_mcu_DC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+ phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+ int Al = cinfo->Al;
+ register int s, r;
+ int blkn, ci;
+ JBLOCKROW block;
+ BITREAD_STATE_VARS;
+ savable_state state;
+ d_derived_tbl * tbl;
+ jpeg_component_info * compptr;
+
+ /* Process restart marker if needed; may have to suspend */
+ if (cinfo->restart_interval) {
+ if (entropy->restarts_to_go == 0)
+ if (! process_restart(cinfo))
+ return FALSE;
+ }
+
+ /* If we've run out of data, just leave the MCU set to zeroes.
+ * This way, we return uniform gray for the remainder of the segment.
+ */
+ if (! entropy->pub.insufficient_data) {
+
+ /* Load up working state */
+ BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
+ ASSIGN_STATE(state, entropy->saved);
+
+ /* Outer loop handles each block in the MCU */
+
+ for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+ block = MCU_data[blkn];
+ ci = cinfo->MCU_membership[blkn];
+ compptr = cinfo->cur_comp_info[ci];
+ tbl = entropy->derived_tbls[compptr->dc_tbl_no];
+
+ /* Decode a single block's worth of coefficients */
+
+ /* Section F.2.2.1: decode the DC coefficient difference */
+ HUFF_DECODE(s, br_state, tbl, return FALSE, label1);
+ if (s) {
+ CHECK_BIT_BUFFER(br_state, s, return FALSE);
+ r = GET_BITS(s);
+ s = HUFF_EXTEND(r, s);
+ }
+
+ /* Convert DC difference to actual value, update last_dc_val */
+ s += state.last_dc_val[ci];
+ state.last_dc_val[ci] = s;
+ /* Scale and output the coefficient (assumes jpeg_natural_order[0]=0) */
+ (*block)[0] = (JCOEF) (s << Al);
+ }
+
+ /* Completed MCU, so update state */
+ BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
+ ASSIGN_STATE(entropy->saved, state);
+ }
+
+ /* Account for restart interval (no-op if not using restarts) */
+ entropy->restarts_to_go--;
+
+ return TRUE;
+}
+
+
+/*
+ * MCU decoding for AC initial scan (either spectral selection,
+ * or first pass of successive approximation).
+ */
+
+METHODDEF(boolean)
+decode_mcu_AC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+ phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+ int Se = cinfo->Se;
+ int Al = cinfo->Al;
+ register int s, k, r;
+ unsigned int EOBRUN;
+ JBLOCKROW block;
+ BITREAD_STATE_VARS;
+ d_derived_tbl * tbl;
+
+ /* Process restart marker if needed; may have to suspend */
+ if (cinfo->restart_interval) {
+ if (entropy->restarts_to_go == 0)
+ if (! process_restart(cinfo))
+ return FALSE;
+ }
+
+ /* If we've run out of data, just leave the MCU set to zeroes.
+ * This way, we return uniform gray for the remainder of the segment.
+ */
+ if (! entropy->pub.insufficient_data) {
+
+ /* Load up working state.
+ * We can avoid loading/saving bitread state if in an EOB run.
+ */
+ EOBRUN = entropy->saved.EOBRUN; /* only part of saved state we need */
+
+ /* There is always only one block per MCU */
+
+ if (EOBRUN > 0) /* if it's a band of zeroes... */
+ EOBRUN--; /* ...process it now (we do nothing) */
+ else {
+ BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
+ block = MCU_data[0];
+ tbl = entropy->ac_derived_tbl;
+
+ for (k = cinfo->Ss; k <= Se; k++) {
+ HUFF_DECODE(s, br_state, tbl, return FALSE, label2);
+ r = s >> 4;
+ s &= 15;
+ if (s) {
+ k += r;
+ CHECK_BIT_BUFFER(br_state, s, return FALSE);
+ r = GET_BITS(s);
+ s = HUFF_EXTEND(r, s);
+ /* Scale and output coefficient in natural (dezigzagged) order */
+ (*block)[jpeg_natural_order[k]] = (JCOEF) (s << Al);
+ } else {
+ if (r == 15) { /* ZRL */
+ k += 15; /* skip 15 zeroes in band */
+ } else { /* EOBr, run length is 2^r + appended bits */
+ EOBRUN = 1 << r;
+ if (r) { /* EOBr, r > 0 */
+ CHECK_BIT_BUFFER(br_state, r, return FALSE);
+ r = GET_BITS(r);
+ EOBRUN += r;
+ }
+ EOBRUN--; /* this band is processed at this moment */
+ break; /* force end-of-band */
+ }
+ }
+ }
+
+ BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
+ }
+
+ /* Completed MCU, so update state */
+ entropy->saved.EOBRUN = EOBRUN; /* only part of saved state we need */
+ }
+
+ /* Account for restart interval (no-op if not using restarts) */
+ entropy->restarts_to_go--;
+
+ return TRUE;
+}
+
+
+/*
+ * MCU decoding for DC successive approximation refinement scan.
+ * Note: we assume such scans can be multi-component, although the spec
+ * is not very clear on the point.
+ */
+
+METHODDEF(boolean)
+decode_mcu_DC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+ phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+ int p1 = 1 << cinfo->Al; /* 1 in the bit position being coded */
+ int blkn;
+ JBLOCKROW block;
+ BITREAD_STATE_VARS;
+
+ /* Process restart marker if needed; may have to suspend */
+ if (cinfo->restart_interval) {
+ if (entropy->restarts_to_go == 0)
+ if (! process_restart(cinfo))
+ return FALSE;
+ }
+
+ /* Not worth the cycles to check insufficient_data here,
+ * since we will not change the data anyway if we read zeroes.
+ */
+
+ /* Load up working state */
+ BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
+
+ /* Outer loop handles each block in the MCU */
+
+ for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+ block = MCU_data[blkn];
+
+ /* Encoded data is simply the next bit of the two's-complement DC value */
+ CHECK_BIT_BUFFER(br_state, 1, return FALSE);
+ if (GET_BITS(1))
+ (*block)[0] |= p1;
+ /* Note: since we use |=, repeating the assignment later is safe */
+ }
+
+ /* Completed MCU, so update state */
+ BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
+
+ /* Account for restart interval (no-op if not using restarts) */
+ entropy->restarts_to_go--;
+
+ return TRUE;
+}
+
+
+/*
+ * MCU decoding for AC successive approximation refinement scan.
+ */
+
+METHODDEF(boolean)
+decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+ phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+ int Se = cinfo->Se;
+ int p1 = 1 << cinfo->Al; /* 1 in the bit position being coded */
+ int m1 = (-1) << cinfo->Al; /* -1 in the bit position being coded */
+ register int s, k, r;
+ unsigned int EOBRUN;
+ JBLOCKROW block;
+ JCOEFPTR thiscoef;
+ BITREAD_STATE_VARS;
+ d_derived_tbl * tbl;
+ int num_newnz;
+ int newnz_pos[DCTSIZE2];
+
+ /* Process restart marker if needed; may have to suspend */
+ if (cinfo->restart_interval) {
+ if (entropy->restarts_to_go == 0)
+ if (! process_restart(cinfo))
+ return FALSE;
+ }
+
+ /* If we've run out of data, don't modify the MCU.
+ */
+ if (! entropy->pub.insufficient_data) {
+
+ /* Load up working state */
+ BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
+ EOBRUN = entropy->saved.EOBRUN; /* only part of saved state we need */
+
+ /* There is always only one block per MCU */
+ block = MCU_data[0];
+ tbl = entropy->ac_derived_tbl;
+
+ /* If we are forced to suspend, we must undo the assignments to any newly
+ * nonzero coefficients in the block, because otherwise we'd get confused
+ * next time about which coefficients were already nonzero.
+ * But we need not undo addition of bits to already-nonzero coefficients;
+ * instead, we can test the current bit to see if we already did it.
+ */
+ num_newnz = 0;
+
+ /* initialize coefficient loop counter to start of band */
+ k = cinfo->Ss;
+
+ if (EOBRUN == 0) {
+ for (; k <= Se; k++) {
+ HUFF_DECODE(s, br_state, tbl, goto undoit, label3);
+ r = s >> 4;
+ s &= 15;
+ if (s) {
+ if (s != 1) /* size of new coef should always be 1 */
+ WARNMS(cinfo, JWRN_HUFF_BAD_CODE);
+ CHECK_BIT_BUFFER(br_state, 1, goto undoit);
+ if (GET_BITS(1))
+ s = p1; /* newly nonzero coef is positive */
+ else
+ s = m1; /* newly nonzero coef is negative */
+ } else {
+ if (r != 15) {
+ EOBRUN = 1 << r; /* EOBr, run length is 2^r + appended bits */
+ if (r) {
+ CHECK_BIT_BUFFER(br_state, r, goto undoit);
+ r = GET_BITS(r);
+ EOBRUN += r;
+ }
+ break; /* rest of block is handled by EOB logic */
+ }
+ /* note s = 0 for processing ZRL */
+ }
+ /* Advance over already-nonzero coefs and r still-zero coefs,
+ * appending correction bits to the nonzeroes. A correction bit is 1
+ * if the absolute value of the coefficient must be increased.
+ */
+ do {
+ thiscoef = *block + jpeg_natural_order[k];
+ if (*thiscoef != 0) {
+ CHECK_BIT_BUFFER(br_state, 1, goto undoit);
+ if (GET_BITS(1)) {
+ if ((*thiscoef & p1) == 0) { /* do nothing if already set it */
+ if (*thiscoef >= 0)
+ *thiscoef += p1;
+ else
+ *thiscoef += m1;
+ }
+ }
+ } else {
+ if (--r < 0)
+ break; /* reached target zero coefficient */
+ }
+ k++;
+ } while (k <= Se);
+ if (s) {
+ int pos = jpeg_natural_order[k];
+ /* Output newly nonzero coefficient */
+ (*block)[pos] = (JCOEF) s;
+ /* Remember its position in case we have to suspend */
+ newnz_pos[num_newnz++] = pos;
+ }
+ }
+ }
+
+ if (EOBRUN > 0) {
+ /* Scan any remaining coefficient positions after the end-of-band
+ * (the last newly nonzero coefficient, if any). Append a correction
+ * bit to each already-nonzero coefficient. A correction bit is 1
+ * if the absolute value of the coefficient must be increased.
+ */
+ for (; k <= Se; k++) {
+ thiscoef = *block + jpeg_natural_order[k];
+ if (*thiscoef != 0) {
+ CHECK_BIT_BUFFER(br_state, 1, goto undoit);
+ if (GET_BITS(1)) {
+ if ((*thiscoef & p1) == 0) { /* do nothing if already changed it */
+ if (*thiscoef >= 0)
+ *thiscoef += p1;
+ else
+ *thiscoef += m1;
+ }
+ }
+ }
+ }
+ /* Count one block completed in EOB run */
+ EOBRUN--;
+ }
+
+ /* Completed MCU, so update state */
+ BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
+ entropy->saved.EOBRUN = EOBRUN; /* only part of saved state we need */
+ }
+
+ /* Account for restart interval (no-op if not using restarts) */
+ entropy->restarts_to_go--;
+
+ return TRUE;
+
+undoit:
+ /* Re-zero any output coefficients that we made newly nonzero */
+ while (num_newnz > 0)
+ (*block)[newnz_pos[--num_newnz]] = 0;
+
+ return FALSE;
+}
+
+
+/*
+ * Module initialization routine for progressive Huffman entropy decoding.
+ */
+
+GLOBAL(void)
+jinit_phuff_decoder (j_decompress_ptr cinfo)
+{
+ phuff_entropy_ptr entropy;
+ int *coef_bit_ptr;
+ int ci, i;
+
+ entropy = (phuff_entropy_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(phuff_entropy_decoder));
+ cinfo->entropy = (struct jpeg_entropy_decoder *) entropy;
+ entropy->pub.start_pass = start_pass_phuff_decoder;
+
+ /* Mark derived tables unallocated */
+ for (i = 0; i < NUM_HUFF_TBLS; i++) {
+ entropy->derived_tbls[i] = NULL;
+ }
+
+ /* Create progression status table */
+ cinfo->coef_bits = (int (*)[DCTSIZE2])
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ cinfo->num_components*DCTSIZE2*SIZEOF(int));
+ coef_bit_ptr = & cinfo->coef_bits[0][0];
+ for (ci = 0; ci < cinfo->num_components; ci++)
+ for (i = 0; i < DCTSIZE2; i++)
+ *coef_bit_ptr++ = -1;
+}
+
+#endif /* D_PROGRESSIVE_SUPPORTED */
--- /dev/null
+/*
+ * jdpostct.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * 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 the decompression postprocessing controller.
+ * This controller manages the upsampling, color conversion, and color
+ * quantization/reduction steps; specifically, it controls the buffering
+ * between upsample/color conversion and color quantization/reduction.
+ *
+ * If no color quantization/reduction is required, then this module has no
+ * work to do, and it just hands off to the upsample/color conversion code.
+ * An integrated upsample/convert/quantize process would replace this module
+ * entirely.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private buffer controller object */
+
+typedef struct {
+ struct jpeg_d_post_controller pub; /* public fields */
+
+ /* Color quantization source buffer: this holds output data from
+ * the upsample/color conversion step to be passed to the quantizer.
+ * For two-pass color quantization, we need a full-image buffer;
+ * for one-pass operation, a strip buffer is sufficient.
+ */
+ jvirt_sarray_ptr whole_image; /* virtual array, or NULL if one-pass */
+ JSAMPARRAY buffer; /* strip buffer, or current strip of virtual */
+ JDIMENSION strip_height; /* buffer size in rows */
+ /* for two-pass mode only: */
+ JDIMENSION starting_row; /* row # of first row in current strip */
+ JDIMENSION next_row; /* index of next row to fill/empty in strip */
+} my_post_controller;
+
+typedef my_post_controller * my_post_ptr;
+
+
+/* Forward declarations */
+METHODDEF(void) post_process_1pass
+ JPP((j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+ JDIMENSION in_row_groups_avail,
+ JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail));
+#ifdef QUANT_2PASS_SUPPORTED
+METHODDEF(void) post_process_prepass
+ JPP((j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+ JDIMENSION in_row_groups_avail,
+ JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail));
+METHODDEF(void) post_process_2pass
+ JPP((j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+ JDIMENSION in_row_groups_avail,
+ JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail));
+#endif
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF(void)
+start_pass_dpost (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+ my_post_ptr post = (my_post_ptr) cinfo->post;
+
+ switch (pass_mode) {
+ case JBUF_PASS_THRU:
+ if (cinfo->quantize_colors) {
+ /* Single-pass processing with color quantization. */
+ post->pub.post_process_data = post_process_1pass;
+ /* We could be doing buffered-image output before starting a 2-pass
+ * color quantization; in that case, jinit_d_post_controller did not
+ * allocate a strip buffer. Use the virtual-array buffer as workspace.
+ */
+ if (post->buffer == NULL) {
+ post->buffer = (*cinfo->mem->access_virt_sarray)
+ ((j_common_ptr) cinfo, post->whole_image,
+ (JDIMENSION) 0, post->strip_height, TRUE);
+ }
+ } else {
+ /* For single-pass processing without color quantization,
+ * I have no work to do; just call the upsampler directly.
+ */
+ post->pub.post_process_data = cinfo->upsample->upsample;
+ }
+ break;
+#ifdef QUANT_2PASS_SUPPORTED
+ case JBUF_SAVE_AND_PASS:
+ /* First pass of 2-pass quantization */
+ if (post->whole_image == NULL)
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+ post->pub.post_process_data = post_process_prepass;
+ break;
+ case JBUF_CRANK_DEST:
+ /* Second pass of 2-pass quantization */
+ if (post->whole_image == NULL)
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+ post->pub.post_process_data = post_process_2pass;
+ break;
+#endif /* QUANT_2PASS_SUPPORTED */
+ default:
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+ break;
+ }
+ post->starting_row = post->next_row = 0;
+}
+
+
+/*
+ * Process some data in the one-pass (strip buffer) case.
+ * This is used for color precision reduction as well as one-pass quantization.
+ */
+
+METHODDEF(void)
+post_process_1pass (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+ JDIMENSION in_row_groups_avail,
+ JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail)
+{
+ my_post_ptr post = (my_post_ptr) cinfo->post;
+ JDIMENSION num_rows, max_rows;
+
+ /* Fill the buffer, but not more than what we can dump out in one go. */
+ /* Note we rely on the upsampler to detect bottom of image. */
+ max_rows = out_rows_avail - *out_row_ctr;
+ if (max_rows > post->strip_height)
+ max_rows = post->strip_height;
+ num_rows = 0;
+ (*cinfo->upsample->upsample) (cinfo,
+ input_buf, in_row_group_ctr, in_row_groups_avail,
+ post->buffer, &num_rows, max_rows);
+ /* Quantize and emit data. */
+ (*cinfo->cquantize->color_quantize) (cinfo,
+ post->buffer, output_buf + *out_row_ctr, (int) num_rows);
+ *out_row_ctr += num_rows;
+}
+
+
+#ifdef QUANT_2PASS_SUPPORTED
+
+/*
+ * Process some data in the first pass of 2-pass quantization.
+ */
+
+METHODDEF(void)
+post_process_prepass (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+ JDIMENSION in_row_groups_avail,
+ JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail)
+{
+ my_post_ptr post = (my_post_ptr) cinfo->post;
+ JDIMENSION old_next_row, num_rows;
+
+ /* Reposition virtual buffer if at start of strip. */
+ if (post->next_row == 0) {
+ post->buffer = (*cinfo->mem->access_virt_sarray)
+ ((j_common_ptr) cinfo, post->whole_image,
+ post->starting_row, post->strip_height, TRUE);
+ }
+
+ /* Upsample some data (up to a strip height's worth). */
+ old_next_row = post->next_row;
+ (*cinfo->upsample->upsample) (cinfo,
+ input_buf, in_row_group_ctr, in_row_groups_avail,
+ post->buffer, &post->next_row, post->strip_height);
+
+ /* Allow quantizer to scan new data. No data is emitted, */
+ /* but we advance out_row_ctr so outer loop can tell when we're done. */
+ if (post->next_row > old_next_row) {
+ num_rows = post->next_row - old_next_row;
+ (*cinfo->cquantize->color_quantize) (cinfo, post->buffer + old_next_row,
+ (JSAMPARRAY) NULL, (int) num_rows);
+ *out_row_ctr += num_rows;
+ }
+
+ /* Advance if we filled the strip. */
+ if (post->next_row >= post->strip_height) {
+ post->starting_row += post->strip_height;
+ post->next_row = 0;
+ }
+}
+
+
+/*
+ * Process some data in the second pass of 2-pass quantization.
+ */
+
+METHODDEF(void)
+post_process_2pass (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+ JDIMENSION in_row_groups_avail,
+ JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail)
+{
+ my_post_ptr post = (my_post_ptr) cinfo->post;
+ JDIMENSION num_rows, max_rows;
+
+ /* Reposition virtual buffer if at start of strip. */
+ if (post->next_row == 0) {
+ post->buffer = (*cinfo->mem->access_virt_sarray)
+ ((j_common_ptr) cinfo, post->whole_image,
+ post->starting_row, post->strip_height, FALSE);
+ }
+
+ /* Determine number of rows to emit. */
+ num_rows = post->strip_height - post->next_row; /* available in strip */
+ max_rows = out_rows_avail - *out_row_ctr; /* available in output area */
+ if (num_rows > max_rows)
+ num_rows = max_rows;
+ /* We have to check bottom of image here, can't depend on upsampler. */
+ max_rows = cinfo->output_height - post->starting_row;
+ if (num_rows > max_rows)
+ num_rows = max_rows;
+
+ /* Quantize and emit data. */
+ (*cinfo->cquantize->color_quantize) (cinfo,
+ post->buffer + post->next_row, output_buf + *out_row_ctr,
+ (int) num_rows);
+ *out_row_ctr += num_rows;
+
+ /* Advance if we filled the strip. */
+ post->next_row += num_rows;
+ if (post->next_row >= post->strip_height) {
+ post->starting_row += post->strip_height;
+ post->next_row = 0;
+ }
+}
+
+#endif /* QUANT_2PASS_SUPPORTED */
+
+
+/*
+ * Initialize postprocessing controller.
+ */
+
+GLOBAL(void)
+jinit_d_post_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
+{
+ my_post_ptr post;
+
+ post = (my_post_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_post_controller));
+ cinfo->post = (struct jpeg_d_post_controller *) post;
+ post->pub.start_pass = start_pass_dpost;
+ post->whole_image = NULL; /* flag for no virtual arrays */
+ post->buffer = NULL; /* flag for no strip buffer */
+
+ /* Create the quantization buffer, if needed */
+ if (cinfo->quantize_colors) {
+ /* The buffer strip height is max_v_samp_factor, which is typically
+ * an efficient number of rows for upsampling to return.
+ * (In the presence of output rescaling, we might want to be smarter?)
+ */
+ post->strip_height = (JDIMENSION) cinfo->max_v_samp_factor;
+ if (need_full_buffer) {
+ /* Two-pass color quantization: need full-image storage. */
+ /* We round up the number of rows to a multiple of the strip height. */
+#ifdef QUANT_2PASS_SUPPORTED
+ post->whole_image = (*cinfo->mem->request_virt_sarray)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
+ cinfo->output_width * cinfo->out_color_components,
+ (JDIMENSION) jround_up((long) cinfo->output_height,
+ (long) post->strip_height),
+ post->strip_height);
+#else
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+#endif /* QUANT_2PASS_SUPPORTED */
+ } else {
+ /* One-pass color quantization: just make a strip buffer. */
+ post->buffer = (*cinfo->mem->alloc_sarray)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ cinfo->output_width * cinfo->out_color_components,
+ post->strip_height);
+ }
+ }
+}
--- /dev/null
+/*
+ * jdsample.c
+ *
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * 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 upsampling routines.
+ *
+ * Upsampling input data is counted in "row groups". A row group
+ * is defined to be (v_samp_factor * DCT_scaled_size / min_DCT_scaled_size)
+ * sample rows of each component. Upsampling will normally produce
+ * max_v_samp_factor pixel rows from each row group (but this could vary
+ * if the upsampler is applying a scale factor of its own).
+ *
+ * An excellent reference for image resampling is
+ * Digital Image Warping, George Wolberg, 1990.
+ * Pub. by IEEE Computer Society Press, Los Alamitos, CA. ISBN 0-8186-8944-7.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Pointer to routine to upsample a single component */
+typedef JMETHOD(void, upsample1_ptr,
+ (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr));
+
+/* Private subobject */
+
+typedef struct {
+ struct jpeg_upsampler pub; /* public fields */
+
+ /* Color conversion buffer. When using separate upsampling and color
+ * conversion steps, this buffer holds one upsampled row group until it
+ * has been color converted and output.
+ * Note: we do not allocate any storage for component(s) which are full-size,
+ * ie do not need rescaling. The corresponding entry of color_buf[] is
+ * simply set to point to the input data array, thereby avoiding copying.
+ */
+ JSAMPARRAY color_buf[MAX_COMPONENTS];
+
+ /* Per-component upsampling method pointers */
+ upsample1_ptr methods[MAX_COMPONENTS];
+
+ int next_row_out; /* counts rows emitted from color_buf */
+ JDIMENSION rows_to_go; /* counts rows remaining in image */
+
+ /* Height of an input row group for each component. */
+ int rowgroup_height[MAX_COMPONENTS];
+
+ /* These arrays save pixel expansion factors so that int_expand need not
+ * recompute them each time. They are unused for other upsampling methods.
+ */
+ UINT8 h_expand[MAX_COMPONENTS];
+ UINT8 v_expand[MAX_COMPONENTS];
+} my_upsampler;
+
+typedef my_upsampler * my_upsample_ptr;
+
+
+/*
+ * Initialize for an upsampling pass.
+ */
+
+METHODDEF(void)
+start_pass_upsample (j_decompress_ptr cinfo)
+{
+ my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
+
+ /* Mark the conversion buffer empty */
+ upsample->next_row_out = cinfo->max_v_samp_factor;
+ /* Initialize total-height counter for detecting bottom of image */
+ upsample->rows_to_go = cinfo->output_height;
+}
+
+
+/*
+ * Control routine to do upsampling (and color conversion).
+ *
+ * In this version we upsample each component independently.
+ * We upsample one row group into the conversion buffer, then apply
+ * color conversion a row at a time.
+ */
+
+METHODDEF(void)
+sep_upsample (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+ JDIMENSION in_row_groups_avail,
+ JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail)
+{
+ my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
+ int ci;
+ jpeg_component_info * compptr;
+ JDIMENSION num_rows;
+
+ /* Fill the conversion buffer, if it's empty */
+ if (upsample->next_row_out >= cinfo->max_v_samp_factor) {
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ /* Invoke per-component upsample method. Notice we pass a POINTER
+ * to color_buf[ci], so that fullsize_upsample can change it.
+ */
+ (*upsample->methods[ci]) (cinfo, compptr,
+ input_buf[ci] + (*in_row_group_ctr * upsample->rowgroup_height[ci]),
+ upsample->color_buf + ci);
+ }
+ upsample->next_row_out = 0;
+ }
+
+ /* Color-convert and emit rows */
+
+ /* How many we have in the buffer: */
+ num_rows = (JDIMENSION) (cinfo->max_v_samp_factor - upsample->next_row_out);
+ /* Not more than the distance to the end of the image. Need this test
+ * in case the image height is not a multiple of max_v_samp_factor:
+ */
+ if (num_rows > upsample->rows_to_go)
+ num_rows = upsample->rows_to_go;
+ /* And not more than what the client can accept: */
+ out_rows_avail -= *out_row_ctr;
+ if (num_rows > out_rows_avail)
+ num_rows = out_rows_avail;
+
+ (*cinfo->cconvert->color_convert) (cinfo, upsample->color_buf,
+ (JDIMENSION) upsample->next_row_out,
+ output_buf + *out_row_ctr,
+ (int) num_rows);
+
+ /* Adjust counts */
+ *out_row_ctr += num_rows;
+ upsample->rows_to_go -= num_rows;
+ upsample->next_row_out += num_rows;
+ /* When the buffer is emptied, declare this input row group consumed */
+ if (upsample->next_row_out >= cinfo->max_v_samp_factor)
+ (*in_row_group_ctr)++;
+}
+
+
+/*
+ * These are the routines invoked by sep_upsample to upsample pixel values
+ * of a single component. One row group is processed per call.
+ */
+
+
+/*
+ * For full-size components, we just make color_buf[ci] point at the
+ * input buffer, and thus avoid copying any data. Note that this is
+ * safe only because sep_upsample doesn't declare the input row group
+ * "consumed" until we are done color converting and emitting it.
+ */
+
+METHODDEF(void)
+fullsize_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+{
+ *output_data_ptr = input_data;
+}
+
+
+/*
+ * This is a no-op version used for "uninteresting" components.
+ * These components will not be referenced by color conversion.
+ */
+
+METHODDEF(void)
+noop_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+{
+ *output_data_ptr = NULL; /* safety check */
+}
+
+
+/*
+ * This version handles any integral sampling ratios.
+ * This is not used for typical JPEG files, so it need not be fast.
+ * Nor, for that matter, is it particularly accurate: the algorithm is
+ * simple replication of the input pixel onto the corresponding output
+ * pixels. The hi-falutin sampling literature refers to this as a
+ * "box filter". A box filter tends to introduce visible artifacts,
+ * so if you are actually going to use 3:1 or 4:1 sampling ratios
+ * you would be well advised to improve this code.
+ */
+
+METHODDEF(void)
+int_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+{
+ my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
+ JSAMPARRAY output_data = *output_data_ptr;
+ register JSAMPROW inptr, outptr;
+ register JSAMPLE invalue;
+ register int h;
+ JSAMPROW outend;
+ int h_expand, v_expand;
+ int inrow, outrow;
+
+ h_expand = upsample->h_expand[compptr->component_index];
+ v_expand = upsample->v_expand[compptr->component_index];
+
+ inrow = outrow = 0;
+ while (outrow < cinfo->max_v_samp_factor) {
+ /* Generate one output row with proper horizontal expansion */
+ inptr = input_data[inrow];
+ outptr = output_data[outrow];
+ outend = outptr + cinfo->output_width;
+ while (outptr < outend) {
+ invalue = *inptr++; /* don't need GETJSAMPLE() here */
+ for (h = h_expand; h > 0; h--) {
+ *outptr++ = invalue;
+ }
+ }
+ /* Generate any additional output rows by duplicating the first one */
+ if (v_expand > 1) {
+ jcopy_sample_rows(output_data, outrow, output_data, outrow+1,
+ v_expand-1, cinfo->output_width);
+ }
+ inrow++;
+ outrow += v_expand;
+ }
+}
+
+
+/*
+ * Fast processing for the common case of 2:1 horizontal and 1:1 vertical.
+ * It's still a box filter.
+ */
+
+METHODDEF(void)
+h2v1_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+{
+ JSAMPARRAY output_data = *output_data_ptr;
+ register JSAMPROW inptr, outptr;
+ register JSAMPLE invalue;
+ JSAMPROW outend;
+ int inrow;
+
+ for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) {
+ inptr = input_data[inrow];
+ outptr = output_data[inrow];
+ outend = outptr + cinfo->output_width;
+ while (outptr < outend) {
+ invalue = *inptr++; /* don't need GETJSAMPLE() here */
+ *outptr++ = invalue;
+ *outptr++ = invalue;
+ }
+ }
+}
+
+
+/*
+ * Fast processing for the common case of 2:1 horizontal and 2:1 vertical.
+ * It's still a box filter.
+ */
+
+METHODDEF(void)
+h2v2_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+{
+ JSAMPARRAY output_data = *output_data_ptr;
+ register JSAMPROW inptr, outptr;
+ register JSAMPLE invalue;
+ JSAMPROW outend;
+ int inrow, outrow;
+
+ inrow = outrow = 0;
+ while (outrow < cinfo->max_v_samp_factor) {
+ inptr = input_data[inrow];
+ outptr = output_data[outrow];
+ outend = outptr + cinfo->output_width;
+ while (outptr < outend) {
+ invalue = *inptr++; /* don't need GETJSAMPLE() here */
+ *outptr++ = invalue;
+ *outptr++ = invalue;
+ }
+ jcopy_sample_rows(output_data, outrow, output_data, outrow+1,
+ 1, cinfo->output_width);
+ inrow++;
+ outrow += 2;
+ }
+}
+
+
+/*
+ * Fancy processing for the common case of 2:1 horizontal and 1:1 vertical.
+ *
+ * The upsampling algorithm is linear interpolation between pixel centers,
+ * also known as a "triangle filter". This is a good compromise between
+ * speed and visual quality. The centers of the output pixels are 1/4 and 3/4
+ * of the way between input pixel centers.
+ *
+ * A note about the "bias" calculations: when rounding fractional values to
+ * integer, we do not want to always round 0.5 up to the next integer.
+ * If we did that, we'd introduce a noticeable bias towards larger values.
+ * Instead, this code is arranged so that 0.5 will be rounded up or down at
+ * alternate pixel locations (a simple ordered dither pattern).
+ */
+
+METHODDEF(void)
+h2v1_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+{
+ JSAMPARRAY output_data = *output_data_ptr;
+ register JSAMPROW inptr, outptr;
+ register int invalue;
+ register JDIMENSION colctr;
+ int inrow;
+
+ for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) {
+ inptr = input_data[inrow];
+ outptr = output_data[inrow];
+ /* Special case for first column */
+ invalue = GETJSAMPLE(*inptr++);
+ *outptr++ = (JSAMPLE) invalue;
+ *outptr++ = (JSAMPLE) ((invalue * 3 + GETJSAMPLE(*inptr) + 2) >> 2);
+
+ for (colctr = compptr->downsampled_width - 2; colctr > 0; colctr--) {
+ /* General case: 3/4 * nearer pixel + 1/4 * further pixel */
+ invalue = GETJSAMPLE(*inptr++) * 3;
+ *outptr++ = (JSAMPLE) ((invalue + GETJSAMPLE(inptr[-2]) + 1) >> 2);
+ *outptr++ = (JSAMPLE) ((invalue + GETJSAMPLE(*inptr) + 2) >> 2);
+ }
+
+ /* Special case for last column */
+ invalue = GETJSAMPLE(*inptr);
+ *outptr++ = (JSAMPLE) ((invalue * 3 + GETJSAMPLE(inptr[-1]) + 1) >> 2);
+ *outptr++ = (JSAMPLE) invalue;
+ }
+}
+
+
+/*
+ * Fancy processing for the common case of 2:1 horizontal and 2:1 vertical.
+ * Again a triangle filter; see comments for h2v1 case, above.
+ *
+ * It is OK for us to reference the adjacent input rows because we demanded
+ * context from the main buffer controller (see initialization code).
+ */
+
+METHODDEF(void)
+h2v2_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+{
+ JSAMPARRAY output_data = *output_data_ptr;
+ register JSAMPROW inptr0, inptr1, outptr;
+#if BITS_IN_JSAMPLE == 8
+ register int thiscolsum, lastcolsum, nextcolsum;
+#else
+ register INT32 thiscolsum, lastcolsum, nextcolsum;
+#endif
+ register JDIMENSION colctr;
+ int inrow, outrow, v;
+
+ inrow = outrow = 0;
+ while (outrow < cinfo->max_v_samp_factor) {
+ for (v = 0; v < 2; v++) {
+ /* inptr0 points to nearest input row, inptr1 points to next nearest */
+ inptr0 = input_data[inrow];
+ if (v == 0) /* next nearest is row above */
+ inptr1 = input_data[inrow-1];
+ else /* next nearest is row below */
+ inptr1 = input_data[inrow+1];
+ outptr = output_data[outrow++];
+
+ /* Special case for first column */
+ thiscolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++);
+ nextcolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++);
+ *outptr++ = (JSAMPLE) ((thiscolsum * 4 + 8) >> 4);
+ *outptr++ = (JSAMPLE) ((thiscolsum * 3 + nextcolsum + 7) >> 4);
+ lastcolsum = thiscolsum; thiscolsum = nextcolsum;
+
+ for (colctr = compptr->downsampled_width - 2; colctr > 0; colctr--) {
+ /* General case: 3/4 * nearer pixel + 1/4 * further pixel in each */
+ /* dimension, thus 9/16, 3/16, 3/16, 1/16 overall */
+ nextcolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++);
+ *outptr++ = (JSAMPLE) ((thiscolsum * 3 + lastcolsum + 8) >> 4);
+ *outptr++ = (JSAMPLE) ((thiscolsum * 3 + nextcolsum + 7) >> 4);
+ lastcolsum = thiscolsum; thiscolsum = nextcolsum;
+ }
+
+ /* Special case for last column */
+ *outptr++ = (JSAMPLE) ((thiscolsum * 3 + lastcolsum + 8) >> 4);
+ *outptr++ = (JSAMPLE) ((thiscolsum * 4 + 7) >> 4);
+ }
+ inrow++;
+ }
+}
+
+
+/*
+ * Module initialization routine for upsampling.
+ */
+
+GLOBAL(void)
+jinit_upsampler (j_decompress_ptr cinfo)
+{
+ my_upsample_ptr upsample;
+ int ci;
+ jpeg_component_info * compptr;
+ boolean need_buffer, do_fancy;
+ int h_in_group, v_in_group, h_out_group, v_out_group;
+
+ upsample = (my_upsample_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_upsampler));
+ cinfo->upsample = (struct jpeg_upsampler *) upsample;
+ upsample->pub.start_pass = start_pass_upsample;
+ upsample->pub.upsample = sep_upsample;
+ upsample->pub.need_context_rows = FALSE; /* until we find out differently */
+
+ if (cinfo->CCIR601_sampling) /* this isn't supported */
+ ERREXIT(cinfo, JERR_CCIR601_NOTIMPL);
+
+ /* jdmainct.c doesn't support context rows when min_DCT_scaled_size = 1,
+ * so don't ask for it.
+ */
+ do_fancy = cinfo->do_fancy_upsampling && cinfo->min_DCT_scaled_size > 1;
+
+ /* Verify we can handle the sampling factors, select per-component methods,
+ * and create storage as needed.
+ */
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ /* Compute size of an "input group" after IDCT scaling. This many samples
+ * are to be converted to max_h_samp_factor * max_v_samp_factor pixels.
+ */
+ h_in_group = (compptr->h_samp_factor * compptr->DCT_scaled_size) /
+ cinfo->min_DCT_scaled_size;
+ v_in_group = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
+ cinfo->min_DCT_scaled_size;
+ h_out_group = cinfo->max_h_samp_factor;
+ v_out_group = cinfo->max_v_samp_factor;
+ upsample->rowgroup_height[ci] = v_in_group; /* save for use later */
+ need_buffer = TRUE;
+ if (! compptr->component_needed) {
+ /* Don't bother to upsample an uninteresting component. */
+ upsample->methods[ci] = noop_upsample;
+ need_buffer = FALSE;
+ } else if (h_in_group == h_out_group && v_in_group == v_out_group) {
+ /* Fullsize components can be processed without any work. */
+ upsample->methods[ci] = fullsize_upsample;
+ need_buffer = FALSE;
+ } else if (h_in_group * 2 == h_out_group &&
+ v_in_group == v_out_group) {
+ /* Special cases for 2h1v upsampling */
+ if (do_fancy && compptr->downsampled_width > 2)
+ upsample->methods[ci] = h2v1_fancy_upsample;
+ else
+ upsample->methods[ci] = h2v1_upsample;
+ } else if (h_in_group * 2 == h_out_group &&
+ v_in_group * 2 == v_out_group) {
+ /* Special cases for 2h2v upsampling */
+ if (do_fancy && compptr->downsampled_width > 2) {
+ upsample->methods[ci] = h2v2_fancy_upsample;
+ upsample->pub.need_context_rows = TRUE;
+ } else
+ upsample->methods[ci] = h2v2_upsample;
+ } else if ((h_out_group % h_in_group) == 0 &&
+ (v_out_group % v_in_group) == 0) {
+ /* Generic integral-factors upsampling method */
+ upsample->methods[ci] = int_upsample;
+ upsample->h_expand[ci] = (UINT8) (h_out_group / h_in_group);
+ upsample->v_expand[ci] = (UINT8) (v_out_group / v_in_group);
+ } else
+ ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL);
+ if (need_buffer) {
+ upsample->color_buf[ci] = (*cinfo->mem->alloc_sarray)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (JDIMENSION) jround_up((long) cinfo->output_width,
+ (long) cinfo->max_h_samp_factor),
+ (JDIMENSION) cinfo->max_v_samp_factor);
+ }
+ }
+}
--- /dev/null
+/*
+ * jdtrans.c
+ *
+ * Copyright (C) 1995-1997, Thomas G. Lane.
+ * 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 library routines for transcoding decompression,
+ * that is, reading raw DCT coefficient arrays from an input JPEG file.
+ * The routines in jdapimin.c will also be needed by a transcoder.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Forward declarations */
+LOCAL(void) transdecode_master_selection JPP((j_decompress_ptr cinfo));
+
+
+/*
+ * Read the coefficient arrays from a JPEG file.
+ * jpeg_read_header must be completed before calling this.
+ *
+ * The entire image is read into a set of virtual coefficient-block arrays,
+ * one per component. The return value is a pointer to the array of
+ * virtual-array descriptors. These can be manipulated directly via the
+ * JPEG memory manager, or handed off to jpeg_write_coefficients().
+ * To release the memory occupied by the virtual arrays, call
+ * jpeg_finish_decompress() when done with the data.
+ *
+ * An alternative usage is to simply obtain access to the coefficient arrays
+ * during a buffered-image-mode decompression operation. This is allowed
+ * after any jpeg_finish_output() call. The arrays can be accessed until
+ * jpeg_finish_decompress() is called. (Note that any call to the library
+ * may reposition the arrays, so don't rely on access_virt_barray() results
+ * to stay valid across library calls.)
+ *
+ * Returns NULL if suspended. This case need be checked only if
+ * a suspending data source is used.
+ */
+
+GLOBAL(jvirt_barray_ptr *)
+jpeg_read_coefficients (j_decompress_ptr cinfo)
+{
+ if (cinfo->global_state == DSTATE_READY) {
+ /* First call: initialize active modules */
+ transdecode_master_selection(cinfo);
+ cinfo->global_state = DSTATE_RDCOEFS;
+ }
+ if (cinfo->global_state == DSTATE_RDCOEFS) {
+ /* Absorb whole file into the coef buffer */
+ for (;;) {
+ int retcode;
+ /* Call progress monitor hook if present */
+ if (cinfo->progress != NULL)
+ (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+ /* Absorb some more input */
+ retcode = (*cinfo->inputctl->consume_input) (cinfo);
+ if (retcode == JPEG_SUSPENDED)
+ return NULL;
+ if (retcode == JPEG_REACHED_EOI)
+ break;
+ /* Advance progress counter if appropriate */
+ if (cinfo->progress != NULL &&
+ (retcode == JPEG_ROW_COMPLETED || retcode == JPEG_REACHED_SOS)) {
+ if (++cinfo->progress->pass_counter >= cinfo->progress->pass_limit) {
+ /* startup underestimated number of scans; ratchet up one scan */
+ cinfo->progress->pass_limit += (long) cinfo->total_iMCU_rows;
+ }
+ }
+ }
+ /* Set state so that jpeg_finish_decompress does the right thing */
+ cinfo->global_state = DSTATE_STOPPING;
+ }
+ /* At this point we should be in state DSTATE_STOPPING if being used
+ * standalone, or in state DSTATE_BUFIMAGE if being invoked to get access
+ * to the coefficients during a full buffered-image-mode decompression.
+ */
+ if ((cinfo->global_state == DSTATE_STOPPING ||
+ cinfo->global_state == DSTATE_BUFIMAGE) && cinfo->buffered_image) {
+ return cinfo->coef->coef_arrays;
+ }
+ /* Oops, improper usage */
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+ return NULL; /* keep compiler happy */
+}
+
+
+/*
+ * Master selection of decompression modules for transcoding.
+ * This substitutes for jdmaster.c's initialization of the full decompressor.
+ */
+
+LOCAL(void)
+transdecode_master_selection (j_decompress_ptr cinfo)
+{
+ /* This is effectively a buffered-image operation. */
+ cinfo->buffered_image = TRUE;
+
+ /* Entropy decoding: either Huffman or arithmetic coding. */
+ if (cinfo->arith_code) {
+ ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
+ } else {
+ if (cinfo->progressive_mode) {
+#ifdef D_PROGRESSIVE_SUPPORTED
+ jinit_phuff_decoder(cinfo);
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+ } else
+ jinit_huff_decoder(cinfo);
+ }
+
+ /* Always get a full-image coefficient buffer. */
+ jinit_d_coef_controller(cinfo, TRUE);
+
+ /* We can now tell the memory manager to allocate virtual arrays. */
+ (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo);
+
+ /* Initialize input side of decompressor to consume first scan. */
+ (*cinfo->inputctl->start_input_pass) (cinfo);
+
+ /* Initialize progress monitoring. */
+ if (cinfo->progress != NULL) {
+ int nscans;
+ /* Estimate number of scans to set pass_limit. */
+ if (cinfo->progressive_mode) {
+ /* Arbitrarily estimate 2 interleaved DC scans + 3 AC scans/component. */
+ nscans = 2 + 3 * cinfo->num_components;
+ } else if (cinfo->inputctl->has_multiple_scans) {
+ /* For a nonprogressive multiscan file, estimate 1 scan per component. */
+ nscans = cinfo->num_components;
+ } else {
+ nscans = 1;
+ }
+ cinfo->progress->pass_counter = 0L;
+ cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows * nscans;
+ cinfo->progress->completed_passes = 0;
+ cinfo->progress->total_passes = 1;
+ }
+}
--- /dev/null
+/*
+ * jerror.c
+ *
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * 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 simple error-reporting and trace-message routines.
+ * These are suitable for Unix-like systems and others where writing to
+ * stderr is the right thing to do. Many applications will want to replace
+ * some or all of these routines.
+ *
+ * If you define USE_WINDOWS_MESSAGEBOX in jconfig.h or in the makefile,
+ * you get a Windows-specific hack to display error messages in a dialog box.
+ * It ain't much, but it beats dropping error messages into the bit bucket,
+ * which is what happens to output to stderr under most Windows C compilers.
+ *
+ * These routines are used by both the compression and decompression code.
+ */
+
+/* this is not a core library module, so it doesn't define JPEG_INTERNALS */
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jversion.h"
+#include "jerror.h"
+
+#ifdef USE_WINDOWS_MESSAGEBOX
+#include <windows.h>
+#endif
+
+#ifndef EXIT_FAILURE /* define exit() codes if not provided */
+#define EXIT_FAILURE 1
+#endif
+
+
+/*
+ * Create the message string table.
+ * We do this from the master message list in jerror.h by re-reading
+ * jerror.h with a suitable definition for macro JMESSAGE.
+ * The message table is made an external symbol just in case any applications
+ * want to refer to it directly.
+ */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_std_message_table jMsgTable
+#endif
+
+#define JMESSAGE(code,string) string ,
+
+const char * const jpeg_std_message_table[] = {
+#include "jerror.h"
+ NULL
+};
+
+
+/*
+ * Error exit handler: must not return to caller.
+ *
+ * Applications may override this if they want to get control back after
+ * an error. Typically one would longjmp somewhere instead of exiting.
+ * The setjmp buffer can be made a private field within an expanded error
+ * handler object. Note that the info needed to generate an error message
+ * is stored in the error object, so you can generate the message now or
+ * later, at your convenience.
+ * You should make sure that the JPEG object is cleaned up (with jpeg_abort
+ * or jpeg_destroy) at some point.
+ */
+
+METHODDEF(void)
+error_exit (j_common_ptr cinfo)
+{
+ /* Always display the message */
+ (*cinfo->err->output_message) (cinfo);
+
+ /* Let the memory manager delete any temp files before we die */
+ jpeg_destroy(cinfo);
+
+ exit(EXIT_FAILURE);
+}
+
+
+/*
+ * Actual output of an error or trace message.
+ * Applications may override this method to send JPEG messages somewhere
+ * other than stderr.
+ *
+ * On Windows, printing to stderr is generally completely useless,
+ * so we provide optional code to produce an error-dialog popup.
+ * Most Windows applications will still prefer to override this routine,
+ * but if they don't, it'll do something at least marginally useful.
+ *
+ * NOTE: to use the library in an environment that doesn't support the
+ * C stdio library, you may have to delete the call to fprintf() entirely,
+ * not just not use this routine.
+ */
+
+METHODDEF(void)
+output_message (j_common_ptr cinfo)
+{
+ char buffer[JMSG_LENGTH_MAX];
+
+ /* Create the message */
+ (*cinfo->err->format_message) (cinfo, buffer);
+
+#ifdef USE_WINDOWS_MESSAGEBOX
+ /* Display it in a message dialog box */
+ MessageBox(GetActiveWindow(), buffer, "JPEG Library Error",
+ MB_OK | MB_ICONERROR);
+#else
+ /* Send it to stderr, adding a newline */
+ fprintf(stderr, "%s\n", buffer);
+#endif
+}
+
+
+/*
+ * Decide whether to emit a trace or warning message.
+ * msg_level is one of:
+ * -1: recoverable corrupt-data warning, may want to abort.
+ * 0: important advisory messages (always display to user).
+ * 1: first level of tracing detail.
+ * 2,3,...: successively more detailed tracing messages.
+ * An application might override this method if it wanted to abort on warnings
+ * or change the policy about which messages to display.
+ */
+
+METHODDEF(void)
+emit_message (j_common_ptr cinfo, int msg_level)
+{
+ struct jpeg_error_mgr * err = cinfo->err;
+
+ if (msg_level < 0) {
+ /* It's a warning message. Since corrupt files may generate many warnings,
+ * the policy implemented here is to show only the first warning,
+ * unless trace_level >= 3.
+ */
+ if (err->num_warnings == 0 || err->trace_level >= 3)
+ (*err->output_message) (cinfo);
+ /* Always count warnings in num_warnings. */
+ err->num_warnings++;
+ } else {
+ /* It's a trace message. Show it if trace_level >= msg_level. */
+ if (err->trace_level >= msg_level)
+ (*err->output_message) (cinfo);
+ }
+}
+
+
+/*
+ * Format a message string for the most recent JPEG error or message.
+ * The message is stored into buffer, which should be at least JMSG_LENGTH_MAX
+ * characters. Note that no '\n' character is added to the string.
+ * Few applications should need to override this method.
+ */
+
+METHODDEF(void)
+format_message (j_common_ptr cinfo, char * buffer)
+{
+ struct jpeg_error_mgr * err = cinfo->err;
+ int msg_code = err->msg_code;
+ const char * msgtext = NULL;
+ const char * msgptr;
+ char ch;
+ boolean isstring;
+
+ /* Look up message string in proper table */
+ if (msg_code > 0 && msg_code <= err->last_jpeg_message) {
+ msgtext = err->jpeg_message_table[msg_code];
+ } else if (err->addon_message_table != NULL &&
+ msg_code >= err->first_addon_message &&
+ msg_code <= err->last_addon_message) {
+ msgtext = err->addon_message_table[msg_code - err->first_addon_message];
+ }
+
+ /* Defend against bogus message number */
+ if (msgtext == NULL) {
+ err->msg_parm.i[0] = msg_code;
+ msgtext = err->jpeg_message_table[0];
+ }
+
+ /* Check for string parameter, as indicated by %s in the message text */
+ isstring = FALSE;
+ msgptr = msgtext;
+ while ((ch = *msgptr++) != '\0') {
+ if (ch == '%') {
+ if (*msgptr == 's') isstring = TRUE;
+ break;
+ }
+ }
+
+ /* Format the message into the passed buffer */
+ if (isstring)
+ sprintf(buffer, msgtext, err->msg_parm.s);
+ else
+ sprintf(buffer, msgtext,
+ err->msg_parm.i[0], err->msg_parm.i[1],
+ err->msg_parm.i[2], err->msg_parm.i[3],
+ err->msg_parm.i[4], err->msg_parm.i[5],
+ err->msg_parm.i[6], err->msg_parm.i[7]);
+}
+
+
+/*
+ * Reset error state variables at start of a new image.
+ * This is called during compression startup to reset trace/error
+ * processing to default state, without losing any application-specific
+ * method pointers. An application might possibly want to override
+ * this method if it has additional error processing state.
+ */
+
+METHODDEF(void)
+reset_error_mgr (j_common_ptr cinfo)
+{
+ cinfo->err->num_warnings = 0;
+ /* trace_level is not reset since it is an application-supplied parameter */
+ cinfo->err->msg_code = 0; /* may be useful as a flag for "no error" */
+}
+
+
+/*
+ * Fill in the standard error-handling methods in a jpeg_error_mgr object.
+ * Typical call is:
+ * struct jpeg_compress_struct cinfo;
+ * struct jpeg_error_mgr err;
+ *
+ * cinfo.err = jpeg_std_error(&err);
+ * after which the application may override some of the methods.
+ */
+
+GLOBAL(struct jpeg_error_mgr *)
+jpeg_std_error (struct jpeg_error_mgr * err)
+{
+ err->error_exit = error_exit;
+ err->emit_message = emit_message;
+ err->output_message = output_message;
+ err->format_message = format_message;
+ err->reset_error_mgr = reset_error_mgr;
+
+ err->trace_level = 0; /* default = no tracing */
+ err->num_warnings = 0; /* no warnings emitted yet */
+ err->msg_code = 0; /* may be useful as a flag for "no error" */
+
+ /* Initialize message table pointers */
+ err->jpeg_message_table = jpeg_std_message_table;
+ err->last_jpeg_message = (int) JMSG_LASTMSGCODE - 1;
+
+ err->addon_message_table = NULL;
+ err->first_addon_message = 0; /* for safety */
+ err->last_addon_message = 0;
+
+ return err;
+}
--- /dev/null
+/*
+ * jerror.h
+ *
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file defines the error and message codes for the JPEG library.
+ * Edit this file to add new codes, or to translate the message strings to
+ * some other language.
+ * A set of error-reporting macros are defined too. Some applications using
+ * the JPEG library may wish to include this file to get the error codes
+ * and/or the macros.
+ */
+
+/*
+ * To define the enum list of message codes, include this file without
+ * defining macro JMESSAGE. To create a message string table, include it
+ * again with a suitable JMESSAGE definition (see jerror.c for an example).
+ */
+#ifndef JMESSAGE
+#ifndef JERROR_H
+/* First time through, define the enum list */
+#define JMAKE_ENUM_LIST
+#else
+/* Repeated inclusions of this file are no-ops unless JMESSAGE is defined */
+#define JMESSAGE(code,string)
+#endif /* JERROR_H */
+#endif /* JMESSAGE */
+
+#ifdef JMAKE_ENUM_LIST
+
+typedef enum {
+
+#define JMESSAGE(code,string) code ,
+
+#endif /* JMAKE_ENUM_LIST */
+
+JMESSAGE(JMSG_NOMESSAGE, "Bogus message code %d") /* Must be first entry! */
+
+/* For maintenance convenience, list is alphabetical by message code name */
+JMESSAGE(JERR_ARITH_NOTIMPL,
+ "Sorry, there are legal restrictions on arithmetic coding")
+JMESSAGE(JERR_BAD_ALIGN_TYPE, "ALIGN_TYPE is wrong, please fix")
+JMESSAGE(JERR_BAD_ALLOC_CHUNK, "MAX_ALLOC_CHUNK is wrong, please fix")
+JMESSAGE(JERR_BAD_BUFFER_MODE, "Bogus buffer control mode")
+JMESSAGE(JERR_BAD_COMPONENT_ID, "Invalid component ID %d in SOS")
+JMESSAGE(JERR_BAD_DCT_COEF, "DCT coefficient out of range")
+JMESSAGE(JERR_BAD_DCTSIZE, "IDCT output block size %d not supported")
+JMESSAGE(JERR_BAD_HUFF_TABLE, "Bogus Huffman table definition")
+JMESSAGE(JERR_BAD_IN_COLORSPACE, "Bogus input colorspace")
+JMESSAGE(JERR_BAD_J_COLORSPACE, "Bogus JPEG colorspace")
+JMESSAGE(JERR_BAD_LENGTH, "Bogus marker length")
+JMESSAGE(JERR_BAD_LIB_VERSION,
+ "Wrong JPEG library version: library is %d, caller expects %d")
+JMESSAGE(JERR_BAD_MCU_SIZE, "Sampling factors too large for interleaved scan")
+JMESSAGE(JERR_BAD_POOL_ID, "Invalid memory pool code %d")
+JMESSAGE(JERR_BAD_PRECISION, "Unsupported JPEG data precision %d")
+JMESSAGE(JERR_BAD_PROGRESSION,
+ "Invalid progressive parameters Ss=%d Se=%d Ah=%d Al=%d")
+JMESSAGE(JERR_BAD_PROG_SCRIPT,
+ "Invalid progressive parameters at scan script entry %d")
+JMESSAGE(JERR_BAD_SAMPLING, "Bogus sampling factors")
+JMESSAGE(JERR_BAD_SCAN_SCRIPT, "Invalid scan script at entry %d")
+JMESSAGE(JERR_BAD_STATE, "Improper call to JPEG library in state %d")
+JMESSAGE(JERR_BAD_STRUCT_SIZE,
+ "JPEG parameter struct mismatch: library thinks size is %u, caller expects %u")
+JMESSAGE(JERR_BAD_VIRTUAL_ACCESS, "Bogus virtual array access")
+JMESSAGE(JERR_BUFFER_SIZE, "Buffer passed to JPEG library is too small")
+JMESSAGE(JERR_CANT_SUSPEND, "Suspension not allowed here")
+JMESSAGE(JERR_CCIR601_NOTIMPL, "CCIR601 sampling not implemented yet")
+JMESSAGE(JERR_COMPONENT_COUNT, "Too many color components: %d, max %d")
+JMESSAGE(JERR_CONVERSION_NOTIMPL, "Unsupported color conversion request")
+JMESSAGE(JERR_DAC_INDEX, "Bogus DAC index %d")
+JMESSAGE(JERR_DAC_VALUE, "Bogus DAC value 0x%x")
+JMESSAGE(JERR_DHT_INDEX, "Bogus DHT index %d")
+JMESSAGE(JERR_DQT_INDEX, "Bogus DQT index %d")
+JMESSAGE(JERR_EMPTY_IMAGE, "Empty JPEG image (DNL not supported)")
+JMESSAGE(JERR_EMS_READ, "Read from EMS failed")
+JMESSAGE(JERR_EMS_WRITE, "Write to EMS failed")
+JMESSAGE(JERR_EOI_EXPECTED, "Didn't expect more than one scan")
+JMESSAGE(JERR_FILE_READ, "Input file read error")
+JMESSAGE(JERR_FILE_WRITE, "Output file write error --- out of disk space?")
+JMESSAGE(JERR_FRACT_SAMPLE_NOTIMPL, "Fractional sampling not implemented yet")
+JMESSAGE(JERR_HUFF_CLEN_OVERFLOW, "Huffman code size table overflow")
+JMESSAGE(JERR_HUFF_MISSING_CODE, "Missing Huffman code table entry")
+JMESSAGE(JERR_IMAGE_TOO_BIG, "Maximum supported image dimension is %u pixels")
+JMESSAGE(JERR_INPUT_EMPTY, "Empty input file")
+JMESSAGE(JERR_INPUT_EOF, "Premature end of input file")
+JMESSAGE(JERR_MISMATCHED_QUANT_TABLE,
+ "Cannot transcode due to multiple use of quantization table %d")
+JMESSAGE(JERR_MISSING_DATA, "Scan script does not transmit all data")
+JMESSAGE(JERR_MODE_CHANGE, "Invalid color quantization mode change")
+JMESSAGE(JERR_NOTIMPL, "Not implemented yet")
+JMESSAGE(JERR_NOT_COMPILED, "Requested feature was omitted at compile time")
+JMESSAGE(JERR_NO_BACKING_STORE, "Backing store not supported")
+JMESSAGE(JERR_NO_HUFF_TABLE, "Huffman table 0x%02x was not defined")
+JMESSAGE(JERR_NO_IMAGE, "JPEG datastream contains no image")
+JMESSAGE(JERR_NO_QUANT_TABLE, "Quantization table 0x%02x was not defined")
+JMESSAGE(JERR_NO_SOI, "Not a JPEG file: starts with 0x%02x 0x%02x")
+JMESSAGE(JERR_OUT_OF_MEMORY, "Insufficient memory (case %d)")
+JMESSAGE(JERR_QUANT_COMPONENTS,
+ "Cannot quantize more than %d color components")
+JMESSAGE(JERR_QUANT_FEW_COLORS, "Cannot quantize to fewer than %d colors")
+JMESSAGE(JERR_QUANT_MANY_COLORS, "Cannot quantize to more than %d colors")
+JMESSAGE(JERR_SOF_DUPLICATE, "Invalid JPEG file structure: two SOF markers")
+JMESSAGE(JERR_SOF_NO_SOS, "Invalid JPEG file structure: missing SOS marker")
+JMESSAGE(JERR_SOF_UNSUPPORTED, "Unsupported JPEG process: SOF type 0x%02x")
+JMESSAGE(JERR_SOI_DUPLICATE, "Invalid JPEG file structure: two SOI markers")
+JMESSAGE(JERR_SOS_NO_SOF, "Invalid JPEG file structure: SOS before SOF")
+JMESSAGE(JERR_TFILE_CREATE, "Failed to create temporary file %s")
+JMESSAGE(JERR_TFILE_READ, "Read failed on temporary file")
+JMESSAGE(JERR_TFILE_SEEK, "Seek failed on temporary file")
+JMESSAGE(JERR_TFILE_WRITE,
+ "Write failed on temporary file --- out of disk space?")
+JMESSAGE(JERR_TOO_LITTLE_DATA, "Application transferred too few scanlines")
+JMESSAGE(JERR_UNKNOWN_MARKER, "Unsupported marker type 0x%02x")
+JMESSAGE(JERR_VIRTUAL_BUG, "Virtual array controller messed up")
+JMESSAGE(JERR_WIDTH_OVERFLOW, "Image too wide for this implementation")
+JMESSAGE(JERR_XMS_READ, "Read from XMS failed")
+JMESSAGE(JERR_XMS_WRITE, "Write to XMS failed")
+JMESSAGE(JMSG_COPYRIGHT, JCOPYRIGHT)
+JMESSAGE(JMSG_VERSION, JVERSION)
+JMESSAGE(JTRC_16BIT_TABLES,
+ "Caution: quantization tables are too coarse for baseline JPEG")
+JMESSAGE(JTRC_ADOBE,
+ "Adobe APP14 marker: version %d, flags 0x%04x 0x%04x, transform %d")
+JMESSAGE(JTRC_APP0, "Unknown APP0 marker (not JFIF), length %u")
+JMESSAGE(JTRC_APP14, "Unknown APP14 marker (not Adobe), length %u")
+JMESSAGE(JTRC_DAC, "Define Arithmetic Table 0x%02x: 0x%02x")
+JMESSAGE(JTRC_DHT, "Define Huffman Table 0x%02x")
+JMESSAGE(JTRC_DQT, "Define Quantization Table %d precision %d")
+JMESSAGE(JTRC_DRI, "Define Restart Interval %u")
+JMESSAGE(JTRC_EMS_CLOSE, "Freed EMS handle %u")
+JMESSAGE(JTRC_EMS_OPEN, "Obtained EMS handle %u")
+JMESSAGE(JTRC_EOI, "End Of Image")
+JMESSAGE(JTRC_HUFFBITS, " %3d %3d %3d %3d %3d %3d %3d %3d")
+JMESSAGE(JTRC_JFIF, "JFIF APP0 marker: version %d.%02d, density %dx%d %d")
+JMESSAGE(JTRC_JFIF_BADTHUMBNAILSIZE,
+ "Warning: thumbnail image size does not match data length %u")
+JMESSAGE(JTRC_JFIF_EXTENSION,
+ "JFIF extension marker: type 0x%02x, length %u")
+JMESSAGE(JTRC_JFIF_THUMBNAIL, " with %d x %d thumbnail image")
+JMESSAGE(JTRC_MISC_MARKER, "Miscellaneous marker 0x%02x, length %u")
+JMESSAGE(JTRC_PARMLESS_MARKER, "Unexpected marker 0x%02x")
+JMESSAGE(JTRC_QUANTVALS, " %4u %4u %4u %4u %4u %4u %4u %4u")
+JMESSAGE(JTRC_QUANT_3_NCOLORS, "Quantizing to %d = %d*%d*%d colors")
+JMESSAGE(JTRC_QUANT_NCOLORS, "Quantizing to %d colors")
+JMESSAGE(JTRC_QUANT_SELECTED, "Selected %d colors for quantization")
+JMESSAGE(JTRC_RECOVERY_ACTION, "At marker 0x%02x, recovery action %d")
+JMESSAGE(JTRC_RST, "RST%d")
+JMESSAGE(JTRC_SMOOTH_NOTIMPL,
+ "Smoothing not supported with nonstandard sampling ratios")
+JMESSAGE(JTRC_SOF, "Start Of Frame 0x%02x: width=%u, height=%u, components=%d")
+JMESSAGE(JTRC_SOF_COMPONENT, " Component %d: %dhx%dv q=%d")
+JMESSAGE(JTRC_SOI, "Start of Image")
+JMESSAGE(JTRC_SOS, "Start Of Scan: %d components")
+JMESSAGE(JTRC_SOS_COMPONENT, " Component %d: dc=%d ac=%d")
+JMESSAGE(JTRC_SOS_PARAMS, " Ss=%d, Se=%d, Ah=%d, Al=%d")
+JMESSAGE(JTRC_TFILE_CLOSE, "Closed temporary file %s")
+JMESSAGE(JTRC_TFILE_OPEN, "Opened temporary file %s")
+JMESSAGE(JTRC_THUMB_JPEG,
+ "JFIF extension marker: JPEG-compressed thumbnail image, length %u")
+JMESSAGE(JTRC_THUMB_PALETTE,
+ "JFIF extension marker: palette thumbnail image, length %u")
+JMESSAGE(JTRC_THUMB_RGB,
+ "JFIF extension marker: RGB thumbnail image, length %u")
+JMESSAGE(JTRC_UNKNOWN_IDS,
+ "Unrecognized component IDs %d %d %d, assuming YCbCr")
+JMESSAGE(JTRC_XMS_CLOSE, "Freed XMS handle %u")
+JMESSAGE(JTRC_XMS_OPEN, "Obtained XMS handle %u")
+JMESSAGE(JWRN_ADOBE_XFORM, "Unknown Adobe color transform code %d")
+JMESSAGE(JWRN_BOGUS_PROGRESSION,
+ "Inconsistent progression sequence for component %d coefficient %d")
+JMESSAGE(JWRN_EXTRANEOUS_DATA,
+ "Corrupt JPEG data: %u extraneous bytes before marker 0x%02x")
+JMESSAGE(JWRN_HIT_MARKER, "Corrupt JPEG data: premature end of data segment")
+JMESSAGE(JWRN_HUFF_BAD_CODE, "Corrupt JPEG data: bad Huffman code")
+JMESSAGE(JWRN_JFIF_MAJOR, "Warning: unknown JFIF revision number %d.%02d")
+JMESSAGE(JWRN_JPEG_EOF, "Premature end of JPEG file")
+JMESSAGE(JWRN_MUST_RESYNC,
+ "Corrupt JPEG data: found marker 0x%02x instead of RST%d")
+JMESSAGE(JWRN_NOT_SEQUENTIAL, "Invalid SOS parameters for sequential JPEG")
+JMESSAGE(JWRN_TOO_MUCH_DATA, "Application transferred too many scanlines")
+
+#ifdef JMAKE_ENUM_LIST
+
+ JMSG_LASTMSGCODE
+} J_MESSAGE_CODE;
+
+#undef JMAKE_ENUM_LIST
+#endif /* JMAKE_ENUM_LIST */
+
+/* Zap JMESSAGE macro so that future re-inclusions do nothing by default */
+#undef JMESSAGE
+
+
+#ifndef JERROR_H
+#define JERROR_H
+
+/* Macros to simplify using the error and trace message stuff */
+/* The first parameter is either type of cinfo pointer */
+
+/* Fatal errors (print message and exit) */
+#define ERREXIT(cinfo,code) \
+ ((cinfo)->err->msg_code = (code), \
+ (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXIT1(cinfo,code,p1) \
+ ((cinfo)->err->msg_code = (code), \
+ (cinfo)->err->msg_parm.i[0] = (p1), \
+ (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXIT2(cinfo,code,p1,p2) \
+ ((cinfo)->err->msg_code = (code), \
+ (cinfo)->err->msg_parm.i[0] = (p1), \
+ (cinfo)->err->msg_parm.i[1] = (p2), \
+ (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXIT3(cinfo,code,p1,p2,p3) \
+ ((cinfo)->err->msg_code = (code), \
+ (cinfo)->err->msg_parm.i[0] = (p1), \
+ (cinfo)->err->msg_parm.i[1] = (p2), \
+ (cinfo)->err->msg_parm.i[2] = (p3), \
+ (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXIT4(cinfo,code,p1,p2,p3,p4) \
+ ((cinfo)->err->msg_code = (code), \
+ (cinfo)->err->msg_parm.i[0] = (p1), \
+ (cinfo)->err->msg_parm.i[1] = (p2), \
+ (cinfo)->err->msg_parm.i[2] = (p3), \
+ (cinfo)->err->msg_parm.i[3] = (p4), \
+ (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXITS(cinfo,code,str) \
+ ((cinfo)->err->msg_code = (code), \
+ strncpy((cinfo)->err->msg_parm.s, (str), JMSG_STR_PARM_MAX), \
+ (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+
+#define MAKESTMT(stuff) do { stuff } while (0)
+
+/* Nonfatal errors (we can keep going, but the data is probably corrupt) */
+#define WARNMS(cinfo,code) \
+ ((cinfo)->err->msg_code = (code), \
+ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1))
+#define WARNMS1(cinfo,code,p1) \
+ ((cinfo)->err->msg_code = (code), \
+ (cinfo)->err->msg_parm.i[0] = (p1), \
+ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1))
+#define WARNMS2(cinfo,code,p1,p2) \
+ ((cinfo)->err->msg_code = (code), \
+ (cinfo)->err->msg_parm.i[0] = (p1), \
+ (cinfo)->err->msg_parm.i[1] = (p2), \
+ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1))
+
+/* Informational/debugging messages */
+#define TRACEMS(cinfo,lvl,code) \
+ ((cinfo)->err->msg_code = (code), \
+ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)))
+#define TRACEMS1(cinfo,lvl,code,p1) \
+ ((cinfo)->err->msg_code = (code), \
+ (cinfo)->err->msg_parm.i[0] = (p1), \
+ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)))
+#define TRACEMS2(cinfo,lvl,code,p1,p2) \
+ ((cinfo)->err->msg_code = (code), \
+ (cinfo)->err->msg_parm.i[0] = (p1), \
+ (cinfo)->err->msg_parm.i[1] = (p2), \
+ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)))
+#define TRACEMS3(cinfo,lvl,code,p1,p2,p3) \
+ MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \
+ _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); \
+ (cinfo)->err->msg_code = (code); \
+ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); )
+#define TRACEMS4(cinfo,lvl,code,p1,p2,p3,p4) \
+ MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \
+ _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \
+ (cinfo)->err->msg_code = (code); \
+ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); )
+#define TRACEMS5(cinfo,lvl,code,p1,p2,p3,p4,p5) \
+ MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \
+ _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \
+ _mp[4] = (p5); \
+ (cinfo)->err->msg_code = (code); \
+ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); )
+#define TRACEMS8(cinfo,lvl,code,p1,p2,p3,p4,p5,p6,p7,p8) \
+ MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \
+ _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \
+ _mp[4] = (p5); _mp[5] = (p6); _mp[6] = (p7); _mp[7] = (p8); \
+ (cinfo)->err->msg_code = (code); \
+ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); )
+#define TRACEMSS(cinfo,lvl,code,str) \
+ ((cinfo)->err->msg_code = (code), \
+ strncpy((cinfo)->err->msg_parm.s, (str), JMSG_STR_PARM_MAX), \
+ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)))
+
+#endif /* JERROR_H */
--- /dev/null
+/*
+ * jfdctflt.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * 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 a floating-point implementation of the
+ * forward DCT (Discrete Cosine Transform).
+ *
+ * This implementation should be more accurate than either of the integer
+ * DCT implementations. However, it may not give the same results on all
+ * machines because of differences in roundoff behavior. Speed will depend
+ * on the hardware's floating point capacity.
+ *
+ * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT
+ * on each column. Direct algorithms are also available, but they are
+ * much more complex and seem not to be any faster when reduced to code.
+ *
+ * This implementation is based on Arai, Agui, and Nakajima's algorithm for
+ * scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in
+ * Japanese, but the algorithm is described in the Pennebaker & Mitchell
+ * JPEG textbook (see REFERENCES section in file README). The following code
+ * is based directly on figure 4-8 in P&M.
+ * While an 8-point DCT cannot be done in less than 11 multiplies, it is
+ * possible to arrange the computation so that many of the multiplies are
+ * simple scalings of the final outputs. These multiplies can then be
+ * folded into the multiplications or divisions by the JPEG quantization
+ * table entries. The AA&N method leaves only 5 multiplies and 29 adds
+ * to be done in the DCT itself.
+ * The primary disadvantage of this method is that with a fixed-point
+ * implementation, accuracy is lost due to imprecise representation of the
+ * scaled quantization values. However, that problem does not arise if
+ * we use floating point arithmetic.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h" /* Private declarations for DCT subsystem */
+
+#ifdef DCT_FLOAT_SUPPORTED
+
+
+/*
+ * This module is specialized to the case DCTSIZE = 8.
+ */
+
+#if DCTSIZE != 8
+ Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
+#endif
+
+
+/*
+ * Perform the forward DCT on one block of samples.
+ */
+
+GLOBAL(void)
+jpeg_fdct_float (FAST_FLOAT * data)
+{
+ FAST_FLOAT tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+ FAST_FLOAT tmp10, tmp11, tmp12, tmp13;
+ FAST_FLOAT z1, z2, z3, z4, z5, z11, z13;
+ FAST_FLOAT *dataptr;
+ int ctr;
+
+ /* Pass 1: process rows. */
+
+ dataptr = data;
+ for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
+ tmp0 = dataptr[0] + dataptr[7];
+ tmp7 = dataptr[0] - dataptr[7];
+ tmp1 = dataptr[1] + dataptr[6];
+ tmp6 = dataptr[1] - dataptr[6];
+ tmp2 = dataptr[2] + dataptr[5];
+ tmp5 = dataptr[2] - dataptr[5];
+ tmp3 = dataptr[3] + dataptr[4];
+ tmp4 = dataptr[3] - dataptr[4];
+
+ /* Even part */
+
+ tmp10 = tmp0 + tmp3; /* phase 2 */
+ tmp13 = tmp0 - tmp3;
+ tmp11 = tmp1 + tmp2;
+ tmp12 = tmp1 - tmp2;
+
+ dataptr[0] = tmp10 + tmp11; /* phase 3 */
+ dataptr[4] = tmp10 - tmp11;
+
+ z1 = (tmp12 + tmp13) * ((FAST_FLOAT) 0.707106781); /* c4 */
+ dataptr[2] = tmp13 + z1; /* phase 5 */
+ dataptr[6] = tmp13 - z1;
+
+ /* Odd part */
+
+ tmp10 = tmp4 + tmp5; /* phase 2 */
+ tmp11 = tmp5 + tmp6;
+ tmp12 = tmp6 + tmp7;
+
+ /* The rotator is modified from fig 4-8 to avoid extra negations. */
+ z5 = (tmp10 - tmp12) * ((FAST_FLOAT) 0.382683433); /* c6 */
+ z2 = ((FAST_FLOAT) 0.541196100) * tmp10 + z5; /* c2-c6 */
+ z4 = ((FAST_FLOAT) 1.306562965) * tmp12 + z5; /* c2+c6 */
+ z3 = tmp11 * ((FAST_FLOAT) 0.707106781); /* c4 */
+
+ z11 = tmp7 + z3; /* phase 5 */
+ z13 = tmp7 - z3;
+
+ dataptr[5] = z13 + z2; /* phase 6 */
+ dataptr[3] = z13 - z2;
+ dataptr[1] = z11 + z4;
+ dataptr[7] = z11 - z4;
+
+ dataptr += DCTSIZE; /* advance pointer to next row */
+ }
+
+ /* Pass 2: process columns. */
+
+ dataptr = data;
+ for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
+ tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7];
+ tmp7 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7];
+ tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6];
+ tmp6 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6];
+ tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5];
+ tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5];
+ tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4];
+ tmp4 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4];
+
+ /* Even part */
+
+ tmp10 = tmp0 + tmp3; /* phase 2 */
+ tmp13 = tmp0 - tmp3;
+ tmp11 = tmp1 + tmp2;
+ tmp12 = tmp1 - tmp2;
+
+ dataptr[DCTSIZE*0] = tmp10 + tmp11; /* phase 3 */
+ dataptr[DCTSIZE*4] = tmp10 - tmp11;
+
+ z1 = (tmp12 + tmp13) * ((FAST_FLOAT) 0.707106781); /* c4 */
+ dataptr[DCTSIZE*2] = tmp13 + z1; /* phase 5 */
+ dataptr[DCTSIZE*6] = tmp13 - z1;
+
+ /* Odd part */
+
+ tmp10 = tmp4 + tmp5; /* phase 2 */
+ tmp11 = tmp5 + tmp6;
+ tmp12 = tmp6 + tmp7;
+
+ /* The rotator is modified from fig 4-8 to avoid extra negations. */
+ z5 = (tmp10 - tmp12) * ((FAST_FLOAT) 0.382683433); /* c6 */
+ z2 = ((FAST_FLOAT) 0.541196100) * tmp10 + z5; /* c2-c6 */
+ z4 = ((FAST_FLOAT) 1.306562965) * tmp12 + z5; /* c2+c6 */
+ z3 = tmp11 * ((FAST_FLOAT) 0.707106781); /* c4 */
+
+ z11 = tmp7 + z3; /* phase 5 */
+ z13 = tmp7 - z3;
+
+ dataptr[DCTSIZE*5] = z13 + z2; /* phase 6 */
+ dataptr[DCTSIZE*3] = z13 - z2;
+ dataptr[DCTSIZE*1] = z11 + z4;
+ dataptr[DCTSIZE*7] = z11 - z4;
+
+ dataptr++; /* advance pointer to next column */
+ }
+}
+
+#endif /* DCT_FLOAT_SUPPORTED */
--- /dev/null
+/*
+ * jfdctfst.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * 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 a fast, not so accurate integer implementation of the
+ * forward DCT (Discrete Cosine Transform).
+ *
+ * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT
+ * on each column. Direct algorithms are also available, but they are
+ * much more complex and seem not to be any faster when reduced to code.
+ *
+ * This implementation is based on Arai, Agui, and Nakajima's algorithm for
+ * scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in
+ * Japanese, but the algorithm is described in the Pennebaker & Mitchell
+ * JPEG textbook (see REFERENCES section in file README). The following code
+ * is based directly on figure 4-8 in P&M.
+ * While an 8-point DCT cannot be done in less than 11 multiplies, it is
+ * possible to arrange the computation so that many of the multiplies are
+ * simple scalings of the final outputs. These multiplies can then be
+ * folded into the multiplications or divisions by the JPEG quantization
+ * table entries. The AA&N method leaves only 5 multiplies and 29 adds
+ * to be done in the DCT itself.
+ * The primary disadvantage of this method is that with fixed-point math,
+ * accuracy is lost due to imprecise representation of the scaled
+ * quantization values. The smaller the quantization table entry, the less
+ * precise the scaled value, so this implementation does worse with high-
+ * quality-setting files than with low-quality ones.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h" /* Private declarations for DCT subsystem */
+
+#ifdef DCT_IFAST_SUPPORTED
+
+
+/*
+ * This module is specialized to the case DCTSIZE = 8.
+ */
+
+#if DCTSIZE != 8
+ Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
+#endif
+
+
+/* Scaling decisions are generally the same as in the LL&M algorithm;
+ * see jfdctint.c for more details. However, we choose to descale
+ * (right shift) multiplication products as soon as they are formed,
+ * rather than carrying additional fractional bits into subsequent additions.
+ * This compromises accuracy slightly, but it lets us save a few shifts.
+ * More importantly, 16-bit arithmetic is then adequate (for 8-bit samples)
+ * everywhere except in the multiplications proper; this saves a good deal
+ * of work on 16-bit-int machines.
+ *
+ * Again to save a few shifts, the intermediate results between pass 1 and
+ * pass 2 are not upscaled, but are represented only to integral precision.
+ *
+ * A final compromise is to represent the multiplicative constants to only
+ * 8 fractional bits, rather than 13. This saves some shifting work on some
+ * machines, and may also reduce the cost of multiplication (since there
+ * are fewer one-bits in the constants).
+ */
+
+#define CONST_BITS 8
+
+
+/* Some C compilers fail to reduce "FIX(constant)" at compile time, thus
+ * causing a lot of useless floating-point operations at run time.
+ * To get around this we use the following pre-calculated constants.
+ * If you change CONST_BITS you may want to add appropriate values.
+ * (With a reasonable C compiler, you can just rely on the FIX() macro...)
+ */
+
+#if CONST_BITS == 8
+#define FIX_0_382683433 ((INT32) 98) /* FIX(0.382683433) */
+#define FIX_0_541196100 ((INT32) 139) /* FIX(0.541196100) */
+#define FIX_0_707106781 ((INT32) 181) /* FIX(0.707106781) */
+#define FIX_1_306562965 ((INT32) 334) /* FIX(1.306562965) */
+#else
+#define FIX_0_382683433 FIX(0.382683433)
+#define FIX_0_541196100 FIX(0.541196100)
+#define FIX_0_707106781 FIX(0.707106781)
+#define FIX_1_306562965 FIX(1.306562965)
+#endif
+
+
+/* We can gain a little more speed, with a further compromise in accuracy,
+ * by omitting the addition in a descaling shift. This yields an incorrectly
+ * rounded result half the time...
+ */
+
+#ifndef USE_ACCURATE_ROUNDING
+#undef DESCALE
+#define DESCALE(x,n) RIGHT_SHIFT(x, n)
+#endif
+
+
+/* Multiply a DCTELEM variable by an INT32 constant, and immediately
+ * descale to yield a DCTELEM result.
+ */
+
+#define MULTIPLY(var,const) ((DCTELEM) DESCALE((var) * (const), CONST_BITS))
+
+
+/*
+ * Perform the forward DCT on one block of samples.
+ */
+
+GLOBAL(void)
+jpeg_fdct_ifast (DCTELEM * data)
+{
+ DCTELEM tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+ DCTELEM tmp10, tmp11, tmp12, tmp13;
+ DCTELEM z1, z2, z3, z4, z5, z11, z13;
+ DCTELEM *dataptr;
+ int ctr;
+ SHIFT_TEMPS
+
+ /* Pass 1: process rows. */
+
+ dataptr = data;
+ for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
+ tmp0 = dataptr[0] + dataptr[7];
+ tmp7 = dataptr[0] - dataptr[7];
+ tmp1 = dataptr[1] + dataptr[6];
+ tmp6 = dataptr[1] - dataptr[6];
+ tmp2 = dataptr[2] + dataptr[5];
+ tmp5 = dataptr[2] - dataptr[5];
+ tmp3 = dataptr[3] + dataptr[4];
+ tmp4 = dataptr[3] - dataptr[4];
+
+ /* Even part */
+
+ tmp10 = tmp0 + tmp3; /* phase 2 */
+ tmp13 = tmp0 - tmp3;
+ tmp11 = tmp1 + tmp2;
+ tmp12 = tmp1 - tmp2;
+
+ dataptr[0] = tmp10 + tmp11; /* phase 3 */
+ dataptr[4] = tmp10 - tmp11;
+
+ z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */
+ dataptr[2] = tmp13 + z1; /* phase 5 */
+ dataptr[6] = tmp13 - z1;
+
+ /* Odd part */
+
+ tmp10 = tmp4 + tmp5; /* phase 2 */
+ tmp11 = tmp5 + tmp6;
+ tmp12 = tmp6 + tmp7;
+
+ /* The rotator is modified from fig 4-8 to avoid extra negations. */
+ z5 = MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */
+ z2 = MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */
+ z4 = MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */
+ z3 = MULTIPLY(tmp11, FIX_0_707106781); /* c4 */
+
+ z11 = tmp7 + z3; /* phase 5 */
+ z13 = tmp7 - z3;
+
+ dataptr[5] = z13 + z2; /* phase 6 */
+ dataptr[3] = z13 - z2;
+ dataptr[1] = z11 + z4;
+ dataptr[7] = z11 - z4;
+
+ dataptr += DCTSIZE; /* advance pointer to next row */
+ }
+
+ /* Pass 2: process columns. */
+
+ dataptr = data;
+ for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
+ tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7];
+ tmp7 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7];
+ tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6];
+ tmp6 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6];
+ tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5];
+ tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5];
+ tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4];
+ tmp4 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4];
+
+ /* Even part */
+
+ tmp10 = tmp0 + tmp3; /* phase 2 */
+ tmp13 = tmp0 - tmp3;
+ tmp11 = tmp1 + tmp2;
+ tmp12 = tmp1 - tmp2;
+
+ dataptr[DCTSIZE*0] = tmp10 + tmp11; /* phase 3 */
+ dataptr[DCTSIZE*4] = tmp10 - tmp11;
+
+ z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */
+ dataptr[DCTSIZE*2] = tmp13 + z1; /* phase 5 */
+ dataptr[DCTSIZE*6] = tmp13 - z1;
+
+ /* Odd part */
+
+ tmp10 = tmp4 + tmp5; /* phase 2 */
+ tmp11 = tmp5 + tmp6;
+ tmp12 = tmp6 + tmp7;
+
+ /* The rotator is modified from fig 4-8 to avoid extra negations. */
+ z5 = MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */
+ z2 = MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */
+ z4 = MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */
+ z3 = MULTIPLY(tmp11, FIX_0_707106781); /* c4 */
+
+ z11 = tmp7 + z3; /* phase 5 */
+ z13 = tmp7 - z3;
+
+ dataptr[DCTSIZE*5] = z13 + z2; /* phase 6 */
+ dataptr[DCTSIZE*3] = z13 - z2;
+ dataptr[DCTSIZE*1] = z11 + z4;
+ dataptr[DCTSIZE*7] = z11 - z4;
+
+ dataptr++; /* advance pointer to next column */
+ }
+}
+
+#endif /* DCT_IFAST_SUPPORTED */
--- /dev/null
+/*
+ * jfdctint.c
+ *
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * 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 a slow-but-accurate integer implementation of the
+ * forward DCT (Discrete Cosine Transform).
+ *
+ * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT
+ * on each column. Direct algorithms are also available, but they are
+ * much more complex and seem not to be any faster when reduced to code.
+ *
+ * This implementation is based on an algorithm described in
+ * C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT
+ * Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics,
+ * Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991.
+ * The primary algorithm described there uses 11 multiplies and 29 adds.
+ * We use their alternate method with 12 multiplies and 32 adds.
+ * The advantage of this method is that no data path contains more than one
+ * multiplication; this allows a very simple and accurate implementation in
+ * scaled fixed-point arithmetic, with a minimal number of shifts.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h" /* Private declarations for DCT subsystem */
+
+#ifdef DCT_ISLOW_SUPPORTED
+
+
+/*
+ * This module is specialized to the case DCTSIZE = 8.
+ */
+
+#if DCTSIZE != 8
+ Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
+#endif
+
+
+/*
+ * The poop on this scaling stuff is as follows:
+ *
+ * Each 1-D DCT step produces outputs which are a factor of sqrt(N)
+ * larger than the true DCT outputs. The final outputs are therefore
+ * a factor of N larger than desired; since N=8 this can be cured by
+ * a simple right shift at the end of the algorithm. The advantage of
+ * this arrangement is that we save two multiplications per 1-D DCT,
+ * because the y0 and y4 outputs need not be divided by sqrt(N).
+ * In the IJG code, this factor of 8 is removed by the quantization step
+ * (in jcdctmgr.c), NOT in this module.
+ *
+ * We have to do addition and subtraction of the integer inputs, which
+ * is no problem, and multiplication by fractional constants, which is
+ * a problem to do in integer arithmetic. We multiply all the constants
+ * by CONST_SCALE and convert them to integer constants (thus retaining
+ * CONST_BITS bits of precision in the constants). After doing a
+ * multiplication we have to divide the product by CONST_SCALE, with proper
+ * rounding, to produce the correct output. This division can be done
+ * cheaply as a right shift of CONST_BITS bits. We postpone shifting
+ * as long as possible so that partial sums can be added together with
+ * full fractional precision.
+ *
+ * The outputs of the first pass are scaled up by PASS1_BITS bits so that
+ * they are represented to better-than-integral precision. These outputs
+ * require BITS_IN_JSAMPLE + PASS1_BITS + 3 bits; this fits in a 16-bit word
+ * with the recommended scaling. (For 12-bit sample data, the intermediate
+ * array is INT32 anyway.)
+ *
+ * To avoid overflow of the 32-bit intermediate results in pass 2, we must
+ * have BITS_IN_JSAMPLE + CONST_BITS + PASS1_BITS <= 26. Error analysis
+ * shows that the values given below are the most effective.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+#define CONST_BITS 13
+#define PASS1_BITS 2
+#else
+#define CONST_BITS 13
+#define PASS1_BITS 1 /* lose a little precision to avoid overflow */
+#endif
+
+/* Some C compilers fail to reduce "FIX(constant)" at compile time, thus
+ * causing a lot of useless floating-point operations at run time.
+ * To get around this we use the following pre-calculated constants.
+ * If you change CONST_BITS you may want to add appropriate values.
+ * (With a reasonable C compiler, you can just rely on the FIX() macro...)
+ */
+
+#if CONST_BITS == 13
+#define FIX_0_298631336 ((INT32) 2446) /* FIX(0.298631336) */
+#define FIX_0_390180644 ((INT32) 3196) /* FIX(0.390180644) */
+#define FIX_0_541196100 ((INT32) 4433) /* FIX(0.541196100) */
+#define FIX_0_765366865 ((INT32) 6270) /* FIX(0.765366865) */
+#define FIX_0_899976223 ((INT32) 7373) /* FIX(0.899976223) */
+#define FIX_1_175875602 ((INT32) 9633) /* FIX(1.175875602) */
+#define FIX_1_501321110 ((INT32) 12299) /* FIX(1.501321110) */
+#define FIX_1_847759065 ((INT32) 15137) /* FIX(1.847759065) */
+#define FIX_1_961570560 ((INT32) 16069) /* FIX(1.961570560) */
+#define FIX_2_053119869 ((INT32) 16819) /* FIX(2.053119869) */
+#define FIX_2_562915447 ((INT32) 20995) /* FIX(2.562915447) */
+#define FIX_3_072711026 ((INT32) 25172) /* FIX(3.072711026) */
+#else
+#define FIX_0_298631336 FIX(0.298631336)
+#define FIX_0_390180644 FIX(0.390180644)
+#define FIX_0_541196100 FIX(0.541196100)
+#define FIX_0_765366865 FIX(0.765366865)
+#define FIX_0_899976223 FIX(0.899976223)
+#define FIX_1_175875602 FIX(1.175875602)
+#define FIX_1_501321110 FIX(1.501321110)
+#define FIX_1_847759065 FIX(1.847759065)
+#define FIX_1_961570560 FIX(1.961570560)
+#define FIX_2_053119869 FIX(2.053119869)
+#define FIX_2_562915447 FIX(2.562915447)
+#define FIX_3_072711026 FIX(3.072711026)
+#endif
+
+
+/* Multiply an INT32 variable by an INT32 constant to yield an INT32 result.
+ * For 8-bit samples with the recommended scaling, all the variable
+ * and constant values involved are no more than 16 bits wide, so a
+ * 16x16->32 bit multiply can be used instead of a full 32x32 multiply.
+ * For 12-bit samples, a full 32-bit multiplication will be needed.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+#define MULTIPLY(var,const) MULTIPLY16C16(var,const)
+#else
+#define MULTIPLY(var,const) ((var) * (const))
+#endif
+
+
+/*
+ * Perform the forward DCT on one block of samples.
+ */
+
+GLOBAL(void)
+jpeg_fdct_islow (DCTELEM * data)
+{
+ INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+ INT32 tmp10, tmp11, tmp12, tmp13;
+ INT32 z1, z2, z3, z4, z5;
+ DCTELEM *dataptr;
+ int ctr;
+ SHIFT_TEMPS
+
+ /* Pass 1: process rows. */
+ /* Note results are scaled up by sqrt(8) compared to a true DCT; */
+ /* furthermore, we scale the results by 2**PASS1_BITS. */
+
+ dataptr = data;
+ for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
+ tmp0 = dataptr[0] + dataptr[7];
+ tmp7 = dataptr[0] - dataptr[7];
+ tmp1 = dataptr[1] + dataptr[6];
+ tmp6 = dataptr[1] - dataptr[6];
+ tmp2 = dataptr[2] + dataptr[5];
+ tmp5 = dataptr[2] - dataptr[5];
+ tmp3 = dataptr[3] + dataptr[4];
+ tmp4 = dataptr[3] - dataptr[4];
+
+ /* Even part per LL&M figure 1 --- note that published figure is faulty;
+ * rotator "sqrt(2)*c1" should be "sqrt(2)*c6".
+ */
+
+ tmp10 = tmp0 + tmp3;
+ tmp13 = tmp0 - tmp3;
+ tmp11 = tmp1 + tmp2;
+ tmp12 = tmp1 - tmp2;
+
+ dataptr[0] = (DCTELEM) ((tmp10 + tmp11) << PASS1_BITS);
+ dataptr[4] = (DCTELEM) ((tmp10 - tmp11) << PASS1_BITS);
+
+ z1 = MULTIPLY(tmp12 + tmp13, FIX_0_541196100);
+ dataptr[2] = (DCTELEM) DESCALE(z1 + MULTIPLY(tmp13, FIX_0_765366865),
+ CONST_BITS-PASS1_BITS);
+ dataptr[6] = (DCTELEM) DESCALE(z1 + MULTIPLY(tmp12, - FIX_1_847759065),
+ CONST_BITS-PASS1_BITS);
+
+ /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
+ * cK represents cos(K*pi/16).
+ * i0..i3 in the paper are tmp4..tmp7 here.
+ */
+
+ z1 = tmp4 + tmp7;
+ z2 = tmp5 + tmp6;
+ z3 = tmp4 + tmp6;
+ z4 = tmp5 + tmp7;
+ z5 = MULTIPLY(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */
+
+ tmp4 = MULTIPLY(tmp4, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */
+ tmp5 = MULTIPLY(tmp5, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */
+ tmp6 = MULTIPLY(tmp6, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */
+ tmp7 = MULTIPLY(tmp7, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */
+ z1 = MULTIPLY(z1, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */
+ z2 = MULTIPLY(z2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
+ z3 = MULTIPLY(z3, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
+ z4 = MULTIPLY(z4, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */
+
+ z3 += z5;
+ z4 += z5;
+
+ dataptr[7] = (DCTELEM) DESCALE(tmp4 + z1 + z3, CONST_BITS-PASS1_BITS);
+ dataptr[5] = (DCTELEM) DESCALE(tmp5 + z2 + z4, CONST_BITS-PASS1_BITS);
+ dataptr[3] = (DCTELEM) DESCALE(tmp6 + z2 + z3, CONST_BITS-PASS1_BITS);
+ dataptr[1] = (DCTELEM) DESCALE(tmp7 + z1 + z4, CONST_BITS-PASS1_BITS);
+
+ dataptr += DCTSIZE; /* advance pointer to next row */
+ }
+
+ /* Pass 2: process columns.
+ * We remove the PASS1_BITS scaling, but leave the results scaled up
+ * by an overall factor of 8.
+ */
+
+ dataptr = data;
+ for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
+ tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7];
+ tmp7 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7];
+ tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6];
+ tmp6 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6];
+ tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5];
+ tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5];
+ tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4];
+ tmp4 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4];
+
+ /* Even part per LL&M figure 1 --- note that published figure is faulty;
+ * rotator "sqrt(2)*c1" should be "sqrt(2)*c6".
+ */
+
+ tmp10 = tmp0 + tmp3;
+ tmp13 = tmp0 - tmp3;
+ tmp11 = tmp1 + tmp2;
+ tmp12 = tmp1 - tmp2;
+
+ dataptr[DCTSIZE*0] = (DCTELEM) DESCALE(tmp10 + tmp11, PASS1_BITS);
+ dataptr[DCTSIZE*4] = (DCTELEM) DESCALE(tmp10 - tmp11, PASS1_BITS);
+
+ z1 = MULTIPLY(tmp12 + tmp13, FIX_0_541196100);
+ dataptr[DCTSIZE*2] = (DCTELEM) DESCALE(z1 + MULTIPLY(tmp13, FIX_0_765366865),
+ CONST_BITS+PASS1_BITS);
+ dataptr[DCTSIZE*6] = (DCTELEM) DESCALE(z1 + MULTIPLY(tmp12, - FIX_1_847759065),
+ CONST_BITS+PASS1_BITS);
+
+ /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
+ * cK represents cos(K*pi/16).
+ * i0..i3 in the paper are tmp4..tmp7 here.
+ */
+
+ z1 = tmp4 + tmp7;
+ z2 = tmp5 + tmp6;
+ z3 = tmp4 + tmp6;
+ z4 = tmp5 + tmp7;
+ z5 = MULTIPLY(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */
+
+ tmp4 = MULTIPLY(tmp4, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */
+ tmp5 = MULTIPLY(tmp5, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */
+ tmp6 = MULTIPLY(tmp6, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */
+ tmp7 = MULTIPLY(tmp7, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */
+ z1 = MULTIPLY(z1, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */
+ z2 = MULTIPLY(z2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
+ z3 = MULTIPLY(z3, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
+ z4 = MULTIPLY(z4, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */
+
+ z3 += z5;
+ z4 += z5;
+
+ dataptr[DCTSIZE*7] = (DCTELEM) DESCALE(tmp4 + z1 + z3,
+ CONST_BITS+PASS1_BITS);
+ dataptr[DCTSIZE*5] = (DCTELEM) DESCALE(tmp5 + z2 + z4,
+ CONST_BITS+PASS1_BITS);
+ dataptr[DCTSIZE*3] = (DCTELEM) DESCALE(tmp6 + z2 + z3,
+ CONST_BITS+PASS1_BITS);
+ dataptr[DCTSIZE*1] = (DCTELEM) DESCALE(tmp7 + z1 + z4,
+ CONST_BITS+PASS1_BITS);
+
+ dataptr++; /* advance pointer to next column */
+ }
+}
+
+#endif /* DCT_ISLOW_SUPPORTED */
--- /dev/null
+/*
+ * jidctflt.c
+ *
+ * Copyright (C) 1994-1998, Thomas G. Lane.
+ * 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 a floating-point implementation of the
+ * inverse DCT (Discrete Cosine Transform). In the IJG code, this routine
+ * must also perform dequantization of the input coefficients.
+ *
+ * This implementation should be more accurate than either of the integer
+ * IDCT implementations. However, it may not give the same results on all
+ * machines because of differences in roundoff behavior. Speed will depend
+ * on the hardware's floating point capacity.
+ *
+ * A 2-D IDCT can be done by 1-D IDCT on each column followed by 1-D IDCT
+ * on each row (or vice versa, but it's more convenient to emit a row at
+ * a time). Direct algorithms are also available, but they are much more
+ * complex and seem not to be any faster when reduced to code.
+ *
+ * This implementation is based on Arai, Agui, and Nakajima's algorithm for
+ * scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in
+ * Japanese, but the algorithm is described in the Pennebaker & Mitchell
+ * JPEG textbook (see REFERENCES section in file README). The following code
+ * is based directly on figure 4-8 in P&M.
+ * While an 8-point DCT cannot be done in less than 11 multiplies, it is
+ * possible to arrange the computation so that many of the multiplies are
+ * simple scalings of the final outputs. These multiplies can then be
+ * folded into the multiplications or divisions by the JPEG quantization
+ * table entries. The AA&N method leaves only 5 multiplies and 29 adds
+ * to be done in the DCT itself.
+ * The primary disadvantage of this method is that with a fixed-point
+ * implementation, accuracy is lost due to imprecise representation of the
+ * scaled quantization values. However, that problem does not arise if
+ * we use floating point arithmetic.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h" /* Private declarations for DCT subsystem */
+
+#ifdef DCT_FLOAT_SUPPORTED
+
+
+/*
+ * This module is specialized to the case DCTSIZE = 8.
+ */
+
+#if DCTSIZE != 8
+ Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
+#endif
+
+
+/* Dequantize a coefficient by multiplying it by the multiplier-table
+ * entry; produce a float result.
+ */
+
+#define DEQUANTIZE(coef,quantval) (((FAST_FLOAT) (coef)) * (quantval))
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients.
+ */
+
+GLOBAL(void)
+jpeg_idct_float (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JCOEFPTR coef_block,
+ JSAMPARRAY output_buf, JDIMENSION output_col)
+{
+ FAST_FLOAT tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+ FAST_FLOAT tmp10, tmp11, tmp12, tmp13;
+ FAST_FLOAT z5, z10, z11, z12, z13;
+ JCOEFPTR inptr;
+ FLOAT_MULT_TYPE * quantptr;
+ FAST_FLOAT * wsptr;
+ JSAMPROW outptr;
+ JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+ int ctr;
+ FAST_FLOAT workspace[DCTSIZE2]; /* buffers data between passes */
+ SHIFT_TEMPS
+
+ /* Pass 1: process columns from input, store into work array. */
+
+ inptr = coef_block;
+ quantptr = (FLOAT_MULT_TYPE *) compptr->dct_table;
+ wsptr = workspace;
+ for (ctr = DCTSIZE; ctr > 0; ctr--) {
+ /* Due to quantization, we will usually find that many of the input
+ * coefficients are zero, especially the AC terms. We can exploit this
+ * by short-circuiting the IDCT calculation for any column in which all
+ * the AC terms are zero. In that case each output is equal to the
+ * DC coefficient (with scale factor as needed).
+ * With typical images and quantization tables, half or more of the
+ * column DCT calculations can be simplified this way.
+ */
+
+ if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 &&
+ inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*4] == 0 &&
+ inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*6] == 0 &&
+ inptr[DCTSIZE*7] == 0) {
+ /* AC terms all zero */
+ FAST_FLOAT dcval = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
+
+ wsptr[DCTSIZE*0] = dcval;
+ wsptr[DCTSIZE*1] = dcval;
+ wsptr[DCTSIZE*2] = dcval;
+ wsptr[DCTSIZE*3] = dcval;
+ wsptr[DCTSIZE*4] = dcval;
+ wsptr[DCTSIZE*5] = dcval;
+ wsptr[DCTSIZE*6] = dcval;
+ wsptr[DCTSIZE*7] = dcval;
+
+ inptr++; /* advance pointers to next column */
+ quantptr++;
+ wsptr++;
+ continue;
+ }
+
+ /* Even part */
+
+ tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
+ tmp1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
+ tmp2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
+ tmp3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
+
+ tmp10 = tmp0 + tmp2; /* phase 3 */
+ tmp11 = tmp0 - tmp2;
+
+ tmp13 = tmp1 + tmp3; /* phases 5-3 */
+ tmp12 = (tmp1 - tmp3) * ((FAST_FLOAT) 1.414213562) - tmp13; /* 2*c4 */
+
+ tmp0 = tmp10 + tmp13; /* phase 2 */
+ tmp3 = tmp10 - tmp13;
+ tmp1 = tmp11 + tmp12;
+ tmp2 = tmp11 - tmp12;
+
+ /* Odd part */
+
+ tmp4 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
+ tmp5 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
+ tmp6 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
+ tmp7 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
+
+ z13 = tmp6 + tmp5; /* phase 6 */
+ z10 = tmp6 - tmp5;
+ z11 = tmp4 + tmp7;
+ z12 = tmp4 - tmp7;
+
+ tmp7 = z11 + z13; /* phase 5 */
+ tmp11 = (z11 - z13) * ((FAST_FLOAT) 1.414213562); /* 2*c4 */
+
+ z5 = (z10 + z12) * ((FAST_FLOAT) 1.847759065); /* 2*c2 */
+ tmp10 = ((FAST_FLOAT) 1.082392200) * z12 - z5; /* 2*(c2-c6) */
+ tmp12 = ((FAST_FLOAT) -2.613125930) * z10 + z5; /* -2*(c2+c6) */
+
+ tmp6 = tmp12 - tmp7; /* phase 2 */
+ tmp5 = tmp11 - tmp6;
+ tmp4 = tmp10 + tmp5;
+
+ wsptr[DCTSIZE*0] = tmp0 + tmp7;
+ wsptr[DCTSIZE*7] = tmp0 - tmp7;
+ wsptr[DCTSIZE*1] = tmp1 + tmp6;
+ wsptr[DCTSIZE*6] = tmp1 - tmp6;
+ wsptr[DCTSIZE*2] = tmp2 + tmp5;
+ wsptr[DCTSIZE*5] = tmp2 - tmp5;
+ wsptr[DCTSIZE*4] = tmp3 + tmp4;
+ wsptr[DCTSIZE*3] = tmp3 - tmp4;
+
+ inptr++; /* advance pointers to next column */
+ quantptr++;
+ wsptr++;
+ }
+
+ /* Pass 2: process rows from work array, store into output array. */
+ /* Note that we must descale the results by a factor of 8 == 2**3. */
+
+ wsptr = workspace;
+ for (ctr = 0; ctr < DCTSIZE; ctr++) {
+ outptr = output_buf[ctr] + output_col;
+ /* Rows of zeroes can be exploited in the same way as we did with columns.
+ * However, the column calculation has created many nonzero AC terms, so
+ * the simplification applies less often (typically 5% to 10% of the time).
+ * And testing floats for zero is relatively expensive, so we don't bother.
+ */
+
+ /* Even part */
+
+ tmp10 = wsptr[0] + wsptr[4];
+ tmp11 = wsptr[0] - wsptr[4];
+
+ tmp13 = wsptr[2] + wsptr[6];
+ tmp12 = (wsptr[2] - wsptr[6]) * ((FAST_FLOAT) 1.414213562) - tmp13;
+
+ tmp0 = tmp10 + tmp13;
+ tmp3 = tmp10 - tmp13;
+ tmp1 = tmp11 + tmp12;
+ tmp2 = tmp11 - tmp12;
+
+ /* Odd part */
+
+ z13 = wsptr[5] + wsptr[3];
+ z10 = wsptr[5] - wsptr[3];
+ z11 = wsptr[1] + wsptr[7];
+ z12 = wsptr[1] - wsptr[7];
+
+ tmp7 = z11 + z13;
+ tmp11 = (z11 - z13) * ((FAST_FLOAT) 1.414213562);
+
+ z5 = (z10 + z12) * ((FAST_FLOAT) 1.847759065); /* 2*c2 */
+ tmp10 = ((FAST_FLOAT) 1.082392200) * z12 - z5; /* 2*(c2-c6) */
+ tmp12 = ((FAST_FLOAT) -2.613125930) * z10 + z5; /* -2*(c2+c6) */
+
+ tmp6 = tmp12 - tmp7;
+ tmp5 = tmp11 - tmp6;
+ tmp4 = tmp10 + tmp5;
+
+ /* Final output stage: scale down by a factor of 8 and range-limit */
+
+ outptr[0] = range_limit[(int) DESCALE((INT32) (tmp0 + tmp7), 3)
+ & RANGE_MASK];
+ outptr[7] = range_limit[(int) DESCALE((INT32) (tmp0 - tmp7), 3)
+ & RANGE_MASK];
+ outptr[1] = range_limit[(int) DESCALE((INT32) (tmp1 + tmp6), 3)
+ & RANGE_MASK];
+ outptr[6] = range_limit[(int) DESCALE((INT32) (tmp1 - tmp6), 3)
+ & RANGE_MASK];
+ outptr[2] = range_limit[(int) DESCALE((INT32) (tmp2 + tmp5), 3)
+ & RANGE_MASK];
+ outptr[5] = range_limit[(int) DESCALE((INT32) (tmp2 - tmp5), 3)
+ & RANGE_MASK];
+ outptr[4] = range_limit[(int) DESCALE((INT32) (tmp3 + tmp4), 3)
+ & RANGE_MASK];
+ outptr[3] = range_limit[(int) DESCALE((INT32) (tmp3 - tmp4), 3)
+ & RANGE_MASK];
+
+ wsptr += DCTSIZE; /* advance pointer to next row */
+ }
+}
+
+#endif /* DCT_FLOAT_SUPPORTED */
--- /dev/null
+/*
+ * jidctfst.c
+ *
+ * Copyright (C) 1994-1998, Thomas G. Lane.
+ * 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 a fast, not so accurate integer implementation of the
+ * inverse DCT (Discrete Cosine Transform). In the IJG code, this routine
+ * must also perform dequantization of the input coefficients.
+ *
+ * A 2-D IDCT can be done by 1-D IDCT on each column followed by 1-D IDCT
+ * on each row (or vice versa, but it's more convenient to emit a row at
+ * a time). Direct algorithms are also available, but they are much more
+ * complex and seem not to be any faster when reduced to code.
+ *
+ * This implementation is based on Arai, Agui, and Nakajima's algorithm for
+ * scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in
+ * Japanese, but the algorithm is described in the Pennebaker & Mitchell
+ * JPEG textbook (see REFERENCES section in file README). The following code
+ * is based directly on figure 4-8 in P&M.
+ * While an 8-point DCT cannot be done in less than 11 multiplies, it is
+ * possible to arrange the computation so that many of the multiplies are
+ * simple scalings of the final outputs. These multiplies can then be
+ * folded into the multiplications or divisions by the JPEG quantization
+ * table entries. The AA&N method leaves only 5 multiplies and 29 adds
+ * to be done in the DCT itself.
+ * The primary disadvantage of this method is that with fixed-point math,
+ * accuracy is lost due to imprecise representation of the scaled
+ * quantization values. The smaller the quantization table entry, the less
+ * precise the scaled value, so this implementation does worse with high-
+ * quality-setting files than with low-quality ones.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h" /* Private declarations for DCT subsystem */
+
+#ifdef DCT_IFAST_SUPPORTED
+
+
+/*
+ * This module is specialized to the case DCTSIZE = 8.
+ */
+
+#if DCTSIZE != 8
+ Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
+#endif
+
+
+/* Scaling decisions are generally the same as in the LL&M algorithm;
+ * see jidctint.c for more details. However, we choose to descale
+ * (right shift) multiplication products as soon as they are formed,
+ * rather than carrying additional fractional bits into subsequent additions.
+ * This compromises accuracy slightly, but it lets us save a few shifts.
+ * More importantly, 16-bit arithmetic is then adequate (for 8-bit samples)
+ * everywhere except in the multiplications proper; this saves a good deal
+ * of work on 16-bit-int machines.
+ *
+ * The dequantized coefficients are not integers because the AA&N scaling
+ * factors have been incorporated. We represent them scaled up by PASS1_BITS,
+ * so that the first and second IDCT rounds have the same input scaling.
+ * For 8-bit JSAMPLEs, we choose IFAST_SCALE_BITS = PASS1_BITS so as to
+ * avoid a descaling shift; this compromises accuracy rather drastically
+ * for small quantization table entries, but it saves a lot of shifts.
+ * For 12-bit JSAMPLEs, there's no hope of using 16x16 multiplies anyway,
+ * so we use a much larger scaling factor to preserve accuracy.
+ *
+ * A final compromise is to represent the multiplicative constants to only
+ * 8 fractional bits, rather than 13. This saves some shifting work on some
+ * machines, and may also reduce the cost of multiplication (since there
+ * are fewer one-bits in the constants).
+ */
+
+#if BITS_IN_JSAMPLE == 8
+#define CONST_BITS 8
+#define PASS1_BITS 2
+#else
+#define CONST_BITS 8
+#define PASS1_BITS 1 /* lose a little precision to avoid overflow */
+#endif
+
+/* Some C compilers fail to reduce "FIX(constant)" at compile time, thus
+ * causing a lot of useless floating-point operations at run time.
+ * To get around this we use the following pre-calculated constants.
+ * If you change CONST_BITS you may want to add appropriate values.
+ * (With a reasonable C compiler, you can just rely on the FIX() macro...)
+ */
+
+#if CONST_BITS == 8
+#define FIX_1_082392200 ((INT32) 277) /* FIX(1.082392200) */
+#define FIX_1_414213562 ((INT32) 362) /* FIX(1.414213562) */
+#define FIX_1_847759065 ((INT32) 473) /* FIX(1.847759065) */
+#define FIX_2_613125930 ((INT32) 669) /* FIX(2.613125930) */
+#else
+#define FIX_1_082392200 FIX(1.082392200)
+#define FIX_1_414213562 FIX(1.414213562)
+#define FIX_1_847759065 FIX(1.847759065)
+#define FIX_2_613125930 FIX(2.613125930)
+#endif
+
+
+/* We can gain a little more speed, with a further compromise in accuracy,
+ * by omitting the addition in a descaling shift. This yields an incorrectly
+ * rounded result half the time...
+ */
+
+#ifndef USE_ACCURATE_ROUNDING
+#undef DESCALE
+#define DESCALE(x,n) RIGHT_SHIFT(x, n)
+#endif
+
+
+/* Multiply a DCTELEM variable by an INT32 constant, and immediately
+ * descale to yield a DCTELEM result.
+ */
+
+#define MULTIPLY(var,const) ((DCTELEM) DESCALE((var) * (const), CONST_BITS))
+
+
+/* Dequantize a coefficient by multiplying it by the multiplier-table
+ * entry; produce a DCTELEM result. For 8-bit data a 16x16->16
+ * multiplication will do. For 12-bit data, the multiplier table is
+ * declared INT32, so a 32-bit multiply will be used.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+#define DEQUANTIZE(coef,quantval) (((IFAST_MULT_TYPE) (coef)) * (quantval))
+#else
+#define DEQUANTIZE(coef,quantval) \
+ DESCALE((coef)*(quantval), IFAST_SCALE_BITS-PASS1_BITS)
+#endif
+
+
+/* Like DESCALE, but applies to a DCTELEM and produces an int.
+ * We assume that int right shift is unsigned if INT32 right shift is.
+ */
+
+#ifdef RIGHT_SHIFT_IS_UNSIGNED
+#define ISHIFT_TEMPS DCTELEM ishift_temp;
+#if BITS_IN_JSAMPLE == 8
+#define DCTELEMBITS 16 /* DCTELEM may be 16 or 32 bits */
+#else
+#define DCTELEMBITS 32 /* DCTELEM must be 32 bits */
+#endif
+#define IRIGHT_SHIFT(x,shft) \
+ ((ishift_temp = (x)) < 0 ? \
+ (ishift_temp >> (shft)) | ((~((DCTELEM) 0)) << (DCTELEMBITS-(shft))) : \
+ (ishift_temp >> (shft)))
+#else
+#define ISHIFT_TEMPS
+#define IRIGHT_SHIFT(x,shft) ((x) >> (shft))
+#endif
+
+#ifdef USE_ACCURATE_ROUNDING
+#define IDESCALE(x,n) ((int) IRIGHT_SHIFT((x) + (1 << ((n)-1)), n))
+#else
+#define IDESCALE(x,n) ((int) IRIGHT_SHIFT(x, n))
+#endif
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients.
+ */
+
+GLOBAL(void)
+jpeg_idct_ifast (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JCOEFPTR coef_block,
+ JSAMPARRAY output_buf, JDIMENSION output_col)
+{
+ DCTELEM tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+ DCTELEM tmp10, tmp11, tmp12, tmp13;
+ DCTELEM z5, z10, z11, z12, z13;
+ JCOEFPTR inptr;
+ IFAST_MULT_TYPE * quantptr;
+ int * wsptr;
+ JSAMPROW outptr;
+ JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+ int ctr;
+ int workspace[DCTSIZE2]; /* buffers data between passes */
+ SHIFT_TEMPS /* for DESCALE */
+ ISHIFT_TEMPS /* for IDESCALE */
+
+ /* Pass 1: process columns from input, store into work array. */
+
+ inptr = coef_block;
+ quantptr = (IFAST_MULT_TYPE *) compptr->dct_table;
+ wsptr = workspace;
+ for (ctr = DCTSIZE; ctr > 0; ctr--) {
+ /* Due to quantization, we will usually find that many of the input
+ * coefficients are zero, especially the AC terms. We can exploit this
+ * by short-circuiting the IDCT calculation for any column in which all
+ * the AC terms are zero. In that case each output is equal to the
+ * DC coefficient (with scale factor as needed).
+ * With typical images and quantization tables, half or more of the
+ * column DCT calculations can be simplified this way.
+ */
+
+ if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 &&
+ inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*4] == 0 &&
+ inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*6] == 0 &&
+ inptr[DCTSIZE*7] == 0) {
+ /* AC terms all zero */
+ int dcval = (int) DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
+
+ wsptr[DCTSIZE*0] = dcval;
+ wsptr[DCTSIZE*1] = dcval;
+ wsptr[DCTSIZE*2] = dcval;
+ wsptr[DCTSIZE*3] = dcval;
+ wsptr[DCTSIZE*4] = dcval;
+ wsptr[DCTSIZE*5] = dcval;
+ wsptr[DCTSIZE*6] = dcval;
+ wsptr[DCTSIZE*7] = dcval;
+
+ inptr++; /* advance pointers to next column */
+ quantptr++;
+ wsptr++;
+ continue;
+ }
+
+ /* Even part */
+
+ tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
+ tmp1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
+ tmp2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
+ tmp3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
+
+ tmp10 = tmp0 + tmp2; /* phase 3 */
+ tmp11 = tmp0 - tmp2;
+
+ tmp13 = tmp1 + tmp3; /* phases 5-3 */
+ tmp12 = MULTIPLY(tmp1 - tmp3, FIX_1_414213562) - tmp13; /* 2*c4 */
+
+ tmp0 = tmp10 + tmp13; /* phase 2 */
+ tmp3 = tmp10 - tmp13;
+ tmp1 = tmp11 + tmp12;
+ tmp2 = tmp11 - tmp12;
+
+ /* Odd part */
+
+ tmp4 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
+ tmp5 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
+ tmp6 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
+ tmp7 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
+
+ z13 = tmp6 + tmp5; /* phase 6 */
+ z10 = tmp6 - tmp5;
+ z11 = tmp4 + tmp7;
+ z12 = tmp4 - tmp7;
+
+ tmp7 = z11 + z13; /* phase 5 */
+ tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562); /* 2*c4 */
+
+ z5 = MULTIPLY(z10 + z12, FIX_1_847759065); /* 2*c2 */
+ tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5; /* 2*(c2-c6) */
+ tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5; /* -2*(c2+c6) */
+
+ tmp6 = tmp12 - tmp7; /* phase 2 */
+ tmp5 = tmp11 - tmp6;
+ tmp4 = tmp10 + tmp5;
+
+ wsptr[DCTSIZE*0] = (int) (tmp0 + tmp7);
+ wsptr[DCTSIZE*7] = (int) (tmp0 - tmp7);
+ wsptr[DCTSIZE*1] = (int) (tmp1 + tmp6);
+ wsptr[DCTSIZE*6] = (int) (tmp1 - tmp6);
+ wsptr[DCTSIZE*2] = (int) (tmp2 + tmp5);
+ wsptr[DCTSIZE*5] = (int) (tmp2 - tmp5);
+ wsptr[DCTSIZE*4] = (int) (tmp3 + tmp4);
+ wsptr[DCTSIZE*3] = (int) (tmp3 - tmp4);
+
+ inptr++; /* advance pointers to next column */
+ quantptr++;
+ wsptr++;
+ }
+
+ /* Pass 2: process rows from work array, store into output array. */
+ /* Note that we must descale the results by a factor of 8 == 2**3, */
+ /* and also undo the PASS1_BITS scaling. */
+
+ wsptr = workspace;
+ for (ctr = 0; ctr < DCTSIZE; ctr++) {
+ outptr = output_buf[ctr] + output_col;
+ /* Rows of zeroes can be exploited in the same way as we did with columns.
+ * However, the column calculation has created many nonzero AC terms, so
+ * the simplification applies less often (typically 5% to 10% of the time).
+ * On machines with very fast multiplication, it's possible that the
+ * test takes more time than it's worth. In that case this section
+ * may be commented out.
+ */
+
+#ifndef NO_ZERO_ROW_TEST
+ if (wsptr[1] == 0 && wsptr[2] == 0 && wsptr[3] == 0 && wsptr[4] == 0 &&
+ wsptr[5] == 0 && wsptr[6] == 0 && wsptr[7] == 0) {
+ /* AC terms all zero */
+ JSAMPLE dcval = range_limit[IDESCALE(wsptr[0], PASS1_BITS+3)
+ & RANGE_MASK];
+
+ outptr[0] = dcval;
+ outptr[1] = dcval;
+ outptr[2] = dcval;
+ outptr[3] = dcval;
+ outptr[4] = dcval;
+ outptr[5] = dcval;
+ outptr[6] = dcval;
+ outptr[7] = dcval;
+
+ wsptr += DCTSIZE; /* advance pointer to next row */
+ continue;
+ }
+#endif
+
+ /* Even part */
+
+ tmp10 = ((DCTELEM) wsptr[0] + (DCTELEM) wsptr[4]);
+ tmp11 = ((DCTELEM) wsptr[0] - (DCTELEM) wsptr[4]);
+
+ tmp13 = ((DCTELEM) wsptr[2] + (DCTELEM) wsptr[6]);
+ tmp12 = MULTIPLY((DCTELEM) wsptr[2] - (DCTELEM) wsptr[6], FIX_1_414213562)
+ - tmp13;
+
+ tmp0 = tmp10 + tmp13;
+ tmp3 = tmp10 - tmp13;
+ tmp1 = tmp11 + tmp12;
+ tmp2 = tmp11 - tmp12;
+
+ /* Odd part */
+
+ z13 = (DCTELEM) wsptr[5] + (DCTELEM) wsptr[3];
+ z10 = (DCTELEM) wsptr[5] - (DCTELEM) wsptr[3];
+ z11 = (DCTELEM) wsptr[1] + (DCTELEM) wsptr[7];
+ z12 = (DCTELEM) wsptr[1] - (DCTELEM) wsptr[7];
+
+ tmp7 = z11 + z13; /* phase 5 */
+ tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562); /* 2*c4 */
+
+ z5 = MULTIPLY(z10 + z12, FIX_1_847759065); /* 2*c2 */
+ tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5; /* 2*(c2-c6) */
+ tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5; /* -2*(c2+c6) */
+
+ tmp6 = tmp12 - tmp7; /* phase 2 */
+ tmp5 = tmp11 - tmp6;
+ tmp4 = tmp10 + tmp5;
+
+ /* Final output stage: scale down by a factor of 8 and range-limit */
+
+ outptr[0] = range_limit[IDESCALE(tmp0 + tmp7, PASS1_BITS+3)
+ & RANGE_MASK];
+ outptr[7] = range_limit[IDESCALE(tmp0 - tmp7, PASS1_BITS+3)
+ & RANGE_MASK];
+ outptr[1] = range_limit[IDESCALE(tmp1 + tmp6, PASS1_BITS+3)
+ & RANGE_MASK];
+ outptr[6] = range_limit[IDESCALE(tmp1 - tmp6, PASS1_BITS+3)
+ & RANGE_MASK];
+ outptr[2] = range_limit[IDESCALE(tmp2 + tmp5, PASS1_BITS+3)
+ & RANGE_MASK];
+ outptr[5] = range_limit[IDESCALE(tmp2 - tmp5, PASS1_BITS+3)
+ & RANGE_MASK];
+ outptr[4] = range_limit[IDESCALE(tmp3 + tmp4, PASS1_BITS+3)
+ & RANGE_MASK];
+ outptr[3] = range_limit[IDESCALE(tmp3 - tmp4, PASS1_BITS+3)
+ & RANGE_MASK];
+
+ wsptr += DCTSIZE; /* advance pointer to next row */
+ }
+}
+
+#endif /* DCT_IFAST_SUPPORTED */
--- /dev/null
+/*
+ * jidctint.c
+ *
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * 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 a slow-but-accurate integer implementation of the
+ * inverse DCT (Discrete Cosine Transform). In the IJG code, this routine
+ * must also perform dequantization of the input coefficients.
+ *
+ * A 2-D IDCT can be done by 1-D IDCT on each column followed by 1-D IDCT
+ * on each row (or vice versa, but it's more convenient to emit a row at
+ * a time). Direct algorithms are also available, but they are much more
+ * complex and seem not to be any faster when reduced to code.
+ *
+ * This implementation is based on an algorithm described in
+ * C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT
+ * Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics,
+ * Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991.
+ * The primary algorithm described there uses 11 multiplies and 29 adds.
+ * We use their alternate method with 12 multiplies and 32 adds.
+ * The advantage of this method is that no data path contains more than one
+ * multiplication; this allows a very simple and accurate implementation in
+ * scaled fixed-point arithmetic, with a minimal number of shifts.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h" /* Private declarations for DCT subsystem */
+
+#ifdef DCT_ISLOW_SUPPORTED
+
+
+/*
+ * This module is specialized to the case DCTSIZE = 8.
+ */
+
+#if DCTSIZE != 8
+ Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
+#endif
+
+
+/*
+ * The poop on this scaling stuff is as follows:
+ *
+ * Each 1-D IDCT step produces outputs which are a factor of sqrt(N)
+ * larger than the true IDCT outputs. The final outputs are therefore
+ * a factor of N larger than desired; since N=8 this can be cured by
+ * a simple right shift at the end of the algorithm. The advantage of
+ * this arrangement is that we save two multiplications per 1-D IDCT,
+ * because the y0 and y4 inputs need not be divided by sqrt(N).
+ *
+ * We have to do addition and subtraction of the integer inputs, which
+ * is no problem, and multiplication by fractional constants, which is
+ * a problem to do in integer arithmetic. We multiply all the constants
+ * by CONST_SCALE and convert them to integer constants (thus retaining
+ * CONST_BITS bits of precision in the constants). After doing a
+ * multiplication we have to divide the product by CONST_SCALE, with proper
+ * rounding, to produce the correct output. This division can be done
+ * cheaply as a right shift of CONST_BITS bits. We postpone shifting
+ * as long as possible so that partial sums can be added together with
+ * full fractional precision.
+ *
+ * The outputs of the first pass are scaled up by PASS1_BITS bits so that
+ * they are represented to better-than-integral precision. These outputs
+ * require BITS_IN_JSAMPLE + PASS1_BITS + 3 bits; this fits in a 16-bit word
+ * with the recommended scaling. (To scale up 12-bit sample data further, an
+ * intermediate INT32 array would be needed.)
+ *
+ * To avoid overflow of the 32-bit intermediate results in pass 2, we must
+ * have BITS_IN_JSAMPLE + CONST_BITS + PASS1_BITS <= 26. Error analysis
+ * shows that the values given below are the most effective.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+#define CONST_BITS 13
+#define PASS1_BITS 2
+#else
+#define CONST_BITS 13
+#define PASS1_BITS 1 /* lose a little precision to avoid overflow */
+#endif
+
+/* Some C compilers fail to reduce "FIX(constant)" at compile time, thus
+ * causing a lot of useless floating-point operations at run time.
+ * To get around this we use the following pre-calculated constants.
+ * If you change CONST_BITS you may want to add appropriate values.
+ * (With a reasonable C compiler, you can just rely on the FIX() macro...)
+ */
+
+#if CONST_BITS == 13
+#define FIX_0_298631336 ((INT32) 2446) /* FIX(0.298631336) */
+#define FIX_0_390180644 ((INT32) 3196) /* FIX(0.390180644) */
+#define FIX_0_541196100 ((INT32) 4433) /* FIX(0.541196100) */
+#define FIX_0_765366865 ((INT32) 6270) /* FIX(0.765366865) */
+#define FIX_0_899976223 ((INT32) 7373) /* FIX(0.899976223) */
+#define FIX_1_175875602 ((INT32) 9633) /* FIX(1.175875602) */
+#define FIX_1_501321110 ((INT32) 12299) /* FIX(1.501321110) */
+#define FIX_1_847759065 ((INT32) 15137) /* FIX(1.847759065) */
+#define FIX_1_961570560 ((INT32) 16069) /* FIX(1.961570560) */
+#define FIX_2_053119869 ((INT32) 16819) /* FIX(2.053119869) */
+#define FIX_2_562915447 ((INT32) 20995) /* FIX(2.562915447) */
+#define FIX_3_072711026 ((INT32) 25172) /* FIX(3.072711026) */
+#else
+#define FIX_0_298631336 FIX(0.298631336)
+#define FIX_0_390180644 FIX(0.390180644)
+#define FIX_0_541196100 FIX(0.541196100)
+#define FIX_0_765366865 FIX(0.765366865)
+#define FIX_0_899976223 FIX(0.899976223)
+#define FIX_1_175875602 FIX(1.175875602)
+#define FIX_1_501321110 FIX(1.501321110)
+#define FIX_1_847759065 FIX(1.847759065)
+#define FIX_1_961570560 FIX(1.961570560)
+#define FIX_2_053119869 FIX(2.053119869)
+#define FIX_2_562915447 FIX(2.562915447)
+#define FIX_3_072711026 FIX(3.072711026)
+#endif
+
+
+/* Multiply an INT32 variable by an INT32 constant to yield an INT32 result.
+ * For 8-bit samples with the recommended scaling, all the variable
+ * and constant values involved are no more than 16 bits wide, so a
+ * 16x16->32 bit multiply can be used instead of a full 32x32 multiply.
+ * For 12-bit samples, a full 32-bit multiplication will be needed.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+#define MULTIPLY(var,const) MULTIPLY16C16(var,const)
+#else
+#define MULTIPLY(var,const) ((var) * (const))
+#endif
+
+
+/* Dequantize a coefficient by multiplying it by the multiplier-table
+ * entry; produce an int result. In this module, both inputs and result
+ * are 16 bits or less, so either int or short multiply will work.
+ */
+
+#define DEQUANTIZE(coef,quantval) (((ISLOW_MULT_TYPE) (coef)) * (quantval))
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients.
+ */
+
+GLOBAL(void)
+jpeg_idct_islow (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JCOEFPTR coef_block,
+ JSAMPARRAY output_buf, JDIMENSION output_col)
+{
+ INT32 tmp0, tmp1, tmp2, tmp3;
+ INT32 tmp10, tmp11, tmp12, tmp13;
+ INT32 z1, z2, z3, z4, z5;
+ JCOEFPTR inptr;
+ ISLOW_MULT_TYPE * quantptr;
+ int * wsptr;
+ JSAMPROW outptr;
+ JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+ int ctr;
+ int workspace[DCTSIZE2]; /* buffers data between passes */
+ SHIFT_TEMPS
+
+ /* Pass 1: process columns from input, store into work array. */
+ /* Note results are scaled up by sqrt(8) compared to a true IDCT; */
+ /* furthermore, we scale the results by 2**PASS1_BITS. */
+
+ inptr = coef_block;
+ quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
+ wsptr = workspace;
+ for (ctr = DCTSIZE; ctr > 0; ctr--) {
+ /* Due to quantization, we will usually find that many of the input
+ * coefficients are zero, especially the AC terms. We can exploit this
+ * by short-circuiting the IDCT calculation for any column in which all
+ * the AC terms are zero. In that case each output is equal to the
+ * DC coefficient (with scale factor as needed).
+ * With typical images and quantization tables, half or more of the
+ * column DCT calculations can be simplified this way.
+ */
+
+ if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 &&
+ inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*4] == 0 &&
+ inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*6] == 0 &&
+ inptr[DCTSIZE*7] == 0) {
+ /* AC terms all zero */
+ int dcval = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) << PASS1_BITS;
+
+ wsptr[DCTSIZE*0] = dcval;
+ wsptr[DCTSIZE*1] = dcval;
+ wsptr[DCTSIZE*2] = dcval;
+ wsptr[DCTSIZE*3] = dcval;
+ wsptr[DCTSIZE*4] = dcval;
+ wsptr[DCTSIZE*5] = dcval;
+ wsptr[DCTSIZE*6] = dcval;
+ wsptr[DCTSIZE*7] = dcval;
+
+ inptr++; /* advance pointers to next column */
+ quantptr++;
+ wsptr++;
+ continue;
+ }
+
+ /* Even part: reverse the even part of the forward DCT. */
+ /* The rotator is sqrt(2)*c(-6). */
+
+ z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
+ z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
+
+ z1 = MULTIPLY(z2 + z3, FIX_0_541196100);
+ tmp2 = z1 + MULTIPLY(z3, - FIX_1_847759065);
+ tmp3 = z1 + MULTIPLY(z2, FIX_0_765366865);
+
+ z2 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
+ z3 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
+
+ tmp0 = (z2 + z3) << CONST_BITS;
+ tmp1 = (z2 - z3) << CONST_BITS;
+
+ tmp10 = tmp0 + tmp3;
+ tmp13 = tmp0 - tmp3;
+ tmp11 = tmp1 + tmp2;
+ tmp12 = tmp1 - tmp2;
+
+ /* Odd part per figure 8; the matrix is unitary and hence its
+ * transpose is its inverse. i0..i3 are y7,y5,y3,y1 respectively.
+ */
+
+ tmp0 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
+ tmp1 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
+ tmp2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
+ tmp3 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
+
+ z1 = tmp0 + tmp3;
+ z2 = tmp1 + tmp2;
+ z3 = tmp0 + tmp2;
+ z4 = tmp1 + tmp3;
+ z5 = MULTIPLY(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */
+
+ tmp0 = MULTIPLY(tmp0, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */
+ tmp1 = MULTIPLY(tmp1, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */
+ tmp2 = MULTIPLY(tmp2, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */
+ tmp3 = MULTIPLY(tmp3, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */
+ z1 = MULTIPLY(z1, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */
+ z2 = MULTIPLY(z2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
+ z3 = MULTIPLY(z3, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
+ z4 = MULTIPLY(z4, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */
+
+ z3 += z5;
+ z4 += z5;
+
+ tmp0 += z1 + z3;
+ tmp1 += z2 + z4;
+ tmp2 += z2 + z3;
+ tmp3 += z1 + z4;
+
+ /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
+
+ wsptr[DCTSIZE*0] = (int) DESCALE(tmp10 + tmp3, CONST_BITS-PASS1_BITS);
+ wsptr[DCTSIZE*7] = (int) DESCALE(tmp10 - tmp3, CONST_BITS-PASS1_BITS);
+ wsptr[DCTSIZE*1] = (int) DESCALE(tmp11 + tmp2, CONST_BITS-PASS1_BITS);
+ wsptr[DCTSIZE*6] = (int) DESCALE(tmp11 - tmp2, CONST_BITS-PASS1_BITS);
+ wsptr[DCTSIZE*2] = (int) DESCALE(tmp12 + tmp1, CONST_BITS-PASS1_BITS);
+ wsptr[DCTSIZE*5] = (int) DESCALE(tmp12 - tmp1, CONST_BITS-PASS1_BITS);
+ wsptr[DCTSIZE*3] = (int) DESCALE(tmp13 + tmp0, CONST_BITS-PASS1_BITS);
+ wsptr[DCTSIZE*4] = (int) DESCALE(tmp13 - tmp0, CONST_BITS-PASS1_BITS);
+
+ inptr++; /* advance pointers to next column */
+ quantptr++;
+ wsptr++;
+ }
+
+ /* Pass 2: process rows from work array, store into output array. */
+ /* Note that we must descale the results by a factor of 8 == 2**3, */
+ /* and also undo the PASS1_BITS scaling. */
+
+ wsptr = workspace;
+ for (ctr = 0; ctr < DCTSIZE; ctr++) {
+ outptr = output_buf[ctr] + output_col;
+ /* Rows of zeroes can be exploited in the same way as we did with columns.
+ * However, the column calculation has created many nonzero AC terms, so
+ * the simplification applies less often (typically 5% to 10% of the time).
+ * On machines with very fast multiplication, it's possible that the
+ * test takes more time than it's worth. In that case this section
+ * may be commented out.
+ */
+
+#ifndef NO_ZERO_ROW_TEST
+ if (wsptr[1] == 0 && wsptr[2] == 0 && wsptr[3] == 0 && wsptr[4] == 0 &&
+ wsptr[5] == 0 && wsptr[6] == 0 && wsptr[7] == 0) {
+ /* AC terms all zero */
+ JSAMPLE dcval = range_limit[(int) DESCALE((INT32) wsptr[0], PASS1_BITS+3)
+ & RANGE_MASK];
+
+ outptr[0] = dcval;
+ outptr[1] = dcval;
+ outptr[2] = dcval;
+ outptr[3] = dcval;
+ outptr[4] = dcval;
+ outptr[5] = dcval;
+ outptr[6] = dcval;
+ outptr[7] = dcval;
+
+ wsptr += DCTSIZE; /* advance pointer to next row */
+ continue;
+ }
+#endif
+
+ /* Even part: reverse the even part of the forward DCT. */
+ /* The rotator is sqrt(2)*c(-6). */
+
+ z2 = (INT32) wsptr[2];
+ z3 = (INT32) wsptr[6];
+
+ z1 = MULTIPLY(z2 + z3, FIX_0_541196100);
+ tmp2 = z1 + MULTIPLY(z3, - FIX_1_847759065);
+ tmp3 = z1 + MULTIPLY(z2, FIX_0_765366865);
+
+ tmp0 = ((INT32) wsptr[0] + (INT32) wsptr[4]) << CONST_BITS;
+ tmp1 = ((INT32) wsptr[0] - (INT32) wsptr[4]) << CONST_BITS;
+
+ tmp10 = tmp0 + tmp3;
+ tmp13 = tmp0 - tmp3;
+ tmp11 = tmp1 + tmp2;
+ tmp12 = tmp1 - tmp2;
+
+ /* Odd part per figure 8; the matrix is unitary and hence its
+ * transpose is its inverse. i0..i3 are y7,y5,y3,y1 respectively.
+ */
+
+ tmp0 = (INT32) wsptr[7];
+ tmp1 = (INT32) wsptr[5];
+ tmp2 = (INT32) wsptr[3];
+ tmp3 = (INT32) wsptr[1];
+
+ z1 = tmp0 + tmp3;
+ z2 = tmp1 + tmp2;
+ z3 = tmp0 + tmp2;
+ z4 = tmp1 + tmp3;
+ z5 = MULTIPLY(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */
+
+ tmp0 = MULTIPLY(tmp0, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */
+ tmp1 = MULTIPLY(tmp1, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */
+ tmp2 = MULTIPLY(tmp2, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */
+ tmp3 = MULTIPLY(tmp3, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */
+ z1 = MULTIPLY(z1, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */
+ z2 = MULTIPLY(z2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
+ z3 = MULTIPLY(z3, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
+ z4 = MULTIPLY(z4, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */
+
+ z3 += z5;
+ z4 += z5;
+
+ tmp0 += z1 + z3;
+ tmp1 += z2 + z4;
+ tmp2 += z2 + z3;
+ tmp3 += z1 + z4;
+
+ /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
+
+ outptr[0] = range_limit[(int) DESCALE(tmp10 + tmp3,
+ CONST_BITS+PASS1_BITS+3)
+ & RANGE_MASK];
+ outptr[7] = range_limit[(int) DESCALE(tmp10 - tmp3,
+ CONST_BITS+PASS1_BITS+3)
+ & RANGE_MASK];
+ outptr[1] = range_limit[(int) DESCALE(tmp11 + tmp2,
+ CONST_BITS+PASS1_BITS+3)
+ & RANGE_MASK];
+ outptr[6] = range_limit[(int) DESCALE(tmp11 - tmp2,
+ CONST_BITS+PASS1_BITS+3)
+ & RANGE_MASK];
+ outptr[2] = range_limit[(int) DESCALE(tmp12 + tmp1,
+ CONST_BITS+PASS1_BITS+3)
+ & RANGE_MASK];
+ outptr[5] = range_limit[(int) DESCALE(tmp12 - tmp1,
+ CONST_BITS+PASS1_BITS+3)
+ & RANGE_MASK];
+ outptr[3] = range_limit[(int) DESCALE(tmp13 + tmp0,
+ CONST_BITS+PASS1_BITS+3)
+ & RANGE_MASK];
+ outptr[4] = range_limit[(int) DESCALE(tmp13 - tmp0,
+ CONST_BITS+PASS1_BITS+3)
+ & RANGE_MASK];
+
+ wsptr += DCTSIZE; /* advance pointer to next row */
+ }
+}
+
+#endif /* DCT_ISLOW_SUPPORTED */
--- /dev/null
+/*
+ * jidctred.c
+ *
+ * Copyright (C) 1994-1998, Thomas G. Lane.
+ * 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 inverse-DCT routines that produce reduced-size output:
+ * either 4x4, 2x2, or 1x1 pixels from an 8x8 DCT block.
+ *
+ * The implementation is based on the Loeffler, Ligtenberg and Moschytz (LL&M)
+ * algorithm used in jidctint.c. We simply replace each 8-to-8 1-D IDCT step
+ * with an 8-to-4 step that produces the four averages of two adjacent outputs
+ * (or an 8-to-2 step producing two averages of four outputs, for 2x2 output).
+ * These steps were derived by computing the corresponding values at the end
+ * of the normal LL&M code, then simplifying as much as possible.
+ *
+ * 1x1 is trivial: just take the DC coefficient divided by 8.
+ *
+ * See jidctint.c for additional comments.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h" /* Private declarations for DCT subsystem */
+
+#ifdef IDCT_SCALING_SUPPORTED
+
+
+/*
+ * This module is specialized to the case DCTSIZE = 8.
+ */
+
+#if DCTSIZE != 8
+ Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
+#endif
+
+
+/* Scaling is the same as in jidctint.c. */
+
+#if BITS_IN_JSAMPLE == 8
+#define CONST_BITS 13
+#define PASS1_BITS 2
+#else
+#define CONST_BITS 13
+#define PASS1_BITS 1 /* lose a little precision to avoid overflow */
+#endif
+
+/* Some C compilers fail to reduce "FIX(constant)" at compile time, thus
+ * causing a lot of useless floating-point operations at run time.
+ * To get around this we use the following pre-calculated constants.
+ * If you change CONST_BITS you may want to add appropriate values.
+ * (With a reasonable C compiler, you can just rely on the FIX() macro...)
+ */
+
+#if CONST_BITS == 13
+#define FIX_0_211164243 ((INT32) 1730) /* FIX(0.211164243) */
+#define FIX_0_509795579 ((INT32) 4176) /* FIX(0.509795579) */
+#define FIX_0_601344887 ((INT32) 4926) /* FIX(0.601344887) */
+#define FIX_0_720959822 ((INT32) 5906) /* FIX(0.720959822) */
+#define FIX_0_765366865 ((INT32) 6270) /* FIX(0.765366865) */
+#define FIX_0_850430095 ((INT32) 6967) /* FIX(0.850430095) */
+#define FIX_0_899976223 ((INT32) 7373) /* FIX(0.899976223) */
+#define FIX_1_061594337 ((INT32) 8697) /* FIX(1.061594337) */
+#define FIX_1_272758580 ((INT32) 10426) /* FIX(1.272758580) */
+#define FIX_1_451774981 ((INT32) 11893) /* FIX(1.451774981) */
+#define FIX_1_847759065 ((INT32) 15137) /* FIX(1.847759065) */
+#define FIX_2_172734803 ((INT32) 17799) /* FIX(2.172734803) */
+#define FIX_2_562915447 ((INT32) 20995) /* FIX(2.562915447) */
+#define FIX_3_624509785 ((INT32) 29692) /* FIX(3.624509785) */
+#else
+#define FIX_0_211164243 FIX(0.211164243)
+#define FIX_0_509795579 FIX(0.509795579)
+#define FIX_0_601344887 FIX(0.601344887)
+#define FIX_0_720959822 FIX(0.720959822)
+#define FIX_0_765366865 FIX(0.765366865)
+#define FIX_0_850430095 FIX(0.850430095)
+#define FIX_0_899976223 FIX(0.899976223)
+#define FIX_1_061594337 FIX(1.061594337)
+#define FIX_1_272758580 FIX(1.272758580)
+#define FIX_1_451774981 FIX(1.451774981)
+#define FIX_1_847759065 FIX(1.847759065)
+#define FIX_2_172734803 FIX(2.172734803)
+#define FIX_2_562915447 FIX(2.562915447)
+#define FIX_3_624509785 FIX(3.624509785)
+#endif
+
+
+/* Multiply an INT32 variable by an INT32 constant to yield an INT32 result.
+ * For 8-bit samples with the recommended scaling, all the variable
+ * and constant values involved are no more than 16 bits wide, so a
+ * 16x16->32 bit multiply can be used instead of a full 32x32 multiply.
+ * For 12-bit samples, a full 32-bit multiplication will be needed.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+#define MULTIPLY(var,const) MULTIPLY16C16(var,const)
+#else
+#define MULTIPLY(var,const) ((var) * (const))
+#endif
+
+
+/* Dequantize a coefficient by multiplying it by the multiplier-table
+ * entry; produce an int result. In this module, both inputs and result
+ * are 16 bits or less, so either int or short multiply will work.
+ */
+
+#define DEQUANTIZE(coef,quantval) (((ISLOW_MULT_TYPE) (coef)) * (quantval))
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients,
+ * producing a reduced-size 4x4 output block.
+ */
+
+GLOBAL(void)
+jpeg_idct_4x4 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JCOEFPTR coef_block,
+ JSAMPARRAY output_buf, JDIMENSION output_col)
+{
+ INT32 tmp0, tmp2, tmp10, tmp12;
+ INT32 z1, z2, z3, z4;
+ JCOEFPTR inptr;
+ ISLOW_MULT_TYPE * quantptr;
+ int * wsptr;
+ JSAMPROW outptr;
+ JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+ int ctr;
+ int workspace[DCTSIZE*4]; /* buffers data between passes */
+ SHIFT_TEMPS
+
+ /* Pass 1: process columns from input, store into work array. */
+
+ inptr = coef_block;
+ quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
+ wsptr = workspace;
+ for (ctr = DCTSIZE; ctr > 0; inptr++, quantptr++, wsptr++, ctr--) {
+ /* Don't bother to process column 4, because second pass won't use it */
+ if (ctr == DCTSIZE-4)
+ continue;
+ if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 &&
+ inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*5] == 0 &&
+ inptr[DCTSIZE*6] == 0 && inptr[DCTSIZE*7] == 0) {
+ /* AC terms all zero; we need not examine term 4 for 4x4 output */
+ int dcval = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) << PASS1_BITS;
+
+ wsptr[DCTSIZE*0] = dcval;
+ wsptr[DCTSIZE*1] = dcval;
+ wsptr[DCTSIZE*2] = dcval;
+ wsptr[DCTSIZE*3] = dcval;
+
+ continue;
+ }
+
+ /* Even part */
+
+ tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
+ tmp0 <<= (CONST_BITS+1);
+
+ z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
+ z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
+
+ tmp2 = MULTIPLY(z2, FIX_1_847759065) + MULTIPLY(z3, - FIX_0_765366865);
+
+ tmp10 = tmp0 + tmp2;
+ tmp12 = tmp0 - tmp2;
+
+ /* Odd part */
+
+ z1 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
+ z2 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
+ z3 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
+ z4 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
+
+ tmp0 = MULTIPLY(z1, - FIX_0_211164243) /* sqrt(2) * (c3-c1) */
+ + MULTIPLY(z2, FIX_1_451774981) /* sqrt(2) * (c3+c7) */
+ + MULTIPLY(z3, - FIX_2_172734803) /* sqrt(2) * (-c1-c5) */
+ + MULTIPLY(z4, FIX_1_061594337); /* sqrt(2) * (c5+c7) */
+
+ tmp2 = MULTIPLY(z1, - FIX_0_509795579) /* sqrt(2) * (c7-c5) */
+ + MULTIPLY(z2, - FIX_0_601344887) /* sqrt(2) * (c5-c1) */
+ + MULTIPLY(z3, FIX_0_899976223) /* sqrt(2) * (c3-c7) */
+ + MULTIPLY(z4, FIX_2_562915447); /* sqrt(2) * (c1+c3) */
+
+ /* Final output stage */
+
+ wsptr[DCTSIZE*0] = (int) DESCALE(tmp10 + tmp2, CONST_BITS-PASS1_BITS+1);
+ wsptr[DCTSIZE*3] = (int) DESCALE(tmp10 - tmp2, CONST_BITS-PASS1_BITS+1);
+ wsptr[DCTSIZE*1] = (int) DESCALE(tmp12 + tmp0, CONST_BITS-PASS1_BITS+1);
+ wsptr[DCTSIZE*2] = (int) DESCALE(tmp12 - tmp0, CONST_BITS-PASS1_BITS+1);
+ }
+
+ /* Pass 2: process 4 rows from work array, store into output array. */
+
+ wsptr = workspace;
+ for (ctr = 0; ctr < 4; ctr++) {
+ outptr = output_buf[ctr] + output_col;
+ /* It's not clear whether a zero row test is worthwhile here ... */
+
+#ifndef NO_ZERO_ROW_TEST
+ if (wsptr[1] == 0 && wsptr[2] == 0 && wsptr[3] == 0 &&
+ wsptr[5] == 0 && wsptr[6] == 0 && wsptr[7] == 0) {
+ /* AC terms all zero */
+ JSAMPLE dcval = range_limit[(int) DESCALE((INT32) wsptr[0], PASS1_BITS+3)
+ & RANGE_MASK];
+
+ outptr[0] = dcval;
+ outptr[1] = dcval;
+ outptr[2] = dcval;
+ outptr[3] = dcval;
+
+ wsptr += DCTSIZE; /* advance pointer to next row */
+ continue;
+ }
+#endif
+
+ /* Even part */
+
+ tmp0 = ((INT32) wsptr[0]) << (CONST_BITS+1);
+
+ tmp2 = MULTIPLY((INT32) wsptr[2], FIX_1_847759065)
+ + MULTIPLY((INT32) wsptr[6], - FIX_0_765366865);
+
+ tmp10 = tmp0 + tmp2;
+ tmp12 = tmp0 - tmp2;
+
+ /* Odd part */
+
+ z1 = (INT32) wsptr[7];
+ z2 = (INT32) wsptr[5];
+ z3 = (INT32) wsptr[3];
+ z4 = (INT32) wsptr[1];
+
+ tmp0 = MULTIPLY(z1, - FIX_0_211164243) /* sqrt(2) * (c3-c1) */
+ + MULTIPLY(z2, FIX_1_451774981) /* sqrt(2) * (c3+c7) */
+ + MULTIPLY(z3, - FIX_2_172734803) /* sqrt(2) * (-c1-c5) */
+ + MULTIPLY(z4, FIX_1_061594337); /* sqrt(2) * (c5+c7) */
+
+ tmp2 = MULTIPLY(z1, - FIX_0_509795579) /* sqrt(2) * (c7-c5) */
+ + MULTIPLY(z2, - FIX_0_601344887) /* sqrt(2) * (c5-c1) */
+ + MULTIPLY(z3, FIX_0_899976223) /* sqrt(2) * (c3-c7) */
+ + MULTIPLY(z4, FIX_2_562915447); /* sqrt(2) * (c1+c3) */
+
+ /* Final output stage */
+
+ outptr[0] = range_limit[(int) DESCALE(tmp10 + tmp2,
+ CONST_BITS+PASS1_BITS+3+1)
+ & RANGE_MASK];
+ outptr[3] = range_limit[(int) DESCALE(tmp10 - tmp2,
+ CONST_BITS+PASS1_BITS+3+1)
+ & RANGE_MASK];
+ outptr[1] = range_limit[(int) DESCALE(tmp12 + tmp0,
+ CONST_BITS+PASS1_BITS+3+1)
+ & RANGE_MASK];
+ outptr[2] = range_limit[(int) DESCALE(tmp12 - tmp0,
+ CONST_BITS+PASS1_BITS+3+1)
+ & RANGE_MASK];
+
+ wsptr += DCTSIZE; /* advance pointer to next row */
+ }
+}
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients,
+ * producing a reduced-size 2x2 output block.
+ */
+
+GLOBAL(void)
+jpeg_idct_2x2 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JCOEFPTR coef_block,
+ JSAMPARRAY output_buf, JDIMENSION output_col)
+{
+ INT32 tmp0, tmp10, z1;
+ JCOEFPTR inptr;
+ ISLOW_MULT_TYPE * quantptr;
+ int * wsptr;
+ JSAMPROW outptr;
+ JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+ int ctr;
+ int workspace[DCTSIZE*2]; /* buffers data between passes */
+ SHIFT_TEMPS
+
+ /* Pass 1: process columns from input, store into work array. */
+
+ inptr = coef_block;
+ quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
+ wsptr = workspace;
+ for (ctr = DCTSIZE; ctr > 0; inptr++, quantptr++, wsptr++, ctr--) {
+ /* Don't bother to process columns 2,4,6 */
+ if (ctr == DCTSIZE-2 || ctr == DCTSIZE-4 || ctr == DCTSIZE-6)
+ continue;
+ if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*3] == 0 &&
+ inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*7] == 0) {
+ /* AC terms all zero; we need not examine terms 2,4,6 for 2x2 output */
+ int dcval = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) << PASS1_BITS;
+
+ wsptr[DCTSIZE*0] = dcval;
+ wsptr[DCTSIZE*1] = dcval;
+
+ continue;
+ }
+
+ /* Even part */
+
+ z1 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
+ tmp10 = z1 << (CONST_BITS+2);
+
+ /* Odd part */
+
+ z1 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
+ tmp0 = MULTIPLY(z1, - FIX_0_720959822); /* sqrt(2) * (c7-c5+c3-c1) */
+ z1 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
+ tmp0 += MULTIPLY(z1, FIX_0_850430095); /* sqrt(2) * (-c1+c3+c5+c7) */
+ z1 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
+ tmp0 += MULTIPLY(z1, - FIX_1_272758580); /* sqrt(2) * (-c1+c3-c5-c7) */
+ z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
+ tmp0 += MULTIPLY(z1, FIX_3_624509785); /* sqrt(2) * (c1+c3+c5+c7) */
+
+ /* Final output stage */
+
+ wsptr[DCTSIZE*0] = (int) DESCALE(tmp10 + tmp0, CONST_BITS-PASS1_BITS+2);
+ wsptr[DCTSIZE*1] = (int) DESCALE(tmp10 - tmp0, CONST_BITS-PASS1_BITS+2);
+ }
+
+ /* Pass 2: process 2 rows from work array, store into output array. */
+
+ wsptr = workspace;
+ for (ctr = 0; ctr < 2; ctr++) {
+ outptr = output_buf[ctr] + output_col;
+ /* It's not clear whether a zero row test is worthwhile here ... */
+
+#ifndef NO_ZERO_ROW_TEST
+ if (wsptr[1] == 0 && wsptr[3] == 0 && wsptr[5] == 0 && wsptr[7] == 0) {
+ /* AC terms all zero */
+ JSAMPLE dcval = range_limit[(int) DESCALE((INT32) wsptr[0], PASS1_BITS+3)
+ & RANGE_MASK];
+
+ outptr[0] = dcval;
+ outptr[1] = dcval;
+
+ wsptr += DCTSIZE; /* advance pointer to next row */
+ continue;
+ }
+#endif
+
+ /* Even part */
+
+ tmp10 = ((INT32) wsptr[0]) << (CONST_BITS+2);
+
+ /* Odd part */
+
+ tmp0 = MULTIPLY((INT32) wsptr[7], - FIX_0_720959822) /* sqrt(2) * (c7-c5+c3-c1) */
+ + MULTIPLY((INT32) wsptr[5], FIX_0_850430095) /* sqrt(2) * (-c1+c3+c5+c7) */
+ + MULTIPLY((INT32) wsptr[3], - FIX_1_272758580) /* sqrt(2) * (-c1+c3-c5-c7) */
+ + MULTIPLY((INT32) wsptr[1], FIX_3_624509785); /* sqrt(2) * (c1+c3+c5+c7) */
+
+ /* Final output stage */
+
+ outptr[0] = range_limit[(int) DESCALE(tmp10 + tmp0,
+ CONST_BITS+PASS1_BITS+3+2)
+ & RANGE_MASK];
+ outptr[1] = range_limit[(int) DESCALE(tmp10 - tmp0,
+ CONST_BITS+PASS1_BITS+3+2)
+ & RANGE_MASK];
+
+ wsptr += DCTSIZE; /* advance pointer to next row */
+ }
+}
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients,
+ * producing a reduced-size 1x1 output block.
+ */
+
+GLOBAL(void)
+jpeg_idct_1x1 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JCOEFPTR coef_block,
+ JSAMPARRAY output_buf, JDIMENSION output_col)
+{
+ int dcval;
+ ISLOW_MULT_TYPE * quantptr;
+ JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+ SHIFT_TEMPS
+
+ /* We hardly need an inverse DCT routine for this: just take the
+ * average pixel value, which is one-eighth of the DC coefficient.
+ */
+ quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
+ dcval = DEQUANTIZE(coef_block[0], quantptr[0]);
+ dcval = (int) DESCALE((INT32) dcval, 3);
+
+ output_buf[0][output_col] = range_limit[dcval & RANGE_MASK];
+}
+
+#endif /* IDCT_SCALING_SUPPORTED */
--- /dev/null
+/*
+ * jinclude.h
+ *
+ * Copyright (C) 1991-1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file exists to provide a single place to fix any problems with
+ * including the wrong system include files. (Common problems are taken
+ * care of by the standard jconfig symbols, but on really weird systems
+ * you may have to edit this file.)
+ *
+ * NOTE: this file is NOT intended to be included by applications using the
+ * JPEG library. Most applications need only include jpeglib.h.
+ */
+
+
+/* Include auto-config file to find out which system include files we need. */
+
+#include "jconfig.h" /* auto configuration options */
+#define JCONFIG_INCLUDED /* so that jpeglib.h doesn't do it again */
+
+/*
+ * We need the NULL macro and size_t typedef.
+ * On an ANSI-conforming system it is sufficient to include <stddef.h>.
+ * Otherwise, we get them from <stdlib.h> or <stdio.h>; we may have to
+ * pull in <sys/types.h> as well.
+ * Note that the core JPEG library does not require <stdio.h>;
+ * only the default error handler and data source/destination modules do.
+ * But we must pull it in because of the references to FILE in jpeglib.h.
+ * You can remove those references if you want to compile without <stdio.h>.
+ */
+
+#ifdef HAVE_STDDEF_H
+#include <stddef.h>
+#endif
+
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#ifdef NEED_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+
+#include <stdio.h>
+
+/*
+ * We need memory copying and zeroing functions, plus strncpy().
+ * ANSI and System V implementations declare these in <string.h>.
+ * BSD doesn't have the mem() functions, but it does have bcopy()/bzero().
+ * Some systems may declare memset and memcpy in <memory.h>.
+ *
+ * NOTE: we assume the size parameters to these functions are of type size_t.
+ * Change the casts in these macros if not!
+ */
+
+#ifdef NEED_BSD_STRINGS
+
+#include <strings.h>
+#define MEMZERO(target,size) bzero((void *)(target), (size_t)(size))
+#define MEMCOPY(dest,src,size) bcopy((const void *)(src), (void *)(dest), (size_t)(size))
+
+#else /* not BSD, assume ANSI/SysV string lib */
+
+#include <string.h>
+#define MEMZERO(target,size) memset((void *)(target), 0, (size_t)(size))
+#define MEMCOPY(dest,src,size) memcpy((void *)(dest), (const void *)(src), (size_t)(size))
+
+#endif
+
+/*
+ * In ANSI C, and indeed any rational implementation, size_t is also the
+ * type returned by sizeof(). However, it seems there are some irrational
+ * implementations out there, in which sizeof() returns an int even though
+ * size_t is defined as long or unsigned long. To ensure consistent results
+ * we always use this SIZEOF() macro in place of using sizeof() directly.
+ */
+
+#define SIZEOF(object) ((size_t) sizeof(object))
+
+/*
+ * The modules that use fread() and fwrite() always invoke them through
+ * these macros. On some systems you may need to twiddle the argument casts.
+ * CAUTION: argument order is different from underlying functions!
+ */
+
+#define JFREAD(file,buf,sizeofbuf) \
+ ((size_t) fread((void *) (buf), (size_t) 1, (size_t) (sizeofbuf), (file)))
+#define JFWRITE(file,buf,sizeofbuf) \
+ ((size_t) fwrite((const void *) (buf), (size_t) 1, (size_t) (sizeofbuf), (file)))
--- /dev/null
+/*
+ * jmemmgr.c
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * 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 the JPEG system-independent memory management
+ * routines. This code is usable across a wide variety of machines; most
+ * of the system dependencies have been isolated in a separate file.
+ * The major functions provided here are:
+ * * pool-based allocation and freeing of memory;
+ * * policy decisions about how to divide available memory among the
+ * virtual arrays;
+ * * control logic for swapping virtual arrays between main memory and
+ * backing storage.
+ * The separate system-dependent file provides the actual backing-storage
+ * access code, and it contains the policy decision about how much total
+ * main memory to use.
+ * This file is system-dependent in the sense that some of its functions
+ * are unnecessary in some systems. For example, if there is enough virtual
+ * memory so that backing storage will never be used, much of the virtual
+ * array control logic could be removed. (Of course, if you have that much
+ * memory then you shouldn't care about a little bit of unused code...)
+ */
+
+#define JPEG_INTERNALS
+#define AM_MEMORY_MANAGER /* we define jvirt_Xarray_control structs */
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jmemsys.h" /* import the system-dependent declarations */
+
+#ifndef NO_GETENV
+#ifndef HAVE_STDLIB_H /* <stdlib.h> should declare getenv() */
+extern char * getenv JPP((const char * name));
+#endif
+#endif
+
+
+/*
+ * Some important notes:
+ * The allocation routines provided here must never return NULL.
+ * They should exit to error_exit if unsuccessful.
+ *
+ * It's not a good idea to try to merge the sarray and barray routines,
+ * even though they are textually almost the same, because samples are
+ * usually stored as bytes while coefficients are shorts or ints. Thus,
+ * in machines where byte pointers have a different representation from
+ * word pointers, the resulting machine code could not be the same.
+ */
+
+
+/*
+ * Many machines require storage alignment: longs must start on 4-byte
+ * boundaries, doubles on 8-byte boundaries, etc. On such machines, malloc()
+ * always returns pointers that are multiples of the worst-case alignment
+ * requirement, and we had better do so too.
+ * There isn't any really portable way to determine the worst-case alignment
+ * requirement. This module assumes that the alignment requirement is
+ * multiples of sizeof(ALIGN_TYPE).
+ * By default, we define ALIGN_TYPE as double. This is necessary on some
+ * workstations (where doubles really do need 8-byte alignment) and will work
+ * fine on nearly everything. If your machine has lesser alignment needs,
+ * you can save a few bytes by making ALIGN_TYPE smaller.
+ * The only place I know of where this will NOT work is certain Macintosh
+ * 680x0 compilers that define double as a 10-byte IEEE extended float.
+ * Doing 10-byte alignment is counterproductive because longwords won't be
+ * aligned well. Put "#define ALIGN_TYPE long" in jconfig.h if you have
+ * such a compiler.
+ */
+
+#ifndef ALIGN_TYPE /* so can override from jconfig.h */
+#define ALIGN_TYPE double
+#endif
+
+
+/*
+ * We allocate objects from "pools", where each pool is gotten with a single
+ * request to jpeg_get_small() or jpeg_get_large(). There is no per-object
+ * overhead within a pool, except for alignment padding. Each pool has a
+ * header with a link to the next pool of the same class.
+ * Small and large pool headers are identical except that the latter's
+ * link pointer must be FAR on 80x86 machines.
+ * Notice that the "real" header fields are union'ed with a dummy ALIGN_TYPE
+ * field. This forces the compiler to make SIZEOF(small_pool_hdr) a multiple
+ * of the alignment requirement of ALIGN_TYPE.
+ */
+
+typedef union small_pool_struct * small_pool_ptr;
+
+typedef union small_pool_struct {
+ struct {
+ small_pool_ptr next; /* next in list of pools */
+ size_t bytes_used; /* how many bytes already used within pool */
+ size_t bytes_left; /* bytes still available in this pool */
+ } hdr;
+ ALIGN_TYPE dummy; /* included in union to ensure alignment */
+} small_pool_hdr;
+
+typedef union large_pool_struct FAR * large_pool_ptr;
+
+typedef union large_pool_struct {
+ struct {
+ large_pool_ptr next; /* next in list of pools */
+ size_t bytes_used; /* how many bytes already used within pool */
+ size_t bytes_left; /* bytes still available in this pool */
+ } hdr;
+ ALIGN_TYPE dummy; /* included in union to ensure alignment */
+} large_pool_hdr;
+
+
+/*
+ * Here is the full definition of a memory manager object.
+ */
+
+typedef struct {
+ struct jpeg_memory_mgr pub; /* public fields */
+
+ /* Each pool identifier (lifetime class) names a linked list of pools. */
+ small_pool_ptr small_list[JPOOL_NUMPOOLS];
+ large_pool_ptr large_list[JPOOL_NUMPOOLS];
+
+ /* Since we only have one lifetime class of virtual arrays, only one
+ * linked list is necessary (for each datatype). Note that the virtual
+ * array control blocks being linked together are actually stored somewhere
+ * in the small-pool list.
+ */
+ jvirt_sarray_ptr virt_sarray_list;
+ jvirt_barray_ptr virt_barray_list;
+
+ /* This counts total space obtained from jpeg_get_small/large */
+ long total_space_allocated;
+
+ /* alloc_sarray and alloc_barray set this value for use by virtual
+ * array routines.
+ */
+ JDIMENSION last_rowsperchunk; /* from most recent alloc_sarray/barray */
+} my_memory_mgr;
+
+typedef my_memory_mgr * my_mem_ptr;
+
+
+/*
+ * The control blocks for virtual arrays.
+ * Note that these blocks are allocated in the "small" pool area.
+ * System-dependent info for the associated backing store (if any) is hidden
+ * inside the backing_store_info struct.
+ */
+
+struct jvirt_sarray_control {
+ JSAMPARRAY mem_buffer; /* => the in-memory buffer */
+ JDIMENSION rows_in_array; /* total virtual array height */
+ JDIMENSION samplesperrow; /* width of array (and of memory buffer) */
+ JDIMENSION maxaccess; /* max rows accessed by access_virt_sarray */
+ JDIMENSION rows_in_mem; /* height of memory buffer */
+ JDIMENSION rowsperchunk; /* allocation chunk size in mem_buffer */
+ JDIMENSION cur_start_row; /* first logical row # in the buffer */
+ JDIMENSION first_undef_row; /* row # of first uninitialized row */
+ boolean pre_zero; /* pre-zero mode requested? */
+ boolean dirty; /* do current buffer contents need written? */
+ boolean b_s_open; /* is backing-store data valid? */
+ jvirt_sarray_ptr next; /* link to next virtual sarray control block */
+ backing_store_info b_s_info; /* System-dependent control info */
+};
+
+struct jvirt_barray_control {
+ JBLOCKARRAY mem_buffer; /* => the in-memory buffer */
+ JDIMENSION rows_in_array; /* total virtual array height */
+ JDIMENSION blocksperrow; /* width of array (and of memory buffer) */
+ JDIMENSION maxaccess; /* max rows accessed by access_virt_barray */
+ JDIMENSION rows_in_mem; /* height of memory buffer */
+ JDIMENSION rowsperchunk; /* allocation chunk size in mem_buffer */
+ JDIMENSION cur_start_row; /* first logical row # in the buffer */
+ JDIMENSION first_undef_row; /* row # of first uninitialized row */
+ boolean pre_zero; /* pre-zero mode requested? */
+ boolean dirty; /* do current buffer contents need written? */
+ boolean b_s_open; /* is backing-store data valid? */
+ jvirt_barray_ptr next; /* link to next virtual barray control block */
+ backing_store_info b_s_info; /* System-dependent control info */
+};
+
+
+#ifdef MEM_STATS /* optional extra stuff for statistics */
+
+LOCAL(void)
+print_mem_stats (j_common_ptr cinfo, int pool_id)
+{
+ my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+ small_pool_ptr shdr_ptr;
+ large_pool_ptr lhdr_ptr;
+
+ /* Since this is only a debugging stub, we can cheat a little by using
+ * fprintf directly rather than going through the trace message code.
+ * This is helpful because message parm array can't handle longs.
+ */
+ fprintf(stderr, "Freeing pool %d, total space = %ld\n",
+ pool_id, mem->total_space_allocated);
+
+ for (lhdr_ptr = mem->large_list[pool_id]; lhdr_ptr != NULL;
+ lhdr_ptr = lhdr_ptr->hdr.next) {
+ fprintf(stderr, " Large chunk used %ld\n",
+ (long) lhdr_ptr->hdr.bytes_used);
+ }
+
+ for (shdr_ptr = mem->small_list[pool_id]; shdr_ptr != NULL;
+ shdr_ptr = shdr_ptr->hdr.next) {
+ fprintf(stderr, " Small chunk used %ld free %ld\n",
+ (long) shdr_ptr->hdr.bytes_used,
+ (long) shdr_ptr->hdr.bytes_left);
+ }
+}
+
+#endif /* MEM_STATS */
+
+
+LOCAL(void)
+out_of_memory (j_common_ptr cinfo, int which)
+/* Report an out-of-memory error and stop execution */
+/* If we compiled MEM_STATS support, report alloc requests before dying */
+{
+#ifdef MEM_STATS
+ cinfo->err->trace_level = 2; /* force self_destruct to report stats */
+#endif
+ ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, which);
+}
+
+
+/*
+ * Allocation of "small" objects.
+ *
+ * For these, we use pooled storage. When a new pool must be created,
+ * we try to get enough space for the current request plus a "slop" factor,
+ * where the slop will be the amount of leftover space in the new pool.
+ * The speed vs. space tradeoff is largely determined by the slop values.
+ * A different slop value is provided for each pool class (lifetime),
+ * and we also distinguish the first pool of a class from later ones.
+ * NOTE: the values given work fairly well on both 16- and 32-bit-int
+ * machines, but may be too small if longs are 64 bits or more.
+ */
+
+static const size_t first_pool_slop[JPOOL_NUMPOOLS] =
+{
+ 1600, /* first PERMANENT pool */
+ 16000 /* first IMAGE pool */
+};
+
+static const size_t extra_pool_slop[JPOOL_NUMPOOLS] =
+{
+ 0, /* additional PERMANENT pools */
+ 5000 /* additional IMAGE pools */
+};
+
+#define MIN_SLOP 50 /* greater than 0 to avoid futile looping */
+
+
+METHODDEF(void *)
+alloc_small (j_common_ptr cinfo, int pool_id, size_t sizeofobject)
+/* Allocate a "small" object */
+{
+ my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+ small_pool_ptr hdr_ptr, prev_hdr_ptr;
+ char * data_ptr;
+ size_t odd_bytes, min_request, slop;
+
+ /* Check for unsatisfiable request (do now to ensure no overflow below) */
+ if (sizeofobject > (size_t) (MAX_ALLOC_CHUNK-SIZEOF(small_pool_hdr)))
+ out_of_memory(cinfo, 1); /* request exceeds malloc's ability */
+
+ /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */
+ odd_bytes = sizeofobject % SIZEOF(ALIGN_TYPE);
+ if (odd_bytes > 0)
+ sizeofobject += SIZEOF(ALIGN_TYPE) - odd_bytes;
+
+ /* See if space is available in any existing pool */
+ if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS)
+ ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */
+ prev_hdr_ptr = NULL;
+ hdr_ptr = mem->small_list[pool_id];
+ while (hdr_ptr != NULL) {
+ if (hdr_ptr->hdr.bytes_left >= sizeofobject)
+ break; /* found pool with enough space */
+ prev_hdr_ptr = hdr_ptr;
+ hdr_ptr = hdr_ptr->hdr.next;
+ }
+
+ /* Time to make a new pool? */
+ if (hdr_ptr == NULL) {
+ /* min_request is what we need now, slop is what will be leftover */
+ min_request = sizeofobject + SIZEOF(small_pool_hdr);
+ if (prev_hdr_ptr == NULL) /* first pool in class? */
+ slop = first_pool_slop[pool_id];
+ else
+ slop = extra_pool_slop[pool_id];
+ /* Don't ask for more than MAX_ALLOC_CHUNK */
+ if (slop > (size_t) (MAX_ALLOC_CHUNK-min_request))
+ slop = (size_t) (MAX_ALLOC_CHUNK-min_request);
+ /* Try to get space, if fail reduce slop and try again */
+ for (;;) {
+ hdr_ptr = (small_pool_ptr) jpeg_get_small(cinfo, min_request + slop);
+ if (hdr_ptr != NULL)
+ break;
+ slop /= 2;
+ if (slop < MIN_SLOP) /* give up when it gets real small */
+ out_of_memory(cinfo, 2); /* jpeg_get_small failed */
+ }
+ mem->total_space_allocated += min_request + slop;
+ /* Success, initialize the new pool header and add to end of list */
+ hdr_ptr->hdr.next = NULL;
+ hdr_ptr->hdr.bytes_used = 0;
+ hdr_ptr->hdr.bytes_left = sizeofobject + slop;
+ if (prev_hdr_ptr == NULL) /* first pool in class? */
+ mem->small_list[pool_id] = hdr_ptr;
+ else
+ prev_hdr_ptr->hdr.next = hdr_ptr;
+ }
+
+ /* OK, allocate the object from the current pool */
+ data_ptr = (char *) (hdr_ptr + 1); /* point to first data byte in pool */
+ data_ptr += hdr_ptr->hdr.bytes_used; /* point to place for object */
+ hdr_ptr->hdr.bytes_used += sizeofobject;
+ hdr_ptr->hdr.bytes_left -= sizeofobject;
+
+ return (void *) data_ptr;
+}
+
+
+/*
+ * Allocation of "large" objects.
+ *
+ * The external semantics of these are the same as "small" objects,
+ * except that FAR pointers are used on 80x86. However the pool
+ * management heuristics are quite different. We assume that each
+ * request is large enough that it may as well be passed directly to
+ * jpeg_get_large; the pool management just links everything together
+ * so that we can free it all on demand.
+ * Note: the major use of "large" objects is in JSAMPARRAY and JBLOCKARRAY
+ * structures. The routines that create these structures (see below)
+ * deliberately bunch rows together to ensure a large request size.
+ */
+
+METHODDEF(void FAR *)
+alloc_large (j_common_ptr cinfo, int pool_id, size_t sizeofobject)
+/* Allocate a "large" object */
+{
+ my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+ large_pool_ptr hdr_ptr;
+ size_t odd_bytes;
+
+ /* Check for unsatisfiable request (do now to ensure no overflow below) */
+ if (sizeofobject > (size_t) (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)))
+ out_of_memory(cinfo, 3); /* request exceeds malloc's ability */
+
+ /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */
+ odd_bytes = sizeofobject % SIZEOF(ALIGN_TYPE);
+ if (odd_bytes > 0)
+ sizeofobject += SIZEOF(ALIGN_TYPE) - odd_bytes;
+
+ /* Always make a new pool */
+ if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS)
+ ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */
+
+ hdr_ptr = (large_pool_ptr) jpeg_get_large(cinfo, sizeofobject +
+ SIZEOF(large_pool_hdr));
+ if (hdr_ptr == NULL)
+ out_of_memory(cinfo, 4); /* jpeg_get_large failed */
+ mem->total_space_allocated += sizeofobject + SIZEOF(large_pool_hdr);
+
+ /* Success, initialize the new pool header and add to list */
+ hdr_ptr->hdr.next = mem->large_list[pool_id];
+ /* We maintain space counts in each pool header for statistical purposes,
+ * even though they are not needed for allocation.
+ */
+ hdr_ptr->hdr.bytes_used = sizeofobject;
+ hdr_ptr->hdr.bytes_left = 0;
+ mem->large_list[pool_id] = hdr_ptr;
+
+ return (void FAR *) (hdr_ptr + 1); /* point to first data byte in pool */
+}
+
+
+/*
+ * Creation of 2-D sample arrays.
+ * The pointers are in near heap, the samples themselves in FAR heap.
+ *
+ * To minimize allocation overhead and to allow I/O of large contiguous
+ * blocks, we allocate the sample rows in groups of as many rows as possible
+ * without exceeding MAX_ALLOC_CHUNK total bytes per allocation request.
+ * NB: the virtual array control routines, later in this file, know about
+ * this chunking of rows. The rowsperchunk value is left in the mem manager
+ * object so that it can be saved away if this sarray is the workspace for
+ * a virtual array.
+ */
+
+METHODDEF(JSAMPARRAY)
+alloc_sarray (j_common_ptr cinfo, int pool_id,
+ JDIMENSION samplesperrow, JDIMENSION numrows)
+/* Allocate a 2-D sample array */
+{
+ my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+ JSAMPARRAY result;
+ JSAMPROW workspace;
+ JDIMENSION rowsperchunk, currow, i;
+ long ltemp;
+
+ /* Calculate max # of rows allowed in one allocation chunk */
+ ltemp = (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)) /
+ ((long) samplesperrow * SIZEOF(JSAMPLE));
+ if (ltemp <= 0)
+ ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
+ if (ltemp < (long) numrows)
+ rowsperchunk = (JDIMENSION) ltemp;
+ else
+ rowsperchunk = numrows;
+ mem->last_rowsperchunk = rowsperchunk;
+
+ /* Get space for row pointers (small object) */
+ result = (JSAMPARRAY) alloc_small(cinfo, pool_id,
+ (size_t) (numrows * SIZEOF(JSAMPROW)));
+
+ /* Get the rows themselves (large objects) */
+ currow = 0;
+ while (currow < numrows) {
+ rowsperchunk = MIN(rowsperchunk, numrows - currow);
+ workspace = (JSAMPROW) alloc_large(cinfo, pool_id,
+ (size_t) ((size_t) rowsperchunk * (size_t) samplesperrow
+ * SIZEOF(JSAMPLE)));
+ for (i = rowsperchunk; i > 0; i--) {
+ result[currow++] = workspace;
+ workspace += samplesperrow;
+ }
+ }
+
+ return result;
+}
+
+
+/*
+ * Creation of 2-D coefficient-block arrays.
+ * This is essentially the same as the code for sample arrays, above.
+ */
+
+METHODDEF(JBLOCKARRAY)
+alloc_barray (j_common_ptr cinfo, int pool_id,
+ JDIMENSION blocksperrow, JDIMENSION numrows)
+/* Allocate a 2-D coefficient-block array */
+{
+ my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+ JBLOCKARRAY result;
+ JBLOCKROW workspace;
+ JDIMENSION rowsperchunk, currow, i;
+ long ltemp;
+
+ /* Calculate max # of rows allowed in one allocation chunk */
+ ltemp = (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)) /
+ ((long) blocksperrow * SIZEOF(JBLOCK));
+ if (ltemp <= 0)
+ ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
+ if (ltemp < (long) numrows)
+ rowsperchunk = (JDIMENSION) ltemp;
+ else
+ rowsperchunk = numrows;
+ mem->last_rowsperchunk = rowsperchunk;
+
+ /* Get space for row pointers (small object) */
+ result = (JBLOCKARRAY) alloc_small(cinfo, pool_id,
+ (size_t) (numrows * SIZEOF(JBLOCKROW)));
+
+ /* Get the rows themselves (large objects) */
+ currow = 0;
+ while (currow < numrows) {
+ rowsperchunk = MIN(rowsperchunk, numrows - currow);
+ workspace = (JBLOCKROW) alloc_large(cinfo, pool_id,
+ (size_t) ((size_t) rowsperchunk * (size_t) blocksperrow
+ * SIZEOF(JBLOCK)));
+ for (i = rowsperchunk; i > 0; i--) {
+ result[currow++] = workspace;
+ workspace += blocksperrow;
+ }
+ }
+
+ return result;
+}
+
+
+/*
+ * About virtual array management:
+ *
+ * The above "normal" array routines are only used to allocate strip buffers
+ * (as wide as the image, but just a few rows high). Full-image-sized buffers
+ * are handled as "virtual" arrays. The array is still accessed a strip at a
+ * time, but the memory manager must save the whole array for repeated
+ * accesses. The intended implementation is that there is a strip buffer in
+ * memory (as high as is possible given the desired memory limit), plus a
+ * backing file that holds the rest of the array.
+ *
+ * The request_virt_array routines are told the total size of the image and
+ * the maximum number of rows that will be accessed at once. The in-memory
+ * buffer must be at least as large as the maxaccess value.
+ *
+ * The request routines create control blocks but not the in-memory buffers.
+ * That is postponed until realize_virt_arrays is called. At that time the
+ * total amount of space needed is known (approximately, anyway), so free
+ * memory can be divided up fairly.
+ *
+ * The access_virt_array routines are responsible for making a specific strip
+ * area accessible (after reading or writing the backing file, if necessary).
+ * Note that the access routines are told whether the caller intends to modify
+ * the accessed strip; during a read-only pass this saves having to rewrite
+ * data to disk. The access routines are also responsible for pre-zeroing
+ * any newly accessed rows, if pre-zeroing was requested.
+ *
+ * In current usage, the access requests are usually for nonoverlapping
+ * strips; that is, successive access start_row numbers differ by exactly
+ * num_rows = maxaccess. This means we can get good performance with simple
+ * buffer dump/reload logic, by making the in-memory buffer be a multiple
+ * of the access height; then there will never be accesses across bufferload
+ * boundaries. The code will still work with overlapping access requests,
+ * but it doesn't handle bufferload overlaps very efficiently.
+ */
+
+
+METHODDEF(jvirt_sarray_ptr)
+request_virt_sarray (j_common_ptr cinfo, int pool_id, boolean pre_zero,
+ JDIMENSION samplesperrow, JDIMENSION numrows,
+ JDIMENSION maxaccess)
+/* Request a virtual 2-D sample array */
+{
+ my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+ jvirt_sarray_ptr result;
+
+ /* Only IMAGE-lifetime virtual arrays are currently supported */
+ if (pool_id != JPOOL_IMAGE)
+ ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */
+
+ /* get control block */
+ result = (jvirt_sarray_ptr) alloc_small(cinfo, pool_id,
+ SIZEOF(struct jvirt_sarray_control));
+
+ result->mem_buffer = NULL; /* marks array not yet realized */
+ result->rows_in_array = numrows;
+ result->samplesperrow = samplesperrow;
+ result->maxaccess = maxaccess;
+ result->pre_zero = pre_zero;
+ result->b_s_open = FALSE; /* no associated backing-store object */
+ result->next = mem->virt_sarray_list; /* add to list of virtual arrays */
+ mem->virt_sarray_list = result;
+
+ return result;
+}
+
+
+METHODDEF(jvirt_barray_ptr)
+request_virt_barray (j_common_ptr cinfo, int pool_id, boolean pre_zero,
+ JDIMENSION blocksperrow, JDIMENSION numrows,
+ JDIMENSION maxaccess)
+/* Request a virtual 2-D coefficient-block array */
+{
+ my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+ jvirt_barray_ptr result;
+
+ /* Only IMAGE-lifetime virtual arrays are currently supported */
+ if (pool_id != JPOOL_IMAGE)
+ ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */
+
+ /* get control block */
+ result = (jvirt_barray_ptr) alloc_small(cinfo, pool_id,
+ SIZEOF(struct jvirt_barray_control));
+
+ result->mem_buffer = NULL; /* marks array not yet realized */
+ result->rows_in_array = numrows;
+ result->blocksperrow = blocksperrow;
+ result->maxaccess = maxaccess;
+ result->pre_zero = pre_zero;
+ result->b_s_open = FALSE; /* no associated backing-store object */
+ result->next = mem->virt_barray_list; /* add to list of virtual arrays */
+ mem->virt_barray_list = result;
+
+ return result;
+}
+
+
+METHODDEF(void)
+realize_virt_arrays (j_common_ptr cinfo)
+/* Allocate the in-memory buffers for any unrealized virtual arrays */
+{
+ my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+ long space_per_minheight, maximum_space, avail_mem;
+ long minheights, max_minheights;
+ jvirt_sarray_ptr sptr;
+ jvirt_barray_ptr bptr;
+
+ /* Compute the minimum space needed (maxaccess rows in each buffer)
+ * and the maximum space needed (full image height in each buffer).
+ * These may be of use to the system-dependent jpeg_mem_available routine.
+ */
+ space_per_minheight = 0;
+ maximum_space = 0;
+ for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) {
+ if (sptr->mem_buffer == NULL) { /* if not realized yet */
+ space_per_minheight += (long) sptr->maxaccess *
+ (long) sptr->samplesperrow * SIZEOF(JSAMPLE);
+ maximum_space += (long) sptr->rows_in_array *
+ (long) sptr->samplesperrow * SIZEOF(JSAMPLE);
+ }
+ }
+ for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) {
+ if (bptr->mem_buffer == NULL) { /* if not realized yet */
+ space_per_minheight += (long) bptr->maxaccess *
+ (long) bptr->blocksperrow * SIZEOF(JBLOCK);
+ maximum_space += (long) bptr->rows_in_array *
+ (long) bptr->blocksperrow * SIZEOF(JBLOCK);
+ }
+ }
+
+ if (space_per_minheight <= 0)
+ return; /* no unrealized arrays, no work */
+
+ /* Determine amount of memory to actually use; this is system-dependent. */
+ avail_mem = jpeg_mem_available(cinfo, space_per_minheight, maximum_space,
+ mem->total_space_allocated);
+
+ /* If the maximum space needed is available, make all the buffers full
+ * height; otherwise parcel it out with the same number of minheights
+ * in each buffer.
+ */
+ if (avail_mem >= maximum_space)
+ max_minheights = 1000000000L;
+ else {
+ max_minheights = avail_mem / space_per_minheight;
+ /* If there doesn't seem to be enough space, try to get the minimum
+ * anyway. This allows a "stub" implementation of jpeg_mem_available().
+ */
+ if (max_minheights <= 0)
+ max_minheights = 1;
+ }
+
+ /* Allocate the in-memory buffers and initialize backing store as needed. */
+
+ for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) {
+ if (sptr->mem_buffer == NULL) { /* if not realized yet */
+ minheights = ((long) sptr->rows_in_array - 1L) / sptr->maxaccess + 1L;
+ if (minheights <= max_minheights) {
+ /* This buffer fits in memory */
+ sptr->rows_in_mem = sptr->rows_in_array;
+ } else {
+ /* It doesn't fit in memory, create backing store. */
+ sptr->rows_in_mem = (JDIMENSION) (max_minheights * sptr->maxaccess);
+ jpeg_open_backing_store(cinfo, & sptr->b_s_info,
+ (long) sptr->rows_in_array *
+ (long) sptr->samplesperrow *
+ (long) SIZEOF(JSAMPLE));
+ sptr->b_s_open = TRUE;
+ }
+ sptr->mem_buffer = alloc_sarray(cinfo, JPOOL_IMAGE,
+ sptr->samplesperrow, sptr->rows_in_mem);
+ sptr->rowsperchunk = mem->last_rowsperchunk;
+ sptr->cur_start_row = 0;
+ sptr->first_undef_row = 0;
+ sptr->dirty = FALSE;
+ }
+ }
+
+ for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) {
+ if (bptr->mem_buffer == NULL) { /* if not realized yet */
+ minheights = ((long) bptr->rows_in_array - 1L) / bptr->maxaccess + 1L;
+ if (minheights <= max_minheights) {
+ /* This buffer fits in memory */
+ bptr->rows_in_mem = bptr->rows_in_array;
+ } else {
+ /* It doesn't fit in memory, create backing store. */
+ bptr->rows_in_mem = (JDIMENSION) (max_minheights * bptr->maxaccess);
+ jpeg_open_backing_store(cinfo, & bptr->b_s_info,
+ (long) bptr->rows_in_array *
+ (long) bptr->blocksperrow *
+ (long) SIZEOF(JBLOCK));
+ bptr->b_s_open = TRUE;
+ }
+ bptr->mem_buffer = alloc_barray(cinfo, JPOOL_IMAGE,
+ bptr->blocksperrow, bptr->rows_in_mem);
+ bptr->rowsperchunk = mem->last_rowsperchunk;
+ bptr->cur_start_row = 0;
+ bptr->first_undef_row = 0;
+ bptr->dirty = FALSE;
+ }
+ }
+}
+
+
+LOCAL(void)
+do_sarray_io (j_common_ptr cinfo, jvirt_sarray_ptr ptr, boolean writing)
+/* Do backing store read or write of a virtual sample array */
+{
+ long bytesperrow, file_offset, byte_count, rows, thisrow, i;
+
+ bytesperrow = (long) ptr->samplesperrow * SIZEOF(JSAMPLE);
+ file_offset = ptr->cur_start_row * bytesperrow;
+ /* Loop to read or write each allocation chunk in mem_buffer */
+ for (i = 0; i < (long) ptr->rows_in_mem; i += ptr->rowsperchunk) {
+ /* One chunk, but check for short chunk at end of buffer */
+ rows = MIN((long) ptr->rowsperchunk, (long) ptr->rows_in_mem - i);
+ /* Transfer no more than is currently defined */
+ thisrow = (long) ptr->cur_start_row + i;
+ rows = MIN(rows, (long) ptr->first_undef_row - thisrow);
+ /* Transfer no more than fits in file */
+ rows = MIN(rows, (long) ptr->rows_in_array - thisrow);
+ if (rows <= 0) /* this chunk might be past end of file! */
+ break;
+ byte_count = rows * bytesperrow;
+ if (writing)
+ (*ptr->b_s_info.write_backing_store) (cinfo, & ptr->b_s_info,
+ (void FAR *) ptr->mem_buffer[i],
+ file_offset, byte_count);
+ else
+ (*ptr->b_s_info.read_backing_store) (cinfo, & ptr->b_s_info,
+ (void FAR *) ptr->mem_buffer[i],
+ file_offset, byte_count);
+ file_offset += byte_count;
+ }
+}
+
+
+LOCAL(void)
+do_barray_io (j_common_ptr cinfo, jvirt_barray_ptr ptr, boolean writing)
+/* Do backing store read or write of a virtual coefficient-block array */
+{
+ long bytesperrow, file_offset, byte_count, rows, thisrow, i;
+
+ bytesperrow = (long) ptr->blocksperrow * SIZEOF(JBLOCK);
+ file_offset = ptr->cur_start_row * bytesperrow;
+ /* Loop to read or write each allocation chunk in mem_buffer */
+ for (i = 0; i < (long) ptr->rows_in_mem; i += ptr->rowsperchunk) {
+ /* One chunk, but check for short chunk at end of buffer */
+ rows = MIN((long) ptr->rowsperchunk, (long) ptr->rows_in_mem - i);
+ /* Transfer no more than is currently defined */
+ thisrow = (long) ptr->cur_start_row + i;
+ rows = MIN(rows, (long) ptr->first_undef_row - thisrow);
+ /* Transfer no more than fits in file */
+ rows = MIN(rows, (long) ptr->rows_in_array - thisrow);
+ if (rows <= 0) /* this chunk might be past end of file! */
+ break;
+ byte_count = rows * bytesperrow;
+ if (writing)
+ (*ptr->b_s_info.write_backing_store) (cinfo, & ptr->b_s_info,
+ (void FAR *) ptr->mem_buffer[i],
+ file_offset, byte_count);
+ else
+ (*ptr->b_s_info.read_backing_store) (cinfo, & ptr->b_s_info,
+ (void FAR *) ptr->mem_buffer[i],
+ file_offset, byte_count);
+ file_offset += byte_count;
+ }
+}
+
+
+METHODDEF(JSAMPARRAY)
+access_virt_sarray (j_common_ptr cinfo, jvirt_sarray_ptr ptr,
+ JDIMENSION start_row, JDIMENSION num_rows,
+ boolean writable)
+/* Access the part of a virtual sample array starting at start_row */
+/* and extending for num_rows rows. writable is true if */
+/* caller intends to modify the accessed area. */
+{
+ JDIMENSION end_row = start_row + num_rows;
+ JDIMENSION undef_row;
+
+ /* debugging check */
+ if (end_row > ptr->rows_in_array || num_rows > ptr->maxaccess ||
+ ptr->mem_buffer == NULL)
+ ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+
+ /* Make the desired part of the virtual array accessible */
+ if (start_row < ptr->cur_start_row ||
+ end_row > ptr->cur_start_row+ptr->rows_in_mem) {
+ if (! ptr->b_s_open)
+ ERREXIT(cinfo, JERR_VIRTUAL_BUG);
+ /* Flush old buffer contents if necessary */
+ if (ptr->dirty) {
+ do_sarray_io(cinfo, ptr, TRUE);
+ ptr->dirty = FALSE;
+ }
+ /* Decide what part of virtual array to access.
+ * Algorithm: if target address > current window, assume forward scan,
+ * load starting at target address. If target address < current window,
+ * assume backward scan, load so that target area is top of window.
+ * Note that when switching from forward write to forward read, will have
+ * start_row = 0, so the limiting case applies and we load from 0 anyway.
+ */
+ if (start_row > ptr->cur_start_row) {
+ ptr->cur_start_row = start_row;
+ } else {
+ /* use long arithmetic here to avoid overflow & unsigned problems */
+ long ltemp;
+
+ ltemp = (long) end_row - (long) ptr->rows_in_mem;
+ if (ltemp < 0)
+ ltemp = 0; /* don't fall off front end of file */
+ ptr->cur_start_row = (JDIMENSION) ltemp;
+ }
+ /* Read in the selected part of the array.
+ * During the initial write pass, we will do no actual read
+ * because the selected part is all undefined.
+ */
+ do_sarray_io(cinfo, ptr, FALSE);
+ }
+ /* Ensure the accessed part of the array is defined; prezero if needed.
+ * To improve locality of access, we only prezero the part of the array
+ * that the caller is about to access, not the entire in-memory array.
+ */
+ if (ptr->first_undef_row < end_row) {
+ if (ptr->first_undef_row < start_row) {
+ if (writable) /* writer skipped over a section of array */
+ ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+ undef_row = start_row; /* but reader is allowed to read ahead */
+ } else {
+ undef_row = ptr->first_undef_row;
+ }
+ if (writable)
+ ptr->first_undef_row = end_row;
+ if (ptr->pre_zero) {
+ size_t bytesperrow = (size_t) ptr->samplesperrow * SIZEOF(JSAMPLE);
+ undef_row -= ptr->cur_start_row; /* make indexes relative to buffer */
+ end_row -= ptr->cur_start_row;
+ while (undef_row < end_row) {
+ jzero_far((void FAR *) ptr->mem_buffer[undef_row], bytesperrow);
+ undef_row++;
+ }
+ } else {
+ if (! writable) /* reader looking at undefined data */
+ ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+ }
+ }
+ /* Flag the buffer dirty if caller will write in it */
+ if (writable)
+ ptr->dirty = TRUE;
+ /* Return address of proper part of the buffer */
+ return ptr->mem_buffer + (start_row - ptr->cur_start_row);
+}
+
+
+METHODDEF(JBLOCKARRAY)
+access_virt_barray (j_common_ptr cinfo, jvirt_barray_ptr ptr,
+ JDIMENSION start_row, JDIMENSION num_rows,
+ boolean writable)
+/* Access the part of a virtual block array starting at start_row */
+/* and extending for num_rows rows. writable is true if */
+/* caller intends to modify the accessed area. */
+{
+ JDIMENSION end_row = start_row + num_rows;
+ JDIMENSION undef_row;
+
+ /* debugging check */
+ if (end_row > ptr->rows_in_array || num_rows > ptr->maxaccess ||
+ ptr->mem_buffer == NULL)
+ ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+
+ /* Make the desired part of the virtual array accessible */
+ if (start_row < ptr->cur_start_row ||
+ end_row > ptr->cur_start_row+ptr->rows_in_mem) {
+ if (! ptr->b_s_open)
+ ERREXIT(cinfo, JERR_VIRTUAL_BUG);
+ /* Flush old buffer contents if necessary */
+ if (ptr->dirty) {
+ do_barray_io(cinfo, ptr, TRUE);
+ ptr->dirty = FALSE;
+ }
+ /* Decide what part of virtual array to access.
+ * Algorithm: if target address > current window, assume forward scan,
+ * load starting at target address. If target address < current window,
+ * assume backward scan, load so that target area is top of window.
+ * Note that when switching from forward write to forward read, will have
+ * start_row = 0, so the limiting case applies and we load from 0 anyway.
+ */
+ if (start_row > ptr->cur_start_row) {
+ ptr->cur_start_row = start_row;
+ } else {
+ /* use long arithmetic here to avoid overflow & unsigned problems */
+ long ltemp;
+
+ ltemp = (long) end_row - (long) ptr->rows_in_mem;
+ if (ltemp < 0)
+ ltemp = 0; /* don't fall off front end of file */
+ ptr->cur_start_row = (JDIMENSION) ltemp;
+ }
+ /* Read in the selected part of the array.
+ * During the initial write pass, we will do no actual read
+ * because the selected part is all undefined.
+ */
+ do_barray_io(cinfo, ptr, FALSE);
+ }
+ /* Ensure the accessed part of the array is defined; prezero if needed.
+ * To improve locality of access, we only prezero the part of the array
+ * that the caller is about to access, not the entire in-memory array.
+ */
+ if (ptr->first_undef_row < end_row) {
+ if (ptr->first_undef_row < start_row) {
+ if (writable) /* writer skipped over a section of array */
+ ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+ undef_row = start_row; /* but reader is allowed to read ahead */
+ } else {
+ undef_row = ptr->first_undef_row;
+ }
+ if (writable)
+ ptr->first_undef_row = end_row;
+ if (ptr->pre_zero) {
+ size_t bytesperrow = (size_t) ptr->blocksperrow * SIZEOF(JBLOCK);
+ undef_row -= ptr->cur_start_row; /* make indexes relative to buffer */
+ end_row -= ptr->cur_start_row;
+ while (undef_row < end_row) {
+ jzero_far((void FAR *) ptr->mem_buffer[undef_row], bytesperrow);
+ undef_row++;
+ }
+ } else {
+ if (! writable) /* reader looking at undefined data */
+ ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+ }
+ }
+ /* Flag the buffer dirty if caller will write in it */
+ if (writable)
+ ptr->dirty = TRUE;
+ /* Return address of proper part of the buffer */
+ return ptr->mem_buffer + (start_row - ptr->cur_start_row);
+}
+
+
+/*
+ * Release all objects belonging to a specified pool.
+ */
+
+METHODDEF(void)
+free_pool (j_common_ptr cinfo, int pool_id)
+{
+ my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+ small_pool_ptr shdr_ptr;
+ large_pool_ptr lhdr_ptr;
+ size_t space_freed;
+
+ if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS)
+ ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */
+
+#ifdef MEM_STATS
+ if (cinfo->err->trace_level > 1)
+ print_mem_stats(cinfo, pool_id); /* print pool's memory usage statistics */
+#endif
+
+ /* If freeing IMAGE pool, close any virtual arrays first */
+ if (pool_id == JPOOL_IMAGE) {
+ jvirt_sarray_ptr sptr;
+ jvirt_barray_ptr bptr;
+
+ for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) {
+ if (sptr->b_s_open) { /* there may be no backing store */
+ sptr->b_s_open = FALSE; /* prevent recursive close if error */
+ (*sptr->b_s_info.close_backing_store) (cinfo, & sptr->b_s_info);
+ }
+ }
+ mem->virt_sarray_list = NULL;
+ for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) {
+ if (bptr->b_s_open) { /* there may be no backing store */
+ bptr->b_s_open = FALSE; /* prevent recursive close if error */
+ (*bptr->b_s_info.close_backing_store) (cinfo, & bptr->b_s_info);
+ }
+ }
+ mem->virt_barray_list = NULL;
+ }
+
+ /* Release large objects */
+ lhdr_ptr = mem->large_list[pool_id];
+ mem->large_list[pool_id] = NULL;
+
+ while (lhdr_ptr != NULL) {
+ large_pool_ptr next_lhdr_ptr = lhdr_ptr->hdr.next;
+ space_freed = lhdr_ptr->hdr.bytes_used +
+ lhdr_ptr->hdr.bytes_left +
+ SIZEOF(large_pool_hdr);
+ jpeg_free_large(cinfo, (void FAR *) lhdr_ptr, space_freed);
+ mem->total_space_allocated -= space_freed;
+ lhdr_ptr = next_lhdr_ptr;
+ }
+
+ /* Release small objects */
+ shdr_ptr = mem->small_list[pool_id];
+ mem->small_list[pool_id] = NULL;
+
+ while (shdr_ptr != NULL) {
+ small_pool_ptr next_shdr_ptr = shdr_ptr->hdr.next;
+ space_freed = shdr_ptr->hdr.bytes_used +
+ shdr_ptr->hdr.bytes_left +
+ SIZEOF(small_pool_hdr);
+ jpeg_free_small(cinfo, (void *) shdr_ptr, space_freed);
+ mem->total_space_allocated -= space_freed;
+ shdr_ptr = next_shdr_ptr;
+ }
+}
+
+
+/*
+ * Close up shop entirely.
+ * Note that this cannot be called unless cinfo->mem is non-NULL.
+ */
+
+METHODDEF(void)
+self_destruct (j_common_ptr cinfo)
+{
+ int pool;
+
+ /* Close all backing store, release all memory.
+ * Releasing pools in reverse order might help avoid fragmentation
+ * with some (brain-damaged) malloc libraries.
+ */
+ for (pool = JPOOL_NUMPOOLS-1; pool >= JPOOL_PERMANENT; pool--) {
+ free_pool(cinfo, pool);
+ }
+
+ /* Release the memory manager control block too. */
+ jpeg_free_small(cinfo, (void *) cinfo->mem, SIZEOF(my_memory_mgr));
+ cinfo->mem = NULL; /* ensures I will be called only once */
+
+ jpeg_mem_term(cinfo); /* system-dependent cleanup */
+}
+
+
+/*
+ * Memory manager initialization.
+ * When this is called, only the error manager pointer is valid in cinfo!
+ */
+
+GLOBAL(void)
+jinit_memory_mgr (j_common_ptr cinfo)
+{
+ my_mem_ptr mem;
+ long max_to_use;
+ int pool;
+ size_t test_mac;
+
+ cinfo->mem = NULL; /* for safety if init fails */
+
+ /* Check for configuration errors.
+ * SIZEOF(ALIGN_TYPE) should be a power of 2; otherwise, it probably
+ * doesn't reflect any real hardware alignment requirement.
+ * The test is a little tricky: for X>0, X and X-1 have no one-bits
+ * in common if and only if X is a power of 2, ie has only one one-bit.
+ * Some compilers may give an "unreachable code" warning here; ignore it.
+ */
+ if ((SIZEOF(ALIGN_TYPE) & (SIZEOF(ALIGN_TYPE)-1)) != 0)
+ ERREXIT(cinfo, JERR_BAD_ALIGN_TYPE);
+ /* MAX_ALLOC_CHUNK must be representable as type size_t, and must be
+ * a multiple of SIZEOF(ALIGN_TYPE).
+ * Again, an "unreachable code" warning may be ignored here.
+ * But a "constant too large" warning means you need to fix MAX_ALLOC_CHUNK.
+ */
+ test_mac = (size_t) MAX_ALLOC_CHUNK;
+ if ((long) test_mac != MAX_ALLOC_CHUNK ||
+ (MAX_ALLOC_CHUNK % SIZEOF(ALIGN_TYPE)) != 0)
+ ERREXIT(cinfo, JERR_BAD_ALLOC_CHUNK);
+
+ max_to_use = jpeg_mem_init(cinfo); /* system-dependent initialization */
+
+ /* Attempt to allocate memory manager's control block */
+ mem = (my_mem_ptr) jpeg_get_small(cinfo, SIZEOF(my_memory_mgr));
+
+ if (mem == NULL) {
+ jpeg_mem_term(cinfo); /* system-dependent cleanup */
+ ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 0);
+ }
+
+ /* OK, fill in the method pointers */
+ mem->pub.alloc_small = alloc_small;
+ mem->pub.alloc_large = alloc_large;
+ mem->pub.alloc_sarray = alloc_sarray;
+ mem->pub.alloc_barray = alloc_barray;
+ mem->pub.request_virt_sarray = request_virt_sarray;
+ mem->pub.request_virt_barray = request_virt_barray;
+ mem->pub.realize_virt_arrays = realize_virt_arrays;
+ mem->pub.access_virt_sarray = access_virt_sarray;
+ mem->pub.access_virt_barray = access_virt_barray;
+ mem->pub.free_pool = free_pool;
+ mem->pub.self_destruct = self_destruct;
+
+ /* Make MAX_ALLOC_CHUNK accessible to other modules */
+ mem->pub.max_alloc_chunk = MAX_ALLOC_CHUNK;
+
+ /* Initialize working state */
+ mem->pub.max_memory_to_use = max_to_use;
+
+ for (pool = JPOOL_NUMPOOLS-1; pool >= JPOOL_PERMANENT; pool--) {
+ mem->small_list[pool] = NULL;
+ mem->large_list[pool] = NULL;
+ }
+ mem->virt_sarray_list = NULL;
+ mem->virt_barray_list = NULL;
+
+ mem->total_space_allocated = SIZEOF(my_memory_mgr);
+
+ /* Declare ourselves open for business */
+ cinfo->mem = & mem->pub;
+
+ /* Check for an environment variable JPEGMEM; if found, override the
+ * default max_memory setting from jpeg_mem_init. Note that the
+ * surrounding application may again override this value.
+ * If your system doesn't support getenv(), define NO_GETENV to disable
+ * this feature.
+ */
+#ifndef NO_GETENV
+ { char * memenv;
+
+ if ((memenv = getenv("JPEGMEM")) != NULL) {
+ char ch = 'x';
+
+ if (sscanf(memenv, "%ld%c", &max_to_use, &ch) > 0) {
+ if (ch == 'm' || ch == 'M')
+ max_to_use *= 1000L;
+ mem->pub.max_memory_to_use = max_to_use * 1000L;
+ }
+ }
+ }
+#endif
+
+}
--- /dev/null
+/*
+ * jmemnobs.c
+ *
+ * Copyright (C) 1992-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file provides a really simple implementation of the system-
+ * dependent portion of the JPEG memory manager. This implementation
+ * assumes that no backing-store files are needed: all required space
+ * can be obtained from malloc().
+ * This is very portable in the sense that it'll compile on almost anything,
+ * but you'd better have lots of main memory (or virtual memory) if you want
+ * to process big images.
+ * Note that the max_memory_to_use option is ignored by this implementation.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jmemsys.h" /* import the system-dependent declarations */
+
+#ifndef HAVE_STDLIB_H /* <stdlib.h> should declare malloc(),free() */
+extern void * malloc JPP((size_t size));
+extern void free JPP((void *ptr));
+#endif
+
+
+/*
+ * Memory allocation and freeing are controlled by the regular library
+ * routines malloc() and free().
+ */
+
+GLOBAL(void *)
+jpeg_get_small (j_common_ptr cinfo, size_t sizeofobject)
+{
+ return (void *) malloc(sizeofobject);
+}
+
+GLOBAL(void)
+jpeg_free_small (j_common_ptr cinfo, void * object, size_t sizeofobject)
+{
+ free(object);
+}
+
+
+/*
+ * "Large" objects are treated the same as "small" ones.
+ * NB: although we include FAR keywords in the routine declarations,
+ * this file won't actually work in 80x86 small/medium model; at least,
+ * you probably won't be able to process useful-size images in only 64KB.
+ */
+
+GLOBAL(void FAR *)
+jpeg_get_large (j_common_ptr cinfo, size_t sizeofobject)
+{
+ return (void FAR *) malloc(sizeofobject);
+}
+
+GLOBAL(void)
+jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject)
+{
+ free(object);
+}
+
+
+/*
+ * This routine computes the total memory space available for allocation.
+ * Here we always say, "we got all you want bud!"
+ */
+
+GLOBAL(long)
+jpeg_mem_available (j_common_ptr cinfo, long min_bytes_needed,
+ long max_bytes_needed, long already_allocated)
+{
+ return max_bytes_needed;
+}
+
+
+/*
+ * Backing store (temporary file) management.
+ * Since jpeg_mem_available always promised the moon,
+ * this should never be called and we can just error out.
+ */
+
+GLOBAL(void)
+jpeg_open_backing_store (j_common_ptr cinfo, backing_store_ptr info,
+ long total_bytes_needed)
+{
+ ERREXIT(cinfo, JERR_NO_BACKING_STORE);
+}
+
+
+/*
+ * These routines take care of any system-dependent initialization and
+ * cleanup required. Here, there isn't any.
+ */
+
+GLOBAL(long)
+jpeg_mem_init (j_common_ptr cinfo)
+{
+ return 0; /* just set max_memory_to_use to 0 */
+}
+
+GLOBAL(void)
+jpeg_mem_term (j_common_ptr cinfo)
+{
+ /* no work */
+}
--- /dev/null
+/*
+ * jmemsys.h
+ *
+ * Copyright (C) 1992-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This include file defines the interface between the system-independent
+ * and system-dependent portions of the JPEG memory manager. No other
+ * modules need include it. (The system-independent portion is jmemmgr.c;
+ * there are several different versions of the system-dependent portion.)
+ *
+ * This file works as-is for the system-dependent memory managers supplied
+ * in the IJG distribution. You may need to modify it if you write a
+ * custom memory manager. If system-dependent changes are needed in
+ * this file, the best method is to #ifdef them based on a configuration
+ * symbol supplied in jconfig.h, as we have done with USE_MSDOS_MEMMGR
+ * and USE_MAC_MEMMGR.
+ */
+
+
+/* Short forms of external names for systems with brain-damaged linkers. */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_get_small jGetSmall
+#define jpeg_free_small jFreeSmall
+#define jpeg_get_large jGetLarge
+#define jpeg_free_large jFreeLarge
+#define jpeg_mem_available jMemAvail
+#define jpeg_open_backing_store jOpenBackStore
+#define jpeg_mem_init jMemInit
+#define jpeg_mem_term jMemTerm
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+
+/*
+ * These two functions are used to allocate and release small chunks of
+ * memory. (Typically the total amount requested through jpeg_get_small is
+ * no more than 20K or so; this will be requested in chunks of a few K each.)
+ * Behavior should be the same as for the standard library functions malloc
+ * and free; in particular, jpeg_get_small must return NULL on failure.
+ * On most systems, these ARE malloc and free. jpeg_free_small is passed the
+ * size of the object being freed, just in case it's needed.
+ * On an 80x86 machine using small-data memory model, these manage near heap.
+ */
+
+EXTERN(void *) jpeg_get_small JPP((j_common_ptr cinfo, size_t sizeofobject));
+EXTERN(void) jpeg_free_small JPP((j_common_ptr cinfo, void * object,
+ size_t sizeofobject));
+
+/*
+ * These two functions are used to allocate and release large chunks of
+ * memory (up to the total free space designated by jpeg_mem_available).
+ * The interface is the same as above, except that on an 80x86 machine,
+ * far pointers are used. On most other machines these are identical to
+ * the jpeg_get/free_small routines; but we keep them separate anyway,
+ * in case a different allocation strategy is desirable for large chunks.
+ */
+
+EXTERN(void FAR *) jpeg_get_large JPP((j_common_ptr cinfo,
+ size_t sizeofobject));
+EXTERN(void) jpeg_free_large JPP((j_common_ptr cinfo, void FAR * object,
+ size_t sizeofobject));
+
+/*
+ * The macro MAX_ALLOC_CHUNK designates the maximum number of bytes that may
+ * be requested in a single call to jpeg_get_large (and jpeg_get_small for that
+ * matter, but that case should never come into play). This macro is needed
+ * to model the 64Kb-segment-size limit of far addressing on 80x86 machines.
+ * On those machines, we expect that jconfig.h will provide a proper value.
+ * On machines with 32-bit flat address spaces, any large constant may be used.
+ *
+ * NB: jmemmgr.c expects that MAX_ALLOC_CHUNK will be representable as type
+ * size_t and will be a multiple of sizeof(align_type).
+ */
+
+#ifndef MAX_ALLOC_CHUNK /* may be overridden in jconfig.h */
+#define MAX_ALLOC_CHUNK 1000000000L
+#endif
+
+/*
+ * This routine computes the total space still available for allocation by
+ * jpeg_get_large. If more space than this is needed, backing store will be
+ * used. NOTE: any memory already allocated must not be counted.
+ *
+ * There is a minimum space requirement, corresponding to the minimum
+ * feasible buffer sizes; jmemmgr.c will request that much space even if
+ * jpeg_mem_available returns zero. The maximum space needed, enough to hold
+ * all working storage in memory, is also passed in case it is useful.
+ * Finally, the total space already allocated is passed. If no better
+ * method is available, cinfo->mem->max_memory_to_use - already_allocated
+ * is often a suitable calculation.
+ *
+ * It is OK for jpeg_mem_available to underestimate the space available
+ * (that'll just lead to more backing-store access than is really necessary).
+ * However, an overestimate will lead to failure. Hence it's wise to subtract
+ * a slop factor from the true available space. 5% should be enough.
+ *
+ * On machines with lots of virtual memory, any large constant may be returned.
+ * Conversely, zero may be returned to always use the minimum amount of memory.
+ */
+
+EXTERN(long) jpeg_mem_available JPP((j_common_ptr cinfo,
+ long min_bytes_needed,
+ long max_bytes_needed,
+ long already_allocated));
+
+
+/*
+ * This structure holds whatever state is needed to access a single
+ * backing-store object. The read/write/close method pointers are called
+ * by jmemmgr.c to manipulate the backing-store object; all other fields
+ * are private to the system-dependent backing store routines.
+ */
+
+#define TEMP_NAME_LENGTH 64 /* max length of a temporary file's name */
+
+
+#ifdef USE_MSDOS_MEMMGR /* DOS-specific junk */
+
+typedef unsigned short XMSH; /* type of extended-memory handles */
+typedef unsigned short EMSH; /* type of expanded-memory handles */
+
+typedef union {
+ short file_handle; /* DOS file handle if it's a temp file */
+ XMSH xms_handle; /* handle if it's a chunk of XMS */
+ EMSH ems_handle; /* handle if it's a chunk of EMS */
+} handle_union;
+
+#endif /* USE_MSDOS_MEMMGR */
+
+#ifdef USE_MAC_MEMMGR /* Mac-specific junk */
+#include <Files.h>
+#endif /* USE_MAC_MEMMGR */
+
+
+typedef struct backing_store_struct * backing_store_ptr;
+
+typedef struct backing_store_struct {
+ /* Methods for reading/writing/closing this backing-store object */
+ JMETHOD(void, read_backing_store, (j_common_ptr cinfo,
+ backing_store_ptr info,
+ void FAR * buffer_address,
+ long file_offset, long byte_count));
+ JMETHOD(void, write_backing_store, (j_common_ptr cinfo,
+ backing_store_ptr info,
+ void FAR * buffer_address,
+ long file_offset, long byte_count));
+ JMETHOD(void, close_backing_store, (j_common_ptr cinfo,
+ backing_store_ptr info));
+
+ /* Private fields for system-dependent backing-store management */
+#ifdef USE_MSDOS_MEMMGR
+ /* For the MS-DOS manager (jmemdos.c), we need: */
+ handle_union handle; /* reference to backing-store storage object */
+ char temp_name[TEMP_NAME_LENGTH]; /* name if it's a file */
+#else
+#ifdef USE_MAC_MEMMGR
+ /* For the Mac manager (jmemmac.c), we need: */
+ short temp_file; /* file reference number to temp file */
+ FSSpec tempSpec; /* the FSSpec for the temp file */
+ char temp_name[TEMP_NAME_LENGTH]; /* name if it's a file */
+#else
+ /* For a typical implementation with temp files, we need: */
+ FILE * temp_file; /* stdio reference to temp file */
+ char temp_name[TEMP_NAME_LENGTH]; /* name of temp file */
+#endif
+#endif
+} backing_store_info;
+
+
+/*
+ * Initial opening of a backing-store object. This must fill in the
+ * read/write/close pointers in the object. The read/write routines
+ * may take an error exit if the specified maximum file size is exceeded.
+ * (If jpeg_mem_available always returns a large value, this routine can
+ * just take an error exit.)
+ */
+
+EXTERN(void) jpeg_open_backing_store JPP((j_common_ptr cinfo,
+ backing_store_ptr info,
+ long total_bytes_needed));
+
+
+/*
+ * These routines take care of any system-dependent initialization and
+ * cleanup required. jpeg_mem_init will be called before anything is
+ * allocated (and, therefore, nothing in cinfo is of use except the error
+ * manager pointer). It should return a suitable default value for
+ * max_memory_to_use; this may subsequently be overridden by the surrounding
+ * application. (Note that max_memory_to_use is only important if
+ * jpeg_mem_available chooses to consult it ... no one else will.)
+ * jpeg_mem_term may assume that all requested memory has been freed and that
+ * all opened backing-store objects have been closed.
+ */
+
+EXTERN(long) jpeg_mem_init JPP((j_common_ptr cinfo));
+EXTERN(void) jpeg_mem_term JPP((j_common_ptr cinfo));
--- /dev/null
+/*
+ * jmorecfg.h
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * 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 additional configuration options that customize the
+ * JPEG software for special applications or support machine-dependent
+ * optimizations. Most users will not need to touch this file.
+ */
+
+
+/*
+ * Define BITS_IN_JSAMPLE as either
+ * 8 for 8-bit sample values (the usual setting)
+ * 12 for 12-bit sample values
+ * Only 8 and 12 are legal data precisions for lossy JPEG according to the
+ * JPEG standard, and the IJG code does not support anything else!
+ * We do not support run-time selection of data precision, sorry.
+ */
+
+#define BITS_IN_JSAMPLE 8 /* use 8 or 12 */
+
+
+/*
+ * Maximum number of components (color channels) allowed in JPEG image.
+ * To meet the letter of the JPEG spec, set this to 255. However, darn
+ * few applications need more than 4 channels (maybe 5 for CMYK + alpha
+ * mask). We recommend 10 as a reasonable compromise; use 4 if you are
+ * really short on memory. (Each allowed component costs a hundred or so
+ * bytes of storage, whether actually used in an image or not.)
+ */
+
+#define MAX_COMPONENTS 10 /* maximum number of image components */
+
+
+/*
+ * Basic data types.
+ * You may need to change these if you have a machine with unusual data
+ * type sizes; for example, "char" not 8 bits, "short" not 16 bits,
+ * or "long" not 32 bits. We don't care whether "int" is 16 or 32 bits,
+ * but it had better be at least 16.
+ */
+
+/* Representation of a single sample (pixel element value).
+ * We frequently allocate large arrays of these, so it's important to keep
+ * them small. But if you have memory to burn and access to char or short
+ * arrays is very slow on your hardware, you might want to change these.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+/* JSAMPLE should be the smallest type that will hold the values 0..255.
+ * You can use a signed char by having GETJSAMPLE mask it with 0xFF.
+ */
+
+#ifdef HAVE_UNSIGNED_CHAR
+
+typedef unsigned char JSAMPLE;
+#define GETJSAMPLE(value) ((int) (value))
+
+#else /* not HAVE_UNSIGNED_CHAR */
+
+typedef char JSAMPLE;
+#ifdef CHAR_IS_UNSIGNED
+#define GETJSAMPLE(value) ((int) (value))
+#else
+#define GETJSAMPLE(value) ((int) (value) & 0xFF)
+#endif /* CHAR_IS_UNSIGNED */
+
+#endif /* HAVE_UNSIGNED_CHAR */
+
+#define MAXJSAMPLE 255
+#define CENTERJSAMPLE 128
+
+#endif /* BITS_IN_JSAMPLE == 8 */
+
+
+#if BITS_IN_JSAMPLE == 12
+/* JSAMPLE should be the smallest type that will hold the values 0..4095.
+ * On nearly all machines "short" will do nicely.
+ */
+
+typedef short JSAMPLE;
+#define GETJSAMPLE(value) ((int) (value))
+
+#define MAXJSAMPLE 4095
+#define CENTERJSAMPLE 2048
+
+#endif /* BITS_IN_JSAMPLE == 12 */
+
+
+/* Representation of a DCT frequency coefficient.
+ * This should be a signed value of at least 16 bits; "short" is usually OK.
+ * Again, we allocate large arrays of these, but you can change to int
+ * if you have memory to burn and "short" is really slow.
+ */
+
+typedef short JCOEF;
+
+
+/* Compressed datastreams are represented as arrays of JOCTET.
+ * These must be EXACTLY 8 bits wide, at least once they are written to
+ * external storage. Note that when using the stdio data source/destination
+ * managers, this is also the data type passed to fread/fwrite.
+ */
+
+#ifdef HAVE_UNSIGNED_CHAR
+
+typedef unsigned char JOCTET;
+#define GETJOCTET(value) (value)
+
+#else /* not HAVE_UNSIGNED_CHAR */
+
+typedef char JOCTET;
+#ifdef CHAR_IS_UNSIGNED
+#define GETJOCTET(value) (value)
+#else
+#define GETJOCTET(value) ((value) & 0xFF)
+#endif /* CHAR_IS_UNSIGNED */
+
+#endif /* HAVE_UNSIGNED_CHAR */
+
+
+/* These typedefs are used for various table entries and so forth.
+ * They must be at least as wide as specified; but making them too big
+ * won't cost a huge amount of memory, so we don't provide special
+ * extraction code like we did for JSAMPLE. (In other words, these
+ * typedefs live at a different point on the speed/space tradeoff curve.)
+ */
+
+/* UINT8 must hold at least the values 0..255. */
+
+#ifdef HAVE_UNSIGNED_CHAR
+typedef unsigned char UINT8;
+#else /* not HAVE_UNSIGNED_CHAR */
+#ifdef CHAR_IS_UNSIGNED
+typedef char UINT8;
+#else /* not CHAR_IS_UNSIGNED */
+typedef short UINT8;
+#endif /* CHAR_IS_UNSIGNED */
+#endif /* HAVE_UNSIGNED_CHAR */
+
+/* UINT16 must hold at least the values 0..65535. */
+
+#ifdef HAVE_UNSIGNED_SHORT
+typedef unsigned short UINT16;
+#else /* not HAVE_UNSIGNED_SHORT */
+typedef unsigned int UINT16;
+#endif /* HAVE_UNSIGNED_SHORT */
+
+/* INT16 must hold at least the values -32768..32767. */
+
+#ifndef XMD_H /* X11/xmd.h correctly defines INT16 */
+typedef short INT16;
+#endif
+
+/* INT32 must hold at least signed 32-bit values. */
+
+#ifndef XMD_H /* X11/xmd.h correctly defines INT32 */
+typedef int INT32;
+#endif
+
+/* Datatype used for image dimensions. The JPEG standard only supports
+ * images up to 64K*64K due to 16-bit fields in SOF markers. Therefore
+ * "unsigned int" is sufficient on all machines. However, if you need to
+ * handle larger images and you don't mind deviating from the spec, you
+ * can change this datatype.
+ */
+
+typedef unsigned int JDIMENSION;
+
+#define JPEG_MAX_DIMENSION 65500L /* a tad under 64K to prevent overflows */
+
+
+/* These macros are used in all function definitions and extern declarations.
+ * You could modify them if you need to change function linkage conventions;
+ * in particular, you'll need to do that to make the library a Windows DLL.
+ * Another application is to make all functions global for use with debuggers
+ * or code profilers that require it.
+ */
+
+/* a function called through method pointers: */
+#define METHODDEF(type) static type
+/* a function used only in its module: */
+#define LOCAL(type) static type
+/* a function referenced thru EXTERNs: */
+#define GLOBAL(type) type
+/* a reference to a GLOBAL function: */
+#define EXTERN(type) extern type
+
+
+/* This macro is used to declare a "method", that is, a function pointer.
+ * We want to supply prototype parameters if the compiler can cope.
+ * Note that the arglist parameter must be parenthesized!
+ * Again, you can customize this if you need special linkage keywords.
+ */
+
+#ifdef HAVE_PROTOTYPES
+#define JMETHOD(type,methodname,arglist) type (*methodname) arglist
+#else
+#define JMETHOD(type,methodname,arglist) type (*methodname) ()
+#endif
+
+
+/* Here is the pseudo-keyword for declaring pointers that must be "far"
+ * on 80x86 machines. Most of the specialized coding for 80x86 is handled
+ * by just saying "FAR *" where such a pointer is needed. In a few places
+ * explicit coding is needed; see uses of the NEED_FAR_POINTERS symbol.
+ */
+
+#ifdef FAR
+#undef FAR
+#endif
+
+#ifdef NEED_FAR_POINTERS
+#define FAR far
+#else
+#define FAR
+#endif
+
+
+/*
+ * On a few systems, type boolean and/or its values FALSE, TRUE may appear
+ * in standard header files. Or you may have conflicts with application-
+ * specific header files that you want to include together with these files.
+ * Defining HAVE_BOOLEAN before including jpeglib.h should make it work.
+ */
+
+#ifndef HAVE_BOOLEAN
+typedef int boolean;
+#endif
+#ifndef FALSE /* in case these macros already exist */
+#define FALSE 0 /* values of boolean */
+#endif
+#ifndef TRUE
+#define TRUE 1
+#endif
+
+
+/*
+ * The remaining options affect code selection within the JPEG library,
+ * but they don't need to be visible to most applications using the library.
+ * To minimize application namespace pollution, the symbols won't be
+ * defined unless JPEG_INTERNALS or JPEG_INTERNAL_OPTIONS has been defined.
+ */
+
+#ifdef JPEG_INTERNALS
+#define JPEG_INTERNAL_OPTIONS
+#endif
+
+#ifdef JPEG_INTERNAL_OPTIONS
+
+
+/*
+ * These defines indicate whether to include various optional functions.
+ * Undefining some of these symbols will produce a smaller but less capable
+ * library. Note that you can leave certain source files out of the
+ * compilation/linking process if you've #undef'd the corresponding symbols.
+ * (You may HAVE to do that if your compiler doesn't like null source files.)
+ */
+
+/* Arithmetic coding is unsupported for legal reasons. Complaints to IBM. */
+
+/* Capability options common to encoder and decoder: */
+
+#define DCT_ISLOW_SUPPORTED /* slow but accurate integer algorithm */
+#define DCT_IFAST_SUPPORTED /* faster, less accurate integer method */
+#define DCT_FLOAT_SUPPORTED /* floating-point: accurate, fast on fast HW */
+
+/* Encoder capability options: */
+
+#undef C_ARITH_CODING_SUPPORTED /* Arithmetic coding back end? */
+#define C_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
+#define C_PROGRESSIVE_SUPPORTED /* Progressive JPEG? (Requires MULTISCAN)*/
+#define ENTROPY_OPT_SUPPORTED /* Optimization of entropy coding parms? */
+/* Note: if you selected 12-bit data precision, it is dangerous to turn off
+ * ENTROPY_OPT_SUPPORTED. The standard Huffman tables are only good for 8-bit
+ * precision, so jchuff.c normally uses entropy optimization to compute
+ * usable tables for higher precision. If you don't want to do optimization,
+ * you'll have to supply different default Huffman tables.
+ * The exact same statements apply for progressive JPEG: the default tables
+ * don't work for progressive mode. (This may get fixed, however.)
+ */
+#define INPUT_SMOOTHING_SUPPORTED /* Input image smoothing option? */
+
+/* Decoder capability options: */
+
+#undef D_ARITH_CODING_SUPPORTED /* Arithmetic coding back end? */
+#define D_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
+#define D_PROGRESSIVE_SUPPORTED /* Progressive JPEG? (Requires MULTISCAN)*/
+#define SAVE_MARKERS_SUPPORTED /* jpeg_save_markers() needed? */
+#define BLOCK_SMOOTHING_SUPPORTED /* Block smoothing? (Progressive only) */
+#define IDCT_SCALING_SUPPORTED /* Output rescaling via IDCT? */
+#undef UPSAMPLE_SCALING_SUPPORTED /* Output rescaling at upsample stage? */
+#define UPSAMPLE_MERGING_SUPPORTED /* Fast path for sloppy upsampling? */
+#define QUANT_1PASS_SUPPORTED /* 1-pass color quantization? */
+#define QUANT_2PASS_SUPPORTED /* 2-pass color quantization? */
+
+/* more capability options later, no doubt */
+
+
+/*
+ * Ordering of RGB data in scanlines passed to or from the application.
+ * If your application wants to deal with data in the order B,G,R, just
+ * change these macros. You can also deal with formats such as R,G,B,X
+ * (one extra byte per pixel) by changing RGB_PIXELSIZE. Note that changing
+ * the offsets will also change the order in which colormap data is organized.
+ * RESTRICTIONS:
+ * 1. The sample applications cjpeg,djpeg do NOT support modified RGB formats.
+ * 2. These macros only affect RGB<=>YCbCr color conversion, so they are not
+ * useful if you are using JPEG color spaces other than YCbCr or grayscale.
+ * 3. The color quantizer modules will not behave desirably if RGB_PIXELSIZE
+ * is not 3 (they don't understand about dummy color components!). So you
+ * can't use color quantization if you change that value.
+ */
+
+#define RGB_RED 0 /* Offset of Red in an RGB scanline element */
+#define RGB_GREEN 1 /* Offset of Green */
+#define RGB_BLUE 2 /* Offset of Blue */
+#define RGB_PIXELSIZE 3 /* JSAMPLEs per RGB scanline element */
+
+
+/* Definitions for speed-related optimizations. */
+
+
+/* If your compiler supports inline functions, define INLINE
+ * as the inline keyword; otherwise define it as empty.
+ */
+
+#ifndef INLINE
+#ifdef __GNUC__ /* for instance, GNU C knows about inline */
+#define INLINE __inline__
+#endif
+#ifndef INLINE
+#define INLINE /* default is to define it as empty */
+#endif
+#endif
+
+
+/* On some machines (notably 68000 series) "int" is 32 bits, but multiplying
+ * two 16-bit shorts is faster than multiplying two ints. Define MULTIPLIER
+ * as short on such a machine. MULTIPLIER must be at least 16 bits wide.
+ */
+
+#ifndef MULTIPLIER
+#define MULTIPLIER int /* type for fastest integer multiply */
+#endif
+
+
+/* FAST_FLOAT should be either float or double, whichever is done faster
+ * by your compiler. (Note that this type is only used in the floating point
+ * DCT routines, so it only matters if you've defined DCT_FLOAT_SUPPORTED.)
+ * Typically, float is faster in ANSI C compilers, while double is faster in
+ * pre-ANSI compilers (because they insist on converting to double anyway).
+ * The code below therefore chooses float if we have ANSI-style prototypes.
+ */
+
+#ifndef FAST_FLOAT
+#ifdef HAVE_PROTOTYPES
+#define FAST_FLOAT float
+#else
+#define FAST_FLOAT double
+#endif
+#endif
+
+#endif /* JPEG_INTERNAL_OPTIONS */
--- /dev/null
+/*
+ * jpegint.h
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file provides common declarations for the various JPEG modules.
+ * These declarations are considered internal to the JPEG library; most
+ * applications using the library shouldn't need to include this file.
+ */
+
+
+/* Declarations for both compression & decompression */
+
+typedef enum { /* Operating modes for buffer controllers */
+ JBUF_PASS_THRU, /* Plain stripwise operation */
+ /* Remaining modes require a full-image buffer to have been created */
+ JBUF_SAVE_SOURCE, /* Run source subobject only, save output */
+ JBUF_CRANK_DEST, /* Run dest subobject only, using saved data */
+ JBUF_SAVE_AND_PASS /* Run both subobjects, save output */
+} J_BUF_MODE;
+
+/* Values of global_state field (jdapi.c has some dependencies on ordering!) */
+#define CSTATE_START 100 /* after create_compress */
+#define CSTATE_SCANNING 101 /* start_compress done, write_scanlines OK */
+#define CSTATE_RAW_OK 102 /* start_compress done, write_raw_data OK */
+#define CSTATE_WRCOEFS 103 /* jpeg_write_coefficients done */
+#define DSTATE_START 200 /* after create_decompress */
+#define DSTATE_INHEADER 201 /* reading header markers, no SOS yet */
+#define DSTATE_READY 202 /* found SOS, ready for start_decompress */
+#define DSTATE_PRELOAD 203 /* reading multiscan file in start_decompress*/
+#define DSTATE_PRESCAN 204 /* performing dummy pass for 2-pass quant */
+#define DSTATE_SCANNING 205 /* start_decompress done, read_scanlines OK */
+#define DSTATE_RAW_OK 206 /* start_decompress done, read_raw_data OK */
+#define DSTATE_BUFIMAGE 207 /* expecting jpeg_start_output */
+#define DSTATE_BUFPOST 208 /* looking for SOS/EOI in jpeg_finish_output */
+#define DSTATE_RDCOEFS 209 /* reading file in jpeg_read_coefficients */
+#define DSTATE_STOPPING 210 /* looking for EOI in jpeg_finish_decompress */
+
+
+/* Declarations for compression modules */
+
+/* Master control module */
+struct jpeg_comp_master {
+ JMETHOD(void, prepare_for_pass, (j_compress_ptr cinfo));
+ JMETHOD(void, pass_startup, (j_compress_ptr cinfo));
+ JMETHOD(void, finish_pass, (j_compress_ptr cinfo));
+
+ /* State variables made visible to other modules */
+ boolean call_pass_startup; /* True if pass_startup must be called */
+ boolean is_last_pass; /* True during last pass */
+};
+
+/* Main buffer control (downsampled-data buffer) */
+struct jpeg_c_main_controller {
+ JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
+ JMETHOD(void, process_data, (j_compress_ptr cinfo,
+ JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+ JDIMENSION in_rows_avail));
+};
+
+/* Compression preprocessing (downsampling input buffer control) */
+struct jpeg_c_prep_controller {
+ JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
+ JMETHOD(void, pre_process_data, (j_compress_ptr cinfo,
+ JSAMPARRAY input_buf,
+ JDIMENSION *in_row_ctr,
+ JDIMENSION in_rows_avail,
+ JSAMPIMAGE output_buf,
+ JDIMENSION *out_row_group_ctr,
+ JDIMENSION out_row_groups_avail));
+};
+
+/* Coefficient buffer control */
+struct jpeg_c_coef_controller {
+ JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
+ JMETHOD(boolean, compress_data, (j_compress_ptr cinfo,
+ JSAMPIMAGE input_buf));
+};
+
+/* Colorspace conversion */
+struct jpeg_color_converter {
+ JMETHOD(void, start_pass, (j_compress_ptr cinfo));
+ JMETHOD(void, color_convert, (j_compress_ptr cinfo,
+ JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+ JDIMENSION output_row, int num_rows));
+};
+
+/* Downsampling */
+struct jpeg_downsampler {
+ JMETHOD(void, start_pass, (j_compress_ptr cinfo));
+ JMETHOD(void, downsample, (j_compress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION in_row_index,
+ JSAMPIMAGE output_buf,
+ JDIMENSION out_row_group_index));
+
+ boolean need_context_rows; /* TRUE if need rows above & below */
+};
+
+/* Forward DCT (also controls coefficient quantization) */
+struct jpeg_forward_dct {
+ JMETHOD(void, start_pass, (j_compress_ptr cinfo));
+ /* perhaps this should be an array??? */
+ JMETHOD(void, forward_DCT, (j_compress_ptr cinfo,
+ jpeg_component_info * compptr,
+ JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
+ JDIMENSION start_row, JDIMENSION start_col,
+ JDIMENSION num_blocks));
+};
+
+/* Entropy encoding */
+struct jpeg_entropy_encoder {
+ JMETHOD(void, start_pass, (j_compress_ptr cinfo, boolean gather_statistics));
+ JMETHOD(boolean, encode_mcu, (j_compress_ptr cinfo, JBLOCKROW *MCU_data));
+ JMETHOD(void, finish_pass, (j_compress_ptr cinfo));
+};
+
+/* Marker writing */
+struct jpeg_marker_writer {
+ JMETHOD(void, write_file_header, (j_compress_ptr cinfo));
+ JMETHOD(void, write_frame_header, (j_compress_ptr cinfo));
+ JMETHOD(void, write_scan_header, (j_compress_ptr cinfo));
+ JMETHOD(void, write_file_trailer, (j_compress_ptr cinfo));
+ JMETHOD(void, write_tables_only, (j_compress_ptr cinfo));
+ /* These routines are exported to allow insertion of extra markers */
+ /* Probably only COM and APPn markers should be written this way */
+ JMETHOD(void, write_marker_header, (j_compress_ptr cinfo, int marker,
+ unsigned int datalen));
+ JMETHOD(void, write_marker_byte, (j_compress_ptr cinfo, int val));
+};
+
+
+/* Declarations for decompression modules */
+
+/* Master control module */
+struct jpeg_decomp_master {
+ JMETHOD(void, prepare_for_output_pass, (j_decompress_ptr cinfo));
+ JMETHOD(void, finish_output_pass, (j_decompress_ptr cinfo));
+
+ /* State variables made visible to other modules */
+ boolean is_dummy_pass; /* True during 1st pass for 2-pass quant */
+};
+
+/* Input control module */
+struct jpeg_input_controller {
+ JMETHOD(int, consume_input, (j_decompress_ptr cinfo));
+ JMETHOD(void, reset_input_controller, (j_decompress_ptr cinfo));
+ JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo));
+ JMETHOD(void, finish_input_pass, (j_decompress_ptr cinfo));
+
+ /* State variables made visible to other modules */
+ boolean has_multiple_scans; /* True if file has multiple scans */
+ boolean eoi_reached; /* True when EOI has been consumed */
+};
+
+/* Main buffer control (downsampled-data buffer) */
+struct jpeg_d_main_controller {
+ JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
+ JMETHOD(void, process_data, (j_decompress_ptr cinfo,
+ JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail));
+};
+
+/* Coefficient buffer control */
+struct jpeg_d_coef_controller {
+ JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo));
+ JMETHOD(int, consume_data, (j_decompress_ptr cinfo));
+ JMETHOD(void, start_output_pass, (j_decompress_ptr cinfo));
+ JMETHOD(int, decompress_data, (j_decompress_ptr cinfo,
+ JSAMPIMAGE output_buf));
+ /* Pointer to array of coefficient virtual arrays, or NULL if none */
+ jvirt_barray_ptr *coef_arrays;
+};
+
+/* Decompression postprocessing (color quantization buffer control) */
+struct jpeg_d_post_controller {
+ JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
+ JMETHOD(void, post_process_data, (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf,
+ JDIMENSION *in_row_group_ctr,
+ JDIMENSION in_row_groups_avail,
+ JSAMPARRAY output_buf,
+ JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail));
+};
+
+/* Marker reading & parsing */
+struct jpeg_marker_reader {
+ JMETHOD(void, reset_marker_reader, (j_decompress_ptr cinfo));
+ /* Read markers until SOS or EOI.
+ * Returns same codes as are defined for jpeg_consume_input:
+ * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
+ */
+ JMETHOD(int, read_markers, (j_decompress_ptr cinfo));
+ /* Read a restart marker --- exported for use by entropy decoder only */
+ jpeg_marker_parser_method read_restart_marker;
+
+ /* State of marker reader --- nominally internal, but applications
+ * supplying COM or APPn handlers might like to know the state.
+ */
+ boolean saw_SOI; /* found SOI? */
+ boolean saw_SOF; /* found SOF? */
+ int next_restart_num; /* next restart number expected (0-7) */
+ unsigned int discarded_bytes; /* # of bytes skipped looking for a marker */
+};
+
+/* Entropy decoding */
+struct jpeg_entropy_decoder {
+ JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
+ JMETHOD(boolean, decode_mcu, (j_decompress_ptr cinfo,
+ JBLOCKROW *MCU_data));
+
+ /* This is here to share code between baseline and progressive decoders; */
+ /* other modules probably should not use it */
+ boolean insufficient_data; /* set TRUE after emitting warning */
+};
+
+/* Inverse DCT (also performs dequantization) */
+typedef JMETHOD(void, inverse_DCT_method_ptr,
+ (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JCOEFPTR coef_block,
+ JSAMPARRAY output_buf, JDIMENSION output_col));
+
+struct jpeg_inverse_dct {
+ JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
+ /* It is useful to allow each component to have a separate IDCT method. */
+ inverse_DCT_method_ptr inverse_DCT[MAX_COMPONENTS];
+};
+
+/* Upsampling (note that upsampler must also call color converter) */
+struct jpeg_upsampler {
+ JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
+ JMETHOD(void, upsample, (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf,
+ JDIMENSION *in_row_group_ctr,
+ JDIMENSION in_row_groups_avail,
+ JSAMPARRAY output_buf,
+ JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail));
+
+ boolean need_context_rows; /* TRUE if need rows above & below */
+};
+
+/* Colorspace conversion */
+struct jpeg_color_deconverter {
+ JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
+ JMETHOD(void, color_convert, (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION input_row,
+ JSAMPARRAY output_buf, int num_rows));
+};
+
+/* Color quantization or color precision reduction */
+struct jpeg_color_quantizer {
+ JMETHOD(void, start_pass, (j_decompress_ptr cinfo, boolean is_pre_scan));
+ JMETHOD(void, color_quantize, (j_decompress_ptr cinfo,
+ JSAMPARRAY input_buf, JSAMPARRAY output_buf,
+ int num_rows));
+ JMETHOD(void, finish_pass, (j_decompress_ptr cinfo));
+ JMETHOD(void, new_color_map, (j_decompress_ptr cinfo));
+};
+
+
+/* Miscellaneous useful macros */
+
+#undef MAX
+#define MAX(a,b) ((a) > (b) ? (a) : (b))
+#undef MIN
+#define MIN(a,b) ((a) < (b) ? (a) : (b))
+
+
+/* We assume that right shift corresponds to signed division by 2 with
+ * rounding towards minus infinity. This is correct for typical "arithmetic
+ * shift" instructions that shift in copies of the sign bit. But some
+ * C compilers implement >> with an unsigned shift. For these machines you
+ * must define RIGHT_SHIFT_IS_UNSIGNED.
+ * RIGHT_SHIFT provides a proper signed right shift of an INT32 quantity.
+ * It is only applied with constant shift counts. SHIFT_TEMPS must be
+ * included in the variables of any routine using RIGHT_SHIFT.
+ */
+
+#ifdef RIGHT_SHIFT_IS_UNSIGNED
+#define SHIFT_TEMPS INT32 shift_temp;
+#define RIGHT_SHIFT(x,shft) \
+ ((shift_temp = (x)) < 0 ? \
+ (shift_temp >> (shft)) | ((~((INT32) 0)) << (32-(shft))) : \
+ (shift_temp >> (shft)))
+#else
+#define SHIFT_TEMPS
+#define RIGHT_SHIFT(x,shft) ((x) >> (shft))
+#endif
+
+
+/* Short forms of external names for systems with brain-damaged linkers. */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jinit_compress_master jICompress
+#define jinit_c_master_control jICMaster
+#define jinit_c_main_controller jICMainC
+#define jinit_c_prep_controller jICPrepC
+#define jinit_c_coef_controller jICCoefC
+#define jinit_color_converter jICColor
+#define jinit_downsampler jIDownsampler
+#define jinit_forward_dct jIFDCT
+#define jinit_huff_encoder jIHEncoder
+#define jinit_phuff_encoder jIPHEncoder
+#define jinit_marker_writer jIMWriter
+#define jinit_master_decompress jIDMaster
+#define jinit_d_main_controller jIDMainC
+#define jinit_d_coef_controller jIDCoefC
+#define jinit_d_post_controller jIDPostC
+#define jinit_input_controller jIInCtlr
+#define jinit_marker_reader jIMReader
+#define jinit_huff_decoder jIHDecoder
+#define jinit_phuff_decoder jIPHDecoder
+#define jinit_inverse_dct jIIDCT
+#define jinit_upsampler jIUpsampler
+#define jinit_color_deconverter jIDColor
+#define jinit_1pass_quantizer jI1Quant
+#define jinit_2pass_quantizer jI2Quant
+#define jinit_merged_upsampler jIMUpsampler
+#define jinit_memory_mgr jIMemMgr
+#define jdiv_round_up jDivRound
+#define jround_up jRound
+#define jcopy_sample_rows jCopySamples
+#define jcopy_block_row jCopyBlocks
+#define jzero_far jZeroFar
+#define jpeg_zigzag_order jZIGTable
+#define jpeg_natural_order jZAGTable
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+
+/* Compression module initialization routines */
+EXTERN(void) jinit_compress_master JPP((j_compress_ptr cinfo));
+EXTERN(void) jinit_c_master_control JPP((j_compress_ptr cinfo,
+ boolean transcode_only));
+EXTERN(void) jinit_c_main_controller JPP((j_compress_ptr cinfo,
+ boolean need_full_buffer));
+EXTERN(void) jinit_c_prep_controller JPP((j_compress_ptr cinfo,
+ boolean need_full_buffer));
+EXTERN(void) jinit_c_coef_controller JPP((j_compress_ptr cinfo,
+ boolean need_full_buffer));
+EXTERN(void) jinit_color_converter JPP((j_compress_ptr cinfo));
+EXTERN(void) jinit_downsampler JPP((j_compress_ptr cinfo));
+EXTERN(void) jinit_forward_dct JPP((j_compress_ptr cinfo));
+EXTERN(void) jinit_huff_encoder JPP((j_compress_ptr cinfo));
+EXTERN(void) jinit_phuff_encoder JPP((j_compress_ptr cinfo));
+EXTERN(void) jinit_marker_writer JPP((j_compress_ptr cinfo));
+/* Decompression module initialization routines */
+EXTERN(void) jinit_master_decompress JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_d_main_controller JPP((j_decompress_ptr cinfo,
+ boolean need_full_buffer));
+EXTERN(void) jinit_d_coef_controller JPP((j_decompress_ptr cinfo,
+ boolean need_full_buffer));
+EXTERN(void) jinit_d_post_controller JPP((j_decompress_ptr cinfo,
+ boolean need_full_buffer));
+EXTERN(void) jinit_input_controller JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_marker_reader JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_huff_decoder JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_phuff_decoder JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_inverse_dct JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_upsampler JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_color_deconverter JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_1pass_quantizer JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_2pass_quantizer JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_merged_upsampler JPP((j_decompress_ptr cinfo));
+/* Memory manager initialization */
+EXTERN(void) jinit_memory_mgr JPP((j_common_ptr cinfo));
+
+/* Utility routines in jutils.c */
+EXTERN(long) jdiv_round_up JPP((long a, long b));
+EXTERN(long) jround_up JPP((long a, long b));
+EXTERN(void) jcopy_sample_rows JPP((JSAMPARRAY input_array, int source_row,
+ JSAMPARRAY output_array, int dest_row,
+ int num_rows, JDIMENSION num_cols));
+EXTERN(void) jcopy_block_row JPP((JBLOCKROW input_row, JBLOCKROW output_row,
+ JDIMENSION num_blocks));
+EXTERN(void) jzero_far JPP((void FAR * target, size_t bytestozero));
+/* Constant tables in jutils.c */
+#if 0 /* This table is not actually needed in v6a */
+extern const int jpeg_zigzag_order[]; /* natural coef order to zigzag order */
+#endif
+extern const int jpeg_natural_order[]; /* zigzag coef order to natural order */
+
+/* Suppress undefined-structure complaints if necessary. */
+
+#ifdef INCOMPLETE_TYPES_BROKEN
+#ifndef AM_MEMORY_MANAGER /* only jmemmgr.c defines these */
+struct jvirt_sarray_control { long dummy; };
+struct jvirt_barray_control { long dummy; };
+#endif
+#endif /* INCOMPLETE_TYPES_BROKEN */
--- /dev/null
+/*
+ * jpeglib.h
+ *
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file defines the application interface for the JPEG library.
+ * Most applications using the library need only include this file,
+ * and perhaps jerror.h if they want to know the exact error codes.
+ */
+
+#ifndef JPEGLIB_H
+#define JPEGLIB_H
+
+/*
+ * First we include the configuration files that record how this
+ * installation of the JPEG library is set up. jconfig.h can be
+ * generated automatically for many systems. jmorecfg.h contains
+ * manual configuration options that most people need not worry about.
+ */
+
+#ifndef JCONFIG_INCLUDED /* in case jinclude.h already did */
+#include "jconfig.h" /* widely used configuration options */
+#endif
+#include "jmorecfg.h" /* seldom changed options */
+
+
+/* Version ID for the JPEG library.
+ * Might be useful for tests like "#if JPEG_LIB_VERSION >= 60".
+ */
+
+#define JPEG_LIB_VERSION 62 /* Version 6b */
+
+
+/* Various constants determining the sizes of things.
+ * All of these are specified by the JPEG standard, so don't change them
+ * if you want to be compatible.
+ */
+
+#define DCTSIZE 8 /* The basic DCT block is 8x8 samples */
+#define DCTSIZE2 64 /* DCTSIZE squared; # of elements in a block */
+#define NUM_QUANT_TBLS 4 /* Quantization tables are numbered 0..3 */
+#define NUM_HUFF_TBLS 4 /* Huffman tables are numbered 0..3 */
+#define NUM_ARITH_TBLS 16 /* Arith-coding tables are numbered 0..15 */
+#define MAX_COMPS_IN_SCAN 4 /* JPEG limit on # of components in one scan */
+#define MAX_SAMP_FACTOR 4 /* JPEG limit on sampling factors */
+/* Unfortunately, some bozo at Adobe saw no reason to be bound by the standard;
+ * the PostScript DCT filter can emit files with many more than 10 blocks/MCU.
+ * If you happen to run across such a file, you can up D_MAX_BLOCKS_IN_MCU
+ * to handle it. We even let you do this from the jconfig.h file. However,
+ * we strongly discourage changing C_MAX_BLOCKS_IN_MCU; just because Adobe
+ * sometimes emits noncompliant files doesn't mean you should too.
+ */
+#define C_MAX_BLOCKS_IN_MCU 10 /* compressor's limit on blocks per MCU */
+#ifndef D_MAX_BLOCKS_IN_MCU
+#define D_MAX_BLOCKS_IN_MCU 10 /* decompressor's limit on blocks per MCU */
+#endif
+
+
+/* Data structures for images (arrays of samples and of DCT coefficients).
+ * On 80x86 machines, the image arrays are too big for near pointers,
+ * but the pointer arrays can fit in near memory.
+ */
+
+typedef JSAMPLE FAR *JSAMPROW; /* ptr to one image row of pixel samples. */
+typedef JSAMPROW *JSAMPARRAY; /* ptr to some rows (a 2-D sample array) */
+typedef JSAMPARRAY *JSAMPIMAGE; /* a 3-D sample array: top index is color */
+
+typedef JCOEF JBLOCK[DCTSIZE2]; /* one block of coefficients */
+typedef JBLOCK FAR *JBLOCKROW; /* pointer to one row of coefficient blocks */
+typedef JBLOCKROW *JBLOCKARRAY; /* a 2-D array of coefficient blocks */
+typedef JBLOCKARRAY *JBLOCKIMAGE; /* a 3-D array of coefficient blocks */
+
+typedef JCOEF FAR *JCOEFPTR; /* useful in a couple of places */
+
+
+/* Types for JPEG compression parameters and working tables. */
+
+
+/* DCT coefficient quantization tables. */
+
+typedef struct {
+ /* This array gives the coefficient quantizers in natural array order
+ * (not the zigzag order in which they are stored in a JPEG DQT marker).
+ * CAUTION: IJG versions prior to v6a kept this array in zigzag order.
+ */
+ UINT16 quantval[DCTSIZE2]; /* quantization step for each coefficient */
+ /* This field is used only during compression. It's initialized FALSE when
+ * the table is created, and set TRUE when it's been output to the file.
+ * You could suppress output of a table by setting this to TRUE.
+ * (See jpeg_suppress_tables for an example.)
+ */
+ boolean sent_table; /* TRUE when table has been output */
+} JQUANT_TBL;
+
+
+/* Huffman coding tables. */
+
+typedef struct {
+ /* These two fields directly represent the contents of a JPEG DHT marker */
+ UINT8 bits[17]; /* bits[k] = # of symbols with codes of */
+ /* length k bits; bits[0] is unused */
+ UINT8 huffval[256]; /* The symbols, in order of incr code length */
+ /* This field is used only during compression. It's initialized FALSE when
+ * the table is created, and set TRUE when it's been output to the file.
+ * You could suppress output of a table by setting this to TRUE.
+ * (See jpeg_suppress_tables for an example.)
+ */
+ boolean sent_table; /* TRUE when table has been output */
+} JHUFF_TBL;
+
+
+/* Basic info about one component (color channel). */
+
+typedef struct {
+ /* These values are fixed over the whole image. */
+ /* For compression, they must be supplied by parameter setup; */
+ /* for decompression, they are read from the SOF marker. */
+ int component_id; /* identifier for this component (0..255) */
+ int component_index; /* its index in SOF or cinfo->comp_info[] */
+ int h_samp_factor; /* horizontal sampling factor (1..4) */
+ int v_samp_factor; /* vertical sampling factor (1..4) */
+ int quant_tbl_no; /* quantization table selector (0..3) */
+ /* These values may vary between scans. */
+ /* For compression, they must be supplied by parameter setup; */
+ /* for decompression, they are read from the SOS marker. */
+ /* The decompressor output side may not use these variables. */
+ int dc_tbl_no; /* DC entropy table selector (0..3) */
+ int ac_tbl_no; /* AC entropy table selector (0..3) */
+
+ /* Remaining fields should be treated as private by applications. */
+
+ /* These values are computed during compression or decompression startup: */
+ /* Component's size in DCT blocks.
+ * Any dummy blocks added to complete an MCU are not counted; therefore
+ * these values do not depend on whether a scan is interleaved or not.
+ */
+ JDIMENSION width_in_blocks;
+ JDIMENSION height_in_blocks;
+ /* Size of a DCT block in samples. Always DCTSIZE for compression.
+ * For decompression this is the size of the output from one DCT block,
+ * reflecting any scaling we choose to apply during the IDCT step.
+ * Values of 1,2,4,8 are likely to be supported. Note that different
+ * components may receive different IDCT scalings.
+ */
+ int DCT_scaled_size;
+ /* The downsampled dimensions are the component's actual, unpadded number
+ * of samples at the main buffer (preprocessing/compression interface), thus
+ * downsampled_width = ceil(image_width * Hi/Hmax)
+ * and similarly for height. For decompression, IDCT scaling is included, so
+ * downsampled_width = ceil(image_width * Hi/Hmax * DCT_scaled_size/DCTSIZE)
+ */
+ JDIMENSION downsampled_width; /* actual width in samples */
+ JDIMENSION downsampled_height; /* actual height in samples */
+ /* This flag is used only for decompression. In cases where some of the
+ * components will be ignored (eg grayscale output from YCbCr image),
+ * we can skip most computations for the unused components.
+ */
+ boolean component_needed; /* do we need the value of this component? */
+
+ /* These values are computed before starting a scan of the component. */
+ /* The decompressor output side may not use these variables. */
+ int MCU_width; /* number of blocks per MCU, horizontally */
+ int MCU_height; /* number of blocks per MCU, vertically */
+ int MCU_blocks; /* MCU_width * MCU_height */
+ int MCU_sample_width; /* MCU width in samples, MCU_width*DCT_scaled_size */
+ int last_col_width; /* # of non-dummy blocks across in last MCU */
+ int last_row_height; /* # of non-dummy blocks down in last MCU */
+
+ /* Saved quantization table for component; NULL if none yet saved.
+ * See jdinput.c comments about the need for this information.
+ * This field is currently used only for decompression.
+ */
+ JQUANT_TBL * quant_table;
+
+ /* Private per-component storage for DCT or IDCT subsystem. */
+ void * dct_table;
+} jpeg_component_info;
+
+
+/* The script for encoding a multiple-scan file is an array of these: */
+
+typedef struct {
+ int comps_in_scan; /* number of components encoded in this scan */
+ int component_index[MAX_COMPS_IN_SCAN]; /* their SOF/comp_info[] indexes */
+ int Ss, Se; /* progressive JPEG spectral selection parms */
+ int Ah, Al; /* progressive JPEG successive approx. parms */
+} jpeg_scan_info;
+
+/* The decompressor can save APPn and COM markers in a list of these: */
+
+typedef struct jpeg_marker_struct FAR * jpeg_saved_marker_ptr;
+
+struct jpeg_marker_struct {
+ jpeg_saved_marker_ptr next; /* next in list, or NULL */
+ UINT8 marker; /* marker code: JPEG_COM, or JPEG_APP0+n */
+ unsigned int original_length; /* # bytes of data in the file */
+ unsigned int data_length; /* # bytes of data saved at data[] */
+ JOCTET FAR * data; /* the data contained in the marker */
+ /* the marker length word is not counted in data_length or original_length */
+};
+
+/* Known color spaces. */
+
+typedef enum {
+ JCS_UNKNOWN, /* error/unspecified */
+ JCS_GRAYSCALE, /* monochrome */
+ JCS_RGB, /* red/green/blue */
+ JCS_YCbCr, /* Y/Cb/Cr (also known as YUV) */
+ JCS_CMYK, /* C/M/Y/K */
+ JCS_YCCK /* Y/Cb/Cr/K */
+} J_COLOR_SPACE;
+
+/* DCT/IDCT algorithm options. */
+
+typedef enum {
+ JDCT_ISLOW, /* slow but accurate integer algorithm */
+ JDCT_IFAST, /* faster, less accurate integer method */
+ JDCT_FLOAT /* floating-point: accurate, fast on fast HW */
+} J_DCT_METHOD;
+
+#ifndef JDCT_DEFAULT /* may be overridden in jconfig.h */
+#define JDCT_DEFAULT JDCT_ISLOW
+#endif
+#ifndef JDCT_FASTEST /* may be overridden in jconfig.h */
+#define JDCT_FASTEST JDCT_IFAST
+#endif
+
+/* Dithering options for decompression. */
+
+typedef enum {
+ JDITHER_NONE, /* no dithering */
+ JDITHER_ORDERED, /* simple ordered dither */
+ JDITHER_FS /* Floyd-Steinberg error diffusion dither */
+} J_DITHER_MODE;
+
+
+/* Common fields between JPEG compression and decompression master structs. */
+
+#define jpeg_common_fields \
+ struct jpeg_error_mgr * err; /* Error handler module */\
+ struct jpeg_memory_mgr * mem; /* Memory manager module */\
+ struct jpeg_progress_mgr * progress; /* Progress monitor, or NULL if none */\
+ void * client_data; /* Available for use by application */\
+ boolean is_decompressor; /* So common code can tell which is which */\
+ int global_state /* For checking call sequence validity */
+
+/* Routines that are to be used by both halves of the library are declared
+ * to receive a pointer to this structure. There are no actual instances of
+ * jpeg_common_struct, only of jpeg_compress_struct and jpeg_decompress_struct.
+ */
+struct jpeg_common_struct {
+ jpeg_common_fields; /* Fields common to both master struct types */
+ /* Additional fields follow in an actual jpeg_compress_struct or
+ * jpeg_decompress_struct. All three structs must agree on these
+ * initial fields! (This would be a lot cleaner in C++.)
+ */
+};
+
+typedef struct jpeg_common_struct * j_common_ptr;
+typedef struct jpeg_compress_struct * j_compress_ptr;
+typedef struct jpeg_decompress_struct * j_decompress_ptr;
+
+
+/* Master record for a compression instance */
+
+struct jpeg_compress_struct {
+ jpeg_common_fields; /* Fields shared with jpeg_decompress_struct */
+
+ /* Destination for compressed data */
+ struct jpeg_destination_mgr * dest;
+
+ /* Description of source image --- these fields must be filled in by
+ * outer application before starting compression. in_color_space must
+ * be correct before you can even call jpeg_set_defaults().
+ */
+
+ JDIMENSION image_width; /* input image width */
+ JDIMENSION image_height; /* input image height */
+ int input_components; /* # of color components in input image */
+ J_COLOR_SPACE in_color_space; /* colorspace of input image */
+
+ double input_gamma; /* image gamma of input image */
+
+ /* Compression parameters --- these fields must be set before calling
+ * jpeg_start_compress(). We recommend calling jpeg_set_defaults() to
+ * initialize everything to reasonable defaults, then changing anything
+ * the application specifically wants to change. That way you won't get
+ * burnt when new parameters are added. Also note that there are several
+ * helper routines to simplify changing parameters.
+ */
+
+ int data_precision; /* bits of precision in image data */
+
+ int num_components; /* # of color components in JPEG image */
+ J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */
+
+ jpeg_component_info * comp_info;
+ /* comp_info[i] describes component that appears i'th in SOF */
+
+ JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS];
+ /* ptrs to coefficient quantization tables, or NULL if not defined */
+
+ JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
+ JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
+ /* ptrs to Huffman coding tables, or NULL if not defined */
+
+ UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */
+ UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */
+ UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */
+
+ int num_scans; /* # of entries in scan_info array */
+ const jpeg_scan_info * scan_info; /* script for multi-scan file, or NULL */
+ /* The default value of scan_info is NULL, which causes a single-scan
+ * sequential JPEG file to be emitted. To create a multi-scan file,
+ * set num_scans and scan_info to point to an array of scan definitions.
+ */
+
+ boolean raw_data_in; /* TRUE=caller supplies downsampled data */
+ boolean arith_code; /* TRUE=arithmetic coding, FALSE=Huffman */
+ boolean optimize_coding; /* TRUE=optimize entropy encoding parms */
+ boolean CCIR601_sampling; /* TRUE=first samples are cosited */
+ int smoothing_factor; /* 1..100, or 0 for no input smoothing */
+ J_DCT_METHOD dct_method; /* DCT algorithm selector */
+
+ /* The restart interval can be specified in absolute MCUs by setting
+ * restart_interval, or in MCU rows by setting restart_in_rows
+ * (in which case the correct restart_interval will be figured
+ * for each scan).
+ */
+ unsigned int restart_interval; /* MCUs per restart, or 0 for no restart */
+ int restart_in_rows; /* if > 0, MCU rows per restart interval */
+
+ /* Parameters controlling emission of special markers. */
+
+ boolean write_JFIF_header; /* should a JFIF marker be written? */
+ UINT8 JFIF_major_version; /* What to write for the JFIF version number */
+ UINT8 JFIF_minor_version;
+ /* These three values are not used by the JPEG code, merely copied */
+ /* into the JFIF APP0 marker. density_unit can be 0 for unknown, */
+ /* 1 for dots/inch, or 2 for dots/cm. Note that the pixel aspect */
+ /* ratio is defined by X_density/Y_density even when density_unit=0. */
+ UINT8 density_unit; /* JFIF code for pixel size units */
+ UINT16 X_density; /* Horizontal pixel density */
+ UINT16 Y_density; /* Vertical pixel density */
+ boolean write_Adobe_marker; /* should an Adobe marker be written? */
+
+ /* State variable: index of next scanline to be written to
+ * jpeg_write_scanlines(). Application may use this to control its
+ * processing loop, e.g., "while (next_scanline < image_height)".
+ */
+
+ JDIMENSION next_scanline; /* 0 .. image_height-1 */
+
+ /* Remaining fields are known throughout compressor, but generally
+ * should not be touched by a surrounding application.
+ */
+
+ /*
+ * These fields are computed during compression startup
+ */
+ boolean progressive_mode; /* TRUE if scan script uses progressive mode */
+ int max_h_samp_factor; /* largest h_samp_factor */
+ int max_v_samp_factor; /* largest v_samp_factor */
+
+ JDIMENSION total_iMCU_rows; /* # of iMCU rows to be input to coef ctlr */
+ /* The coefficient controller receives data in units of MCU rows as defined
+ * for fully interleaved scans (whether the JPEG file is interleaved or not).
+ * There are v_samp_factor * DCTSIZE sample rows of each component in an
+ * "iMCU" (interleaved MCU) row.
+ */
+
+ /*
+ * These fields are valid during any one scan.
+ * They describe the components and MCUs actually appearing in the scan.
+ */
+ int comps_in_scan; /* # of JPEG components in this scan */
+ jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN];
+ /* *cur_comp_info[i] describes component that appears i'th in SOS */
+
+ JDIMENSION MCUs_per_row; /* # of MCUs across the image */
+ JDIMENSION MCU_rows_in_scan; /* # of MCU rows in the image */
+
+ int blocks_in_MCU; /* # of DCT blocks per MCU */
+ int MCU_membership[C_MAX_BLOCKS_IN_MCU];
+ /* MCU_membership[i] is index in cur_comp_info of component owning */
+ /* i'th block in an MCU */
+
+ int Ss, Se, Ah, Al; /* progressive JPEG parameters for scan */
+
+ /*
+ * Links to compression subobjects (methods and private variables of modules)
+ */
+ struct jpeg_comp_master * master;
+ struct jpeg_c_main_controller * main;
+ struct jpeg_c_prep_controller * prep;
+ struct jpeg_c_coef_controller * coef;
+ struct jpeg_marker_writer * marker;
+ struct jpeg_color_converter * cconvert;
+ struct jpeg_downsampler * downsample;
+ struct jpeg_forward_dct * fdct;
+ struct jpeg_entropy_encoder * entropy;
+ jpeg_scan_info * script_space; /* workspace for jpeg_simple_progression */
+ int script_space_size;
+};
+
+
+/* Master record for a decompression instance */
+
+struct jpeg_decompress_struct {
+ jpeg_common_fields; /* Fields shared with jpeg_compress_struct */
+
+ /* Source of compressed data */
+ struct jpeg_source_mgr * src;
+
+ /* Basic description of image --- filled in by jpeg_read_header(). */
+ /* Application may inspect these values to decide how to process image. */
+
+ JDIMENSION image_width; /* nominal image width (from SOF marker) */
+ JDIMENSION image_height; /* nominal image height */
+ int num_components; /* # of color components in JPEG image */
+ J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */
+
+ /* Decompression processing parameters --- these fields must be set before
+ * calling jpeg_start_decompress(). Note that jpeg_read_header() initializes
+ * them to default values.
+ */
+
+ J_COLOR_SPACE out_color_space; /* colorspace for output */
+
+ unsigned int scale_num, scale_denom; /* fraction by which to scale image */
+
+ double output_gamma; /* image gamma wanted in output */
+
+ boolean buffered_image; /* TRUE=multiple output passes */
+ boolean raw_data_out; /* TRUE=downsampled data wanted */
+
+ J_DCT_METHOD dct_method; /* IDCT algorithm selector */
+ boolean do_fancy_upsampling; /* TRUE=apply fancy upsampling */
+ boolean do_block_smoothing; /* TRUE=apply interblock smoothing */
+
+ boolean quantize_colors; /* TRUE=colormapped output wanted */
+ /* the following are ignored if not quantize_colors: */
+ J_DITHER_MODE dither_mode; /* type of color dithering to use */
+ boolean two_pass_quantize; /* TRUE=use two-pass color quantization */
+ int desired_number_of_colors; /* max # colors to use in created colormap */
+ /* these are significant only in buffered-image mode: */
+ boolean enable_1pass_quant; /* enable future use of 1-pass quantizer */
+ boolean enable_external_quant;/* enable future use of external colormap */
+ boolean enable_2pass_quant; /* enable future use of 2-pass quantizer */
+
+ /* Description of actual output image that will be returned to application.
+ * These fields are computed by jpeg_start_decompress().
+ * You can also use jpeg_calc_output_dimensions() to determine these values
+ * in advance of calling jpeg_start_decompress().
+ */
+
+ JDIMENSION output_width; /* scaled image width */
+ JDIMENSION output_height; /* scaled image height */
+ int out_color_components; /* # of color components in out_color_space */
+ int output_components; /* # of color components returned */
+ /* output_components is 1 (a colormap index) when quantizing colors;
+ * otherwise it equals out_color_components.
+ */
+ int rec_outbuf_height; /* min recommended height of scanline buffer */
+ /* If the buffer passed to jpeg_read_scanlines() is less than this many rows
+ * high, space and time will be wasted due to unnecessary data copying.
+ * Usually rec_outbuf_height will be 1 or 2, at most 4.
+ */
+
+ /* When quantizing colors, the output colormap is described by these fields.
+ * The application can supply a colormap by setting colormap non-NULL before
+ * calling jpeg_start_decompress; otherwise a colormap is created during
+ * jpeg_start_decompress or jpeg_start_output.
+ * The map has out_color_components rows and actual_number_of_colors columns.
+ */
+ int actual_number_of_colors; /* number of entries in use */
+ JSAMPARRAY colormap; /* The color map as a 2-D pixel array */
+
+ /* State variables: these variables indicate the progress of decompression.
+ * The application may examine these but must not modify them.
+ */
+
+ /* Row index of next scanline to be read from jpeg_read_scanlines().
+ * Application may use this to control its processing loop, e.g.,
+ * "while (output_scanline < output_height)".
+ */
+ JDIMENSION output_scanline; /* 0 .. output_height-1 */
+
+ /* Current input scan number and number of iMCU rows completed in scan.
+ * These indicate the progress of the decompressor input side.
+ */
+ int input_scan_number; /* Number of SOS markers seen so far */
+ JDIMENSION input_iMCU_row; /* Number of iMCU rows completed */
+
+ /* The "output scan number" is the notional scan being displayed by the
+ * output side. The decompressor will not allow output scan/row number
+ * to get ahead of input scan/row, but it can fall arbitrarily far behind.
+ */
+ int output_scan_number; /* Nominal scan number being displayed */
+ JDIMENSION output_iMCU_row; /* Number of iMCU rows read */
+
+ /* Current progression status. coef_bits[c][i] indicates the precision
+ * with which component c's DCT coefficient i (in zigzag order) is known.
+ * It is -1 when no data has yet been received, otherwise it is the point
+ * transform (shift) value for the most recent scan of the coefficient
+ * (thus, 0 at completion of the progression).
+ * This pointer is NULL when reading a non-progressive file.
+ */
+ int (*coef_bits)[DCTSIZE2]; /* -1 or current Al value for each coef */
+
+ /* Internal JPEG parameters --- the application usually need not look at
+ * these fields. Note that the decompressor output side may not use
+ * any parameters that can change between scans.
+ */
+
+ /* Quantization and Huffman tables are carried forward across input
+ * datastreams when processing abbreviated JPEG datastreams.
+ */
+
+ JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS];
+ /* ptrs to coefficient quantization tables, or NULL if not defined */
+
+ JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
+ JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
+ /* ptrs to Huffman coding tables, or NULL if not defined */
+
+ /* These parameters are never carried across datastreams, since they
+ * are given in SOF/SOS markers or defined to be reset by SOI.
+ */
+
+ int data_precision; /* bits of precision in image data */
+
+ jpeg_component_info * comp_info;
+ /* comp_info[i] describes component that appears i'th in SOF */
+
+ boolean progressive_mode; /* TRUE if SOFn specifies progressive mode */
+ boolean arith_code; /* TRUE=arithmetic coding, FALSE=Huffman */
+
+ UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */
+ UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */
+ UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */
+
+ unsigned int restart_interval; /* MCUs per restart interval, or 0 for no restart */
+
+ /* These fields record data obtained from optional markers recognized by
+ * the JPEG library.
+ */
+ boolean saw_JFIF_marker; /* TRUE iff a JFIF APP0 marker was found */
+ /* Data copied from JFIF marker; only valid if saw_JFIF_marker is TRUE: */
+ UINT8 JFIF_major_version; /* JFIF version number */
+ UINT8 JFIF_minor_version;
+ UINT8 density_unit; /* JFIF code for pixel size units */
+ UINT16 X_density; /* Horizontal pixel density */
+ UINT16 Y_density; /* Vertical pixel density */
+ boolean saw_Adobe_marker; /* TRUE iff an Adobe APP14 marker was found */
+ UINT8 Adobe_transform; /* Color transform code from Adobe marker */
+
+ boolean CCIR601_sampling; /* TRUE=first samples are cosited */
+
+ /* Aside from the specific data retained from APPn markers known to the
+ * library, the uninterpreted contents of any or all APPn and COM markers
+ * can be saved in a list for examination by the application.
+ */
+ jpeg_saved_marker_ptr marker_list; /* Head of list of saved markers */
+
+ /* Remaining fields are known throughout decompressor, but generally
+ * should not be touched by a surrounding application.
+ */
+
+ /*
+ * These fields are computed during decompression startup
+ */
+ int max_h_samp_factor; /* largest h_samp_factor */
+ int max_v_samp_factor; /* largest v_samp_factor */
+
+ int min_DCT_scaled_size; /* smallest DCT_scaled_size of any component */
+
+ JDIMENSION total_iMCU_rows; /* # of iMCU rows in image */
+ /* The coefficient controller's input and output progress is measured in
+ * units of "iMCU" (interleaved MCU) rows. These are the same as MCU rows
+ * in fully interleaved JPEG scans, but are used whether the scan is
+ * interleaved or not. We define an iMCU row as v_samp_factor DCT block
+ * rows of each component. Therefore, the IDCT output contains
+ * v_samp_factor*DCT_scaled_size sample rows of a component per iMCU row.
+ */
+
+ JSAMPLE * sample_range_limit; /* table for fast range-limiting */
+
+ /*
+ * These fields are valid during any one scan.
+ * They describe the components and MCUs actually appearing in the scan.
+ * Note that the decompressor output side must not use these fields.
+ */
+ int comps_in_scan; /* # of JPEG components in this scan */
+ jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN];
+ /* *cur_comp_info[i] describes component that appears i'th in SOS */
+
+ JDIMENSION MCUs_per_row; /* # of MCUs across the image */
+ JDIMENSION MCU_rows_in_scan; /* # of MCU rows in the image */
+
+ int blocks_in_MCU; /* # of DCT blocks per MCU */
+ int MCU_membership[D_MAX_BLOCKS_IN_MCU];
+ /* MCU_membership[i] is index in cur_comp_info of component owning */
+ /* i'th block in an MCU */
+
+ int Ss, Se, Ah, Al; /* progressive JPEG parameters for scan */
+
+ /* This field is shared between entropy decoder and marker parser.
+ * It is either zero or the code of a JPEG marker that has been
+ * read from the data source, but has not yet been processed.
+ */
+ int unread_marker;
+
+ /*
+ * Links to decompression subobjects (methods, private variables of modules)
+ */
+ struct jpeg_decomp_master * master;
+ struct jpeg_d_main_controller * main;
+ struct jpeg_d_coef_controller * coef;
+ struct jpeg_d_post_controller * post;
+ struct jpeg_input_controller * inputctl;
+ struct jpeg_marker_reader * marker;
+ struct jpeg_entropy_decoder * entropy;
+ struct jpeg_inverse_dct * idct;
+ struct jpeg_upsampler * upsample;
+ struct jpeg_color_deconverter * cconvert;
+ struct jpeg_color_quantizer * cquantize;
+};
+
+
+/* "Object" declarations for JPEG modules that may be supplied or called
+ * directly by the surrounding application.
+ * As with all objects in the JPEG library, these structs only define the
+ * publicly visible methods and state variables of a module. Additional
+ * private fields may exist after the public ones.
+ */
+
+
+/* Error handler object */
+
+struct jpeg_error_mgr {
+ /* Error exit handler: does not return to caller */
+ JMETHOD(void, error_exit, (j_common_ptr cinfo));
+ /* Conditionally emit a trace or warning message */
+ JMETHOD(void, emit_message, (j_common_ptr cinfo, int msg_level));
+ /* Routine that actually outputs a trace or error message */
+ JMETHOD(void, output_message, (j_common_ptr cinfo));
+ /* Format a message string for the most recent JPEG error or message */
+ JMETHOD(void, format_message, (j_common_ptr cinfo, char * buffer));
+#define JMSG_LENGTH_MAX 200 /* recommended size of format_message buffer */
+ /* Reset error state variables at start of a new image */
+ JMETHOD(void, reset_error_mgr, (j_common_ptr cinfo));
+
+ /* The message ID code and any parameters are saved here.
+ * A message can have one string parameter or up to 8 int parameters.
+ */
+ int msg_code;
+#define JMSG_STR_PARM_MAX 80
+ union {
+ int i[8];
+ char s[JMSG_STR_PARM_MAX];
+ } msg_parm;
+
+ /* Standard state variables for error facility */
+
+ int trace_level; /* max msg_level that will be displayed */
+
+ /* For recoverable corrupt-data errors, we emit a warning message,
+ * but keep going unless emit_message chooses to abort. emit_message
+ * should count warnings in num_warnings. The surrounding application
+ * can check for bad data by seeing if num_warnings is nonzero at the
+ * end of processing.
+ */
+ long num_warnings; /* number of corrupt-data warnings */
+
+ /* These fields point to the table(s) of error message strings.
+ * An application can change the table pointer to switch to a different
+ * message list (typically, to change the language in which errors are
+ * reported). Some applications may wish to add additional error codes
+ * that will be handled by the JPEG library error mechanism; the second
+ * table pointer is used for this purpose.
+ *
+ * First table includes all errors generated by JPEG library itself.
+ * Error code 0 is reserved for a "no such error string" message.
+ */
+ const char * const * jpeg_message_table; /* Library errors */
+ int last_jpeg_message; /* Table contains strings 0..last_jpeg_message */
+ /* Second table can be added by application (see cjpeg/djpeg for example).
+ * It contains strings numbered first_addon_message..last_addon_message.
+ */
+ const char * const * addon_message_table; /* Non-library errors */
+ int first_addon_message; /* code for first string in addon table */
+ int last_addon_message; /* code for last string in addon table */
+};
+
+
+/* Progress monitor object */
+
+struct jpeg_progress_mgr {
+ JMETHOD(void, progress_monitor, (j_common_ptr cinfo));
+
+ long pass_counter; /* work units completed in this pass */
+ long pass_limit; /* total number of work units in this pass */
+ int completed_passes; /* passes completed so far */
+ int total_passes; /* total number of passes expected */
+};
+
+
+/* Data destination object for compression */
+
+struct jpeg_destination_mgr {
+ JOCTET * next_output_byte; /* => next byte to write in buffer */
+ size_t free_in_buffer; /* # of byte spaces remaining in buffer */
+
+ JMETHOD(void, init_destination, (j_compress_ptr cinfo));
+ JMETHOD(boolean, empty_output_buffer, (j_compress_ptr cinfo));
+ JMETHOD(void, term_destination, (j_compress_ptr cinfo));
+};
+
+
+/* Data source object for decompression */
+
+struct jpeg_source_mgr {
+ const JOCTET * next_input_byte; /* => next byte to read from buffer */
+ size_t bytes_in_buffer; /* # of bytes remaining in buffer */
+
+ JMETHOD(void, init_source, (j_decompress_ptr cinfo));
+ JMETHOD(boolean, fill_input_buffer, (j_decompress_ptr cinfo));
+ JMETHOD(void, skip_input_data, (j_decompress_ptr cinfo, long num_bytes));
+ JMETHOD(boolean, resync_to_restart, (j_decompress_ptr cinfo, int desired));
+ JMETHOD(void, term_source, (j_decompress_ptr cinfo));
+};
+
+
+/* Memory manager object.
+ * Allocates "small" objects (a few K total), "large" objects (tens of K),
+ * and "really big" objects (virtual arrays with backing store if needed).
+ * The memory manager does not allow individual objects to be freed; rather,
+ * each created object is assigned to a pool, and whole pools can be freed
+ * at once. This is faster and more convenient than remembering exactly what
+ * to free, especially where malloc()/free() are not too speedy.
+ * NB: alloc routines never return NULL. They exit to error_exit if not
+ * successful.
+ */
+
+#define JPOOL_PERMANENT 0 /* lasts until master record is destroyed */
+#define JPOOL_IMAGE 1 /* lasts until done with image/datastream */
+#define JPOOL_NUMPOOLS 2
+
+typedef struct jvirt_sarray_control * jvirt_sarray_ptr;
+typedef struct jvirt_barray_control * jvirt_barray_ptr;
+
+
+struct jpeg_memory_mgr {
+ /* Method pointers */
+ JMETHOD(void *, alloc_small, (j_common_ptr cinfo, int pool_id,
+ size_t sizeofobject));
+ JMETHOD(void FAR *, alloc_large, (j_common_ptr cinfo, int pool_id,
+ size_t sizeofobject));
+ JMETHOD(JSAMPARRAY, alloc_sarray, (j_common_ptr cinfo, int pool_id,
+ JDIMENSION samplesperrow,
+ JDIMENSION numrows));
+ JMETHOD(JBLOCKARRAY, alloc_barray, (j_common_ptr cinfo, int pool_id,
+ JDIMENSION blocksperrow,
+ JDIMENSION numrows));
+ JMETHOD(jvirt_sarray_ptr, request_virt_sarray, (j_common_ptr cinfo,
+ int pool_id,
+ boolean pre_zero,
+ JDIMENSION samplesperrow,
+ JDIMENSION numrows,
+ JDIMENSION maxaccess));
+ JMETHOD(jvirt_barray_ptr, request_virt_barray, (j_common_ptr cinfo,
+ int pool_id,
+ boolean pre_zero,
+ JDIMENSION blocksperrow,
+ JDIMENSION numrows,
+ JDIMENSION maxaccess));
+ JMETHOD(void, realize_virt_arrays, (j_common_ptr cinfo));
+ JMETHOD(JSAMPARRAY, access_virt_sarray, (j_common_ptr cinfo,
+ jvirt_sarray_ptr ptr,
+ JDIMENSION start_row,
+ JDIMENSION num_rows,
+ boolean writable));
+ JMETHOD(JBLOCKARRAY, access_virt_barray, (j_common_ptr cinfo,
+ jvirt_barray_ptr ptr,
+ JDIMENSION start_row,
+ JDIMENSION num_rows,
+ boolean writable));
+ JMETHOD(void, free_pool, (j_common_ptr cinfo, int pool_id));
+ JMETHOD(void, self_destruct, (j_common_ptr cinfo));
+
+ /* Limit on memory allocation for this JPEG object. (Note that this is
+ * merely advisory, not a guaranteed maximum; it only affects the space
+ * used for virtual-array buffers.) May be changed by outer application
+ * after creating the JPEG object.
+ */
+ long max_memory_to_use;
+
+ /* Maximum allocation request accepted by alloc_large. */
+ long max_alloc_chunk;
+};
+
+
+/* Routine signature for application-supplied marker processing methods.
+ * Need not pass marker code since it is stored in cinfo->unread_marker.
+ */
+typedef JMETHOD(boolean, jpeg_marker_parser_method, (j_decompress_ptr cinfo));
+
+
+/* Declarations for routines called by application.
+ * The JPP macro hides prototype parameters from compilers that can't cope.
+ * Note JPP requires double parentheses.
+ */
+
+#ifdef HAVE_PROTOTYPES
+#define JPP(arglist) arglist
+#else
+#define JPP(arglist) ()
+#endif
+
+
+/* Short forms of external names for systems with brain-damaged linkers.
+ * We shorten external names to be unique in the first six letters, which
+ * is good enough for all known systems.
+ * (If your compiler itself needs names to be unique in less than 15
+ * characters, you are out of luck. Get a better compiler.)
+ */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_std_error jStdError
+#define jpeg_CreateCompress jCreaCompress
+#define jpeg_CreateDecompress jCreaDecompress
+#define jpeg_destroy_compress jDestCompress
+#define jpeg_destroy_decompress jDestDecompress
+#define jpeg_stdio_dest jStdDest
+#define jpeg_stdio_src jStdSrc
+#define jpeg_set_defaults jSetDefaults
+#define jpeg_set_colorspace jSetColorspace
+#define jpeg_default_colorspace jDefColorspace
+#define jpeg_set_quality jSetQuality
+#define jpeg_set_linear_quality jSetLQuality
+#define jpeg_add_quant_table jAddQuantTable
+#define jpeg_quality_scaling jQualityScaling
+#define jpeg_simple_progression jSimProgress
+#define jpeg_suppress_tables jSuppressTables
+#define jpeg_alloc_quant_table jAlcQTable
+#define jpeg_alloc_huff_table jAlcHTable
+#define jpeg_start_compress jStrtCompress
+#define jpeg_write_scanlines jWrtScanlines
+#define jpeg_finish_compress jFinCompress
+#define jpeg_write_raw_data jWrtRawData
+#define jpeg_write_marker jWrtMarker
+#define jpeg_write_m_header jWrtMHeader
+#define jpeg_write_m_byte jWrtMByte
+#define jpeg_write_tables jWrtTables
+#define jpeg_read_header jReadHeader
+#define jpeg_start_decompress jStrtDecompress
+#define jpeg_read_scanlines jReadScanlines
+#define jpeg_finish_decompress jFinDecompress
+#define jpeg_read_raw_data jReadRawData
+#define jpeg_has_multiple_scans jHasMultScn
+#define jpeg_start_output jStrtOutput
+#define jpeg_finish_output jFinOutput
+#define jpeg_input_complete jInComplete
+#define jpeg_new_colormap jNewCMap
+#define jpeg_consume_input jConsumeInput
+#define jpeg_calc_output_dimensions jCalcDimensions
+#define jpeg_save_markers jSaveMarkers
+#define jpeg_set_marker_processor jSetMarker
+#define jpeg_read_coefficients jReadCoefs
+#define jpeg_write_coefficients jWrtCoefs
+#define jpeg_copy_critical_parameters jCopyCrit
+#define jpeg_abort_compress jAbrtCompress
+#define jpeg_abort_decompress jAbrtDecompress
+#define jpeg_abort jAbort
+#define jpeg_destroy jDestroy
+#define jpeg_resync_to_restart jResyncRestart
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+
+/* Default error-management setup */
+EXTERN(struct jpeg_error_mgr *) jpeg_std_error
+ JPP((struct jpeg_error_mgr * err));
+
+/* Initialization of JPEG compression objects.
+ * jpeg_create_compress() and jpeg_create_decompress() are the exported
+ * names that applications should call. These expand to calls on
+ * jpeg_CreateCompress and jpeg_CreateDecompress with additional information
+ * passed for version mismatch checking.
+ * NB: you must set up the error-manager BEFORE calling jpeg_create_xxx.
+ */
+#define jpeg_create_compress(cinfo) \
+ jpeg_CreateCompress((cinfo), JPEG_LIB_VERSION, \
+ (size_t) sizeof(struct jpeg_compress_struct))
+#define jpeg_create_decompress(cinfo) \
+ jpeg_CreateDecompress((cinfo), JPEG_LIB_VERSION, \
+ (size_t) sizeof(struct jpeg_decompress_struct))
+EXTERN(void) jpeg_CreateCompress JPP((j_compress_ptr cinfo,
+ int version, size_t structsize));
+EXTERN(void) jpeg_CreateDecompress JPP((j_decompress_ptr cinfo,
+ int version, size_t structsize));
+/* Destruction of JPEG compression objects */
+EXTERN(void) jpeg_destroy_compress JPP((j_compress_ptr cinfo));
+EXTERN(void) jpeg_destroy_decompress JPP((j_decompress_ptr cinfo));
+
+/* Standard data source and destination managers: stdio streams. */
+/* Caller is responsible for opening the file before and closing after. */
+EXTERN(void) jpeg_stdio_dest JPP((j_compress_ptr cinfo, FILE * outfile));
+EXTERN(void) jpeg_stdio_src JPP((j_decompress_ptr cinfo, FILE * infile));
+
+/* Default parameter setup for compression */
+EXTERN(void) jpeg_set_defaults JPP((j_compress_ptr cinfo));
+/* Compression parameter setup aids */
+EXTERN(void) jpeg_set_colorspace JPP((j_compress_ptr cinfo,
+ J_COLOR_SPACE colorspace));
+EXTERN(void) jpeg_default_colorspace JPP((j_compress_ptr cinfo));
+EXTERN(void) jpeg_set_quality JPP((j_compress_ptr cinfo, int quality,
+ boolean force_baseline));
+EXTERN(void) jpeg_set_linear_quality JPP((j_compress_ptr cinfo,
+ int scale_factor,
+ boolean force_baseline));
+EXTERN(void) jpeg_add_quant_table JPP((j_compress_ptr cinfo, int which_tbl,
+ const unsigned int *basic_table,
+ int scale_factor,
+ boolean force_baseline));
+EXTERN(int) jpeg_quality_scaling JPP((int quality));
+EXTERN(void) jpeg_simple_progression JPP((j_compress_ptr cinfo));
+EXTERN(void) jpeg_suppress_tables JPP((j_compress_ptr cinfo,
+ boolean suppress));
+EXTERN(JQUANT_TBL *) jpeg_alloc_quant_table JPP((j_common_ptr cinfo));
+EXTERN(JHUFF_TBL *) jpeg_alloc_huff_table JPP((j_common_ptr cinfo));
+
+/* Main entry points for compression */
+EXTERN(void) jpeg_start_compress JPP((j_compress_ptr cinfo,
+ boolean write_all_tables));
+EXTERN(JDIMENSION) jpeg_write_scanlines JPP((j_compress_ptr cinfo,
+ JSAMPARRAY scanlines,
+ JDIMENSION num_lines));
+EXTERN(void) jpeg_finish_compress JPP((j_compress_ptr cinfo));
+
+/* Replaces jpeg_write_scanlines when writing raw downsampled data. */
+EXTERN(JDIMENSION) jpeg_write_raw_data JPP((j_compress_ptr cinfo,
+ JSAMPIMAGE data,
+ JDIMENSION num_lines));
+
+/* Write a special marker. See libjpeg.doc concerning safe usage. */
+EXTERN(void) jpeg_write_marker
+ JPP((j_compress_ptr cinfo, int marker,
+ const JOCTET * dataptr, unsigned int datalen));
+/* Same, but piecemeal. */
+EXTERN(void) jpeg_write_m_header
+ JPP((j_compress_ptr cinfo, int marker, unsigned int datalen));
+EXTERN(void) jpeg_write_m_byte
+ JPP((j_compress_ptr cinfo, int val));
+
+/* Alternate compression function: just write an abbreviated table file */
+EXTERN(void) jpeg_write_tables JPP((j_compress_ptr cinfo));
+
+/* Decompression startup: read start of JPEG datastream to see what's there */
+EXTERN(int) jpeg_read_header JPP((j_decompress_ptr cinfo,
+ boolean require_image));
+/* Return value is one of: */
+#define JPEG_SUSPENDED 0 /* Suspended due to lack of input data */
+#define JPEG_HEADER_OK 1 /* Found valid image datastream */
+#define JPEG_HEADER_TABLES_ONLY 2 /* Found valid table-specs-only datastream */
+/* If you pass require_image = TRUE (normal case), you need not check for
+ * a TABLES_ONLY return code; an abbreviated file will cause an error exit.
+ * JPEG_SUSPENDED is only possible if you use a data source module that can
+ * give a suspension return (the stdio source module doesn't).
+ */
+
+/* Main entry points for decompression */
+EXTERN(boolean) jpeg_start_decompress JPP((j_decompress_ptr cinfo));
+EXTERN(JDIMENSION) jpeg_read_scanlines JPP((j_decompress_ptr cinfo,
+ JSAMPARRAY scanlines,
+ JDIMENSION max_lines));
+EXTERN(boolean) jpeg_finish_decompress JPP((j_decompress_ptr cinfo));
+
+/* Replaces jpeg_read_scanlines when reading raw downsampled data. */
+EXTERN(JDIMENSION) jpeg_read_raw_data JPP((j_decompress_ptr cinfo,
+ JSAMPIMAGE data,
+ JDIMENSION max_lines));
+
+/* Additional entry points for buffered-image mode. */
+EXTERN(boolean) jpeg_has_multiple_scans JPP((j_decompress_ptr cinfo));
+EXTERN(boolean) jpeg_start_output JPP((j_decompress_ptr cinfo,
+ int scan_number));
+EXTERN(boolean) jpeg_finish_output JPP((j_decompress_ptr cinfo));
+EXTERN(boolean) jpeg_input_complete JPP((j_decompress_ptr cinfo));
+EXTERN(void) jpeg_new_colormap JPP((j_decompress_ptr cinfo));
+EXTERN(int) jpeg_consume_input JPP((j_decompress_ptr cinfo));
+/* Return value is one of: */
+/* #define JPEG_SUSPENDED 0 Suspended due to lack of input data */
+#define JPEG_REACHED_SOS 1 /* Reached start of new scan */
+#define JPEG_REACHED_EOI 2 /* Reached end of image */
+#define JPEG_ROW_COMPLETED 3 /* Completed one iMCU row */
+#define JPEG_SCAN_COMPLETED 4 /* Completed last iMCU row of a scan */
+
+/* Precalculate output dimensions for current decompression parameters. */
+EXTERN(void) jpeg_calc_output_dimensions JPP((j_decompress_ptr cinfo));
+
+/* Control saving of COM and APPn markers into marker_list. */
+EXTERN(void) jpeg_save_markers
+ JPP((j_decompress_ptr cinfo, int marker_code,
+ unsigned int length_limit));
+
+/* Install a special processing method for COM or APPn markers. */
+EXTERN(void) jpeg_set_marker_processor
+ JPP((j_decompress_ptr cinfo, int marker_code,
+ jpeg_marker_parser_method routine));
+
+/* Read or write raw DCT coefficients --- useful for lossless transcoding. */
+EXTERN(jvirt_barray_ptr *) jpeg_read_coefficients JPP((j_decompress_ptr cinfo));
+EXTERN(void) jpeg_write_coefficients JPP((j_compress_ptr cinfo,
+ jvirt_barray_ptr * coef_arrays));
+EXTERN(void) jpeg_copy_critical_parameters JPP((j_decompress_ptr srcinfo,
+ j_compress_ptr dstinfo));
+
+/* If you choose to abort compression or decompression before completing
+ * jpeg_finish_(de)compress, then you need to clean up to release memory,
+ * temporary files, etc. You can just call jpeg_destroy_(de)compress
+ * if you're done with the JPEG object, but if you want to clean it up and
+ * reuse it, call this:
+ */
+EXTERN(void) jpeg_abort_compress JPP((j_compress_ptr cinfo));
+EXTERN(void) jpeg_abort_decompress JPP((j_decompress_ptr cinfo));
+
+/* Generic versions of jpeg_abort and jpeg_destroy that work on either
+ * flavor of JPEG object. These may be more convenient in some places.
+ */
+EXTERN(void) jpeg_abort JPP((j_common_ptr cinfo));
+EXTERN(void) jpeg_destroy JPP((j_common_ptr cinfo));
+
+/* Default restart-marker-resync procedure for use by data source modules */
+EXTERN(boolean) jpeg_resync_to_restart JPP((j_decompress_ptr cinfo,
+ int desired));
+
+
+/* These marker codes are exported since applications and data source modules
+ * are likely to want to use them.
+ */
+
+#define JPEG_RST0 0xD0 /* RST0 marker code */
+#define JPEG_EOI 0xD9 /* EOI marker code */
+#define JPEG_APP0 0xE0 /* APP0 marker code */
+#define JPEG_COM 0xFE /* COM marker code */
+
+
+/* If we have a brain-damaged compiler that emits warnings (or worse, errors)
+ * for structure definitions that are never filled in, keep it quiet by
+ * supplying dummy definitions for the various substructures.
+ */
+
+#ifdef INCOMPLETE_TYPES_BROKEN
+#ifndef JPEG_INTERNALS /* will be defined in jpegint.h */
+struct jvirt_sarray_control { long dummy; };
+struct jvirt_barray_control { long dummy; };
+struct jpeg_comp_master { long dummy; };
+struct jpeg_c_main_controller { long dummy; };
+struct jpeg_c_prep_controller { long dummy; };
+struct jpeg_c_coef_controller { long dummy; };
+struct jpeg_marker_writer { long dummy; };
+struct jpeg_color_converter { long dummy; };
+struct jpeg_downsampler { long dummy; };
+struct jpeg_forward_dct { long dummy; };
+struct jpeg_entropy_encoder { long dummy; };
+struct jpeg_decomp_master { long dummy; };
+struct jpeg_d_main_controller { long dummy; };
+struct jpeg_d_coef_controller { long dummy; };
+struct jpeg_d_post_controller { long dummy; };
+struct jpeg_input_controller { long dummy; };
+struct jpeg_marker_reader { long dummy; };
+struct jpeg_entropy_decoder { long dummy; };
+struct jpeg_inverse_dct { long dummy; };
+struct jpeg_upsampler { long dummy; };
+struct jpeg_color_deconverter { long dummy; };
+struct jpeg_color_quantizer { long dummy; };
+#endif /* JPEG_INTERNALS */
+#endif /* INCOMPLETE_TYPES_BROKEN */
+
+
+/*
+ * The JPEG library modules define JPEG_INTERNALS before including this file.
+ * The internal structure declarations are read only when that is true.
+ * Applications using the library should not include jpegint.h, but may wish
+ * to include jerror.h.
+ */
+
+#ifdef JPEG_INTERNALS
+#include "jpegint.h" /* fetch private declarations */
+#include "jerror.h" /* fetch error codes too */
+#endif
+
+#endif /* JPEGLIB_H */
--- /dev/null
+/*
+ * jquant1.c
+ *
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * 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 1-pass color quantization (color mapping) routines.
+ * These routines provide mapping to a fixed color map using equally spaced
+ * color values. Optional Floyd-Steinberg or ordered dithering is available.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+#ifdef QUANT_1PASS_SUPPORTED
+
+
+/*
+ * The main purpose of 1-pass quantization is to provide a fast, if not very
+ * high quality, colormapped output capability. A 2-pass quantizer usually
+ * gives better visual quality; however, for quantized grayscale output this
+ * quantizer is perfectly adequate. Dithering is highly recommended with this
+ * quantizer, though you can turn it off if you really want to.
+ *
+ * In 1-pass quantization the colormap must be chosen in advance of seeing the
+ * image. We use a map consisting of all combinations of Ncolors[i] color
+ * values for the i'th component. The Ncolors[] values are chosen so that
+ * their product, the total number of colors, is no more than that requested.
+ * (In most cases, the product will be somewhat less.)
+ *
+ * Since the colormap is orthogonal, the representative value for each color
+ * component can be determined without considering the other components;
+ * then these indexes can be combined into a colormap index by a standard
+ * N-dimensional-array-subscript calculation. Most of the arithmetic involved
+ * can be precalculated and stored in the lookup table colorindex[].
+ * colorindex[i][j] maps pixel value j in component i to the nearest
+ * representative value (grid plane) for that component; this index is
+ * multiplied by the array stride for component i, so that the
+ * index of the colormap entry closest to a given pixel value is just
+ * sum( colorindex[component-number][pixel-component-value] )
+ * Aside from being fast, this scheme allows for variable spacing between
+ * representative values with no additional lookup cost.
+ *
+ * If gamma correction has been applied in color conversion, it might be wise
+ * to adjust the color grid spacing so that the representative colors are
+ * equidistant in linear space. At this writing, gamma correction is not
+ * implemented by jdcolor, so nothing is done here.
+ */
+
+
+/* Declarations for ordered dithering.
+ *
+ * We use a standard 16x16 ordered dither array. The basic concept of ordered
+ * dithering is described in many references, for instance Dale Schumacher's
+ * chapter II.2 of Graphics Gems II (James Arvo, ed. Academic Press, 1991).
+ * In place of Schumacher's comparisons against a "threshold" value, we add a
+ * "dither" value to the input pixel and then round the result to the nearest
+ * output value. The dither value is equivalent to (0.5 - threshold) times
+ * the distance between output values. For ordered dithering, we assume that
+ * the output colors are equally spaced; if not, results will probably be
+ * worse, since the dither may be too much or too little at a given point.
+ *
+ * The normal calculation would be to form pixel value + dither, range-limit
+ * this to 0..MAXJSAMPLE, and then index into the colorindex table as usual.
+ * We can skip the separate range-limiting step by extending the colorindex
+ * table in both directions.
+ */
+
+#define ODITHER_SIZE 16 /* dimension of dither matrix */
+/* NB: if ODITHER_SIZE is not a power of 2, ODITHER_MASK uses will break */
+#define ODITHER_CELLS (ODITHER_SIZE*ODITHER_SIZE) /* # cells in matrix */
+#define ODITHER_MASK (ODITHER_SIZE-1) /* mask for wrapping around counters */
+
+typedef int ODITHER_MATRIX[ODITHER_SIZE][ODITHER_SIZE];
+typedef int (*ODITHER_MATRIX_PTR)[ODITHER_SIZE];
+
+static const UINT8 base_dither_matrix[ODITHER_SIZE][ODITHER_SIZE] = {
+ /* Bayer's order-4 dither array. Generated by the code given in
+ * Stephen Hawley's article "Ordered Dithering" in Graphics Gems I.
+ * The values in this array must range from 0 to ODITHER_CELLS-1.
+ */
+ { 0,192, 48,240, 12,204, 60,252, 3,195, 51,243, 15,207, 63,255 },
+ { 128, 64,176,112,140, 76,188,124,131, 67,179,115,143, 79,191,127 },
+ { 32,224, 16,208, 44,236, 28,220, 35,227, 19,211, 47,239, 31,223 },
+ { 160, 96,144, 80,172,108,156, 92,163, 99,147, 83,175,111,159, 95 },
+ { 8,200, 56,248, 4,196, 52,244, 11,203, 59,251, 7,199, 55,247 },
+ { 136, 72,184,120,132, 68,180,116,139, 75,187,123,135, 71,183,119 },
+ { 40,232, 24,216, 36,228, 20,212, 43,235, 27,219, 39,231, 23,215 },
+ { 168,104,152, 88,164,100,148, 84,171,107,155, 91,167,103,151, 87 },
+ { 2,194, 50,242, 14,206, 62,254, 1,193, 49,241, 13,205, 61,253 },
+ { 130, 66,178,114,142, 78,190,126,129, 65,177,113,141, 77,189,125 },
+ { 34,226, 18,210, 46,238, 30,222, 33,225, 17,209, 45,237, 29,221 },
+ { 162, 98,146, 82,174,110,158, 94,161, 97,145, 81,173,109,157, 93 },
+ { 10,202, 58,250, 6,198, 54,246, 9,201, 57,249, 5,197, 53,245 },
+ { 138, 74,186,122,134, 70,182,118,137, 73,185,121,133, 69,181,117 },
+ { 42,234, 26,218, 38,230, 22,214, 41,233, 25,217, 37,229, 21,213 },
+ { 170,106,154, 90,166,102,150, 86,169,105,153, 89,165,101,149, 85 }
+};
+
+
+/* Declarations for Floyd-Steinberg dithering.
+ *
+ * Errors are accumulated into the array fserrors[], at a resolution of
+ * 1/16th of a pixel count. The error at a given pixel is propagated
+ * to its not-yet-processed neighbors using the standard F-S fractions,
+ * ... (here) 7/16
+ * 3/16 5/16 1/16
+ * We work left-to-right on even rows, right-to-left on odd rows.
+ *
+ * We can get away with a single array (holding one row's worth of errors)
+ * by using it to store the current row's errors at pixel columns not yet
+ * processed, but the next row's errors at columns already processed. We
+ * need only a few extra variables to hold the errors immediately around the
+ * current column. (If we are lucky, those variables are in registers, but
+ * even if not, they're probably cheaper to access than array elements are.)
+ *
+ * The fserrors[] array is indexed [component#][position].
+ * We provide (#columns + 2) entries per component; the extra entry at each
+ * end saves us from special-casing the first and last pixels.
+ *
+ * Note: on a wide image, we might not have enough room in a PC's near data
+ * segment to hold the error array; so it is allocated with alloc_large.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+typedef INT16 FSERROR; /* 16 bits should be enough */
+typedef int LOCFSERROR; /* use 'int' for calculation temps */
+#else
+typedef INT32 FSERROR; /* may need more than 16 bits */
+typedef INT32 LOCFSERROR; /* be sure calculation temps are big enough */
+#endif
+
+typedef FSERROR FAR *FSERRPTR; /* pointer to error array (in FAR storage!) */
+
+
+/* Private subobject */
+
+#define MAX_Q_COMPS 4 /* max components I can handle */
+
+typedef struct {
+ struct jpeg_color_quantizer pub; /* public fields */
+
+ /* Initially allocated colormap is saved here */
+ JSAMPARRAY sv_colormap; /* The color map as a 2-D pixel array */
+ int sv_actual; /* number of entries in use */
+
+ JSAMPARRAY colorindex; /* Precomputed mapping for speed */
+ /* colorindex[i][j] = index of color closest to pixel value j in component i,
+ * premultiplied as described above. Since colormap indexes must fit into
+ * JSAMPLEs, the entries of this array will too.
+ */
+ boolean is_padded; /* is the colorindex padded for odither? */
+
+ int Ncolors[MAX_Q_COMPS]; /* # of values alloced to each component */
+
+ /* Variables for ordered dithering */
+ int row_index; /* cur row's vertical index in dither matrix */
+ ODITHER_MATRIX_PTR odither[MAX_Q_COMPS]; /* one dither array per component */
+
+ /* Variables for Floyd-Steinberg dithering */
+ FSERRPTR fserrors[MAX_Q_COMPS]; /* accumulated errors */
+ boolean on_odd_row; /* flag to remember which row we are on */
+} my_cquantizer;
+
+typedef my_cquantizer * my_cquantize_ptr;
+
+
+/*
+ * Policy-making subroutines for create_colormap and create_colorindex.
+ * These routines determine the colormap to be used. The rest of the module
+ * only assumes that the colormap is orthogonal.
+ *
+ * * select_ncolors decides how to divvy up the available colors
+ * among the components.
+ * * output_value defines the set of representative values for a component.
+ * * largest_input_value defines the mapping from input values to
+ * representative values for a component.
+ * Note that the latter two routines may impose different policies for
+ * different components, though this is not currently done.
+ */
+
+
+LOCAL(int)
+select_ncolors (j_decompress_ptr cinfo, int Ncolors[])
+/* Determine allocation of desired colors to components, */
+/* and fill in Ncolors[] array to indicate choice. */
+/* Return value is total number of colors (product of Ncolors[] values). */
+{
+ int nc = cinfo->out_color_components; /* number of color components */
+ int max_colors = cinfo->desired_number_of_colors;
+ int total_colors, iroot, i, j;
+ boolean changed;
+ long temp;
+ static const int RGB_order[3] = { RGB_GREEN, RGB_RED, RGB_BLUE };
+
+ /* We can allocate at least the nc'th root of max_colors per component. */
+ /* Compute floor(nc'th root of max_colors). */
+ iroot = 1;
+ do {
+ iroot++;
+ temp = iroot; /* set temp = iroot ** nc */
+ for (i = 1; i < nc; i++)
+ temp *= iroot;
+ } while (temp <= (long) max_colors); /* repeat till iroot exceeds root */
+ iroot--; /* now iroot = floor(root) */
+
+ /* Must have at least 2 color values per component */
+ if (iroot < 2)
+ ERREXIT1(cinfo, JERR_QUANT_FEW_COLORS, (int) temp);
+
+ /* Initialize to iroot color values for each component */
+ total_colors = 1;
+ for (i = 0; i < nc; i++) {
+ Ncolors[i] = iroot;
+ total_colors *= iroot;
+ }
+ /* We may be able to increment the count for one or more components without
+ * exceeding max_colors, though we know not all can be incremented.
+ * Sometimes, the first component can be incremented more than once!
+ * (Example: for 16 colors, we start at 2*2*2, go to 3*2*2, then 4*2*2.)
+ * In RGB colorspace, try to increment G first, then R, then B.
+ */
+ do {
+ changed = FALSE;
+ for (i = 0; i < nc; i++) {
+ j = (cinfo->out_color_space == JCS_RGB ? RGB_order[i] : i);
+ /* calculate new total_colors if Ncolors[j] is incremented */
+ temp = total_colors / Ncolors[j];
+ temp *= Ncolors[j]+1; /* done in long arith to avoid oflo */
+ if (temp > (long) max_colors)
+ break; /* won't fit, done with this pass */
+ Ncolors[j]++; /* OK, apply the increment */
+ total_colors = (int) temp;
+ changed = TRUE;
+ }
+ } while (changed);
+
+ return total_colors;
+}
+
+
+LOCAL(int)
+output_value (j_decompress_ptr cinfo, int ci, int j, int maxj)
+/* Return j'th output value, where j will range from 0 to maxj */
+/* The output values must fall in 0..MAXJSAMPLE in increasing order */
+{
+ /* We always provide values 0 and MAXJSAMPLE for each component;
+ * any additional values are equally spaced between these limits.
+ * (Forcing the upper and lower values to the limits ensures that
+ * dithering can't produce a color outside the selected gamut.)
+ */
+ return (int) (((INT32) j * MAXJSAMPLE + maxj/2) / maxj);
+}
+
+
+LOCAL(int)
+largest_input_value (j_decompress_ptr cinfo, int ci, int j, int maxj)
+/* Return largest input value that should map to j'th output value */
+/* Must have largest(j=0) >= 0, and largest(j=maxj) >= MAXJSAMPLE */
+{
+ /* Breakpoints are halfway between values returned by output_value */
+ return (int) (((INT32) (2*j + 1) * MAXJSAMPLE + maxj) / (2*maxj));
+}
+
+
+/*
+ * Create the colormap.
+ */
+
+LOCAL(void)
+create_colormap (j_decompress_ptr cinfo)
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ JSAMPARRAY colormap; /* Created colormap */
+ int total_colors; /* Number of distinct output colors */
+ int i,j,k, nci, blksize, blkdist, ptr, val;
+
+ /* Select number of colors for each component */
+ total_colors = select_ncolors(cinfo, cquantize->Ncolors);
+
+ /* Report selected color counts */
+ if (cinfo->out_color_components == 3)
+ TRACEMS4(cinfo, 1, JTRC_QUANT_3_NCOLORS,
+ total_colors, cquantize->Ncolors[0],
+ cquantize->Ncolors[1], cquantize->Ncolors[2]);
+ else
+ TRACEMS1(cinfo, 1, JTRC_QUANT_NCOLORS, total_colors);
+
+ /* Allocate and fill in the colormap. */
+ /* The colors are ordered in the map in standard row-major order, */
+ /* i.e. rightmost (highest-indexed) color changes most rapidly. */
+
+ colormap = (*cinfo->mem->alloc_sarray)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (JDIMENSION) total_colors, (JDIMENSION) cinfo->out_color_components);
+
+ /* blksize is number of adjacent repeated entries for a component */
+ /* blkdist is distance between groups of identical entries for a component */
+ blkdist = total_colors;
+
+ for (i = 0; i < cinfo->out_color_components; i++) {
+ /* fill in colormap entries for i'th color component */
+ nci = cquantize->Ncolors[i]; /* # of distinct values for this color */
+ blksize = blkdist / nci;
+ for (j = 0; j < nci; j++) {
+ /* Compute j'th output value (out of nci) for component */
+ val = output_value(cinfo, i, j, nci-1);
+ /* Fill in all colormap entries that have this value of this component */
+ for (ptr = j * blksize; ptr < total_colors; ptr += blkdist) {
+ /* fill in blksize entries beginning at ptr */
+ for (k = 0; k < blksize; k++)
+ colormap[i][ptr+k] = (JSAMPLE) val;
+ }
+ }
+ blkdist = blksize; /* blksize of this color is blkdist of next */
+ }
+
+ /* Save the colormap in private storage,
+ * where it will survive color quantization mode changes.
+ */
+ cquantize->sv_colormap = colormap;
+ cquantize->sv_actual = total_colors;
+}
+
+
+/*
+ * Create the color index table.
+ */
+
+LOCAL(void)
+create_colorindex (j_decompress_ptr cinfo)
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ JSAMPROW indexptr;
+ int i,j,k, nci, blksize, val, pad;
+
+ /* For ordered dither, we pad the color index tables by MAXJSAMPLE in
+ * each direction (input index values can be -MAXJSAMPLE .. 2*MAXJSAMPLE).
+ * This is not necessary in the other dithering modes. However, we
+ * flag whether it was done in case user changes dithering mode.
+ */
+ if (cinfo->dither_mode == JDITHER_ORDERED) {
+ pad = MAXJSAMPLE*2;
+ cquantize->is_padded = TRUE;
+ } else {
+ pad = 0;
+ cquantize->is_padded = FALSE;
+ }
+
+ cquantize->colorindex = (*cinfo->mem->alloc_sarray)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (JDIMENSION) (MAXJSAMPLE+1 + pad),
+ (JDIMENSION) cinfo->out_color_components);
+
+ /* blksize is number of adjacent repeated entries for a component */
+ blksize = cquantize->sv_actual;
+
+ for (i = 0; i < cinfo->out_color_components; i++) {
+ /* fill in colorindex entries for i'th color component */
+ nci = cquantize->Ncolors[i]; /* # of distinct values for this color */
+ blksize = blksize / nci;
+
+ /* adjust colorindex pointers to provide padding at negative indexes. */
+ if (pad)
+ cquantize->colorindex[i] += MAXJSAMPLE;
+
+ /* in loop, val = index of current output value, */
+ /* and k = largest j that maps to current val */
+ indexptr = cquantize->colorindex[i];
+ val = 0;
+ k = largest_input_value(cinfo, i, 0, nci-1);
+ for (j = 0; j <= MAXJSAMPLE; j++) {
+ while (j > k) /* advance val if past boundary */
+ k = largest_input_value(cinfo, i, ++val, nci-1);
+ /* premultiply so that no multiplication needed in main processing */
+ indexptr[j] = (JSAMPLE) (val * blksize);
+ }
+ /* Pad at both ends if necessary */
+ if (pad)
+ for (j = 1; j <= MAXJSAMPLE; j++) {
+ indexptr[-j] = indexptr[0];
+ indexptr[MAXJSAMPLE+j] = indexptr[MAXJSAMPLE];
+ }
+ }
+}
+
+
+/*
+ * Create an ordered-dither array for a component having ncolors
+ * distinct output values.
+ */
+
+LOCAL(ODITHER_MATRIX_PTR)
+make_odither_array (j_decompress_ptr cinfo, int ncolors)
+{
+ ODITHER_MATRIX_PTR odither;
+ int j,k;
+ INT32 num,den;
+
+ odither = (ODITHER_MATRIX_PTR)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(ODITHER_MATRIX));
+ /* The inter-value distance for this color is MAXJSAMPLE/(ncolors-1).
+ * Hence the dither value for the matrix cell with fill order f
+ * (f=0..N-1) should be (N-1-2*f)/(2*N) * MAXJSAMPLE/(ncolors-1).
+ * On 16-bit-int machine, be careful to avoid overflow.
+ */
+ den = 2 * ODITHER_CELLS * ((INT32) (ncolors - 1));
+ for (j = 0; j < ODITHER_SIZE; j++) {
+ for (k = 0; k < ODITHER_SIZE; k++) {
+ num = ((INT32) (ODITHER_CELLS-1 - 2*((int)base_dither_matrix[j][k])))
+ * MAXJSAMPLE;
+ /* Ensure round towards zero despite C's lack of consistency
+ * about rounding negative values in integer division...
+ */
+ odither[j][k] = (int) (num<0 ? -((-num)/den) : num/den);
+ }
+ }
+ return odither;
+}
+
+
+/*
+ * Create the ordered-dither tables.
+ * Components having the same number of representative colors may
+ * share a dither table.
+ */
+
+LOCAL(void)
+create_odither_tables (j_decompress_ptr cinfo)
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ ODITHER_MATRIX_PTR odither;
+ int i, j, nci;
+
+ for (i = 0; i < cinfo->out_color_components; i++) {
+ nci = cquantize->Ncolors[i]; /* # of distinct values for this color */
+ odither = NULL; /* search for matching prior component */
+ for (j = 0; j < i; j++) {
+ if (nci == cquantize->Ncolors[j]) {
+ odither = cquantize->odither[j];
+ break;
+ }
+ }
+ if (odither == NULL) /* need a new table? */
+ odither = make_odither_array(cinfo, nci);
+ cquantize->odither[i] = odither;
+ }
+}
+
+
+/*
+ * Map some rows of pixels to the output colormapped representation.
+ */
+
+METHODDEF(void)
+color_quantize (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
+ JSAMPARRAY output_buf, int num_rows)
+/* General case, no dithering */
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ JSAMPARRAY colorindex = cquantize->colorindex;
+ register int pixcode, ci;
+ register JSAMPROW ptrin, ptrout;
+ int row;
+ JDIMENSION col;
+ JDIMENSION width = cinfo->output_width;
+ register int nc = cinfo->out_color_components;
+
+ for (row = 0; row < num_rows; row++) {
+ ptrin = input_buf[row];
+ ptrout = output_buf[row];
+ for (col = width; col > 0; col--) {
+ pixcode = 0;
+ for (ci = 0; ci < nc; ci++) {
+ pixcode += GETJSAMPLE(colorindex[ci][GETJSAMPLE(*ptrin++)]);
+ }
+ *ptrout++ = (JSAMPLE) pixcode;
+ }
+ }
+}
+
+
+METHODDEF(void)
+color_quantize3 (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
+ JSAMPARRAY output_buf, int num_rows)
+/* Fast path for out_color_components==3, no dithering */
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ register int pixcode;
+ register JSAMPROW ptrin, ptrout;
+ JSAMPROW colorindex0 = cquantize->colorindex[0];
+ JSAMPROW colorindex1 = cquantize->colorindex[1];
+ JSAMPROW colorindex2 = cquantize->colorindex[2];
+ int row;
+ JDIMENSION col;
+ JDIMENSION width = cinfo->output_width;
+
+ for (row = 0; row < num_rows; row++) {
+ ptrin = input_buf[row];
+ ptrout = output_buf[row];
+ for (col = width; col > 0; col--) {
+ pixcode = GETJSAMPLE(colorindex0[GETJSAMPLE(*ptrin++)]);
+ pixcode += GETJSAMPLE(colorindex1[GETJSAMPLE(*ptrin++)]);
+ pixcode += GETJSAMPLE(colorindex2[GETJSAMPLE(*ptrin++)]);
+ *ptrout++ = (JSAMPLE) pixcode;
+ }
+ }
+}
+
+
+METHODDEF(void)
+quantize_ord_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
+ JSAMPARRAY output_buf, int num_rows)
+/* General case, with ordered dithering */
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ register JSAMPROW input_ptr;
+ register JSAMPROW output_ptr;
+ JSAMPROW colorindex_ci;
+ int * dither; /* points to active row of dither matrix */
+ int row_index, col_index; /* current indexes into dither matrix */
+ int nc = cinfo->out_color_components;
+ int ci;
+ int row;
+ JDIMENSION col;
+ JDIMENSION width = cinfo->output_width;
+
+ for (row = 0; row < num_rows; row++) {
+ /* Initialize output values to 0 so can process components separately */
+ jzero_far((void FAR *) output_buf[row],
+ (size_t) (width * SIZEOF(JSAMPLE)));
+ row_index = cquantize->row_index;
+ for (ci = 0; ci < nc; ci++) {
+ input_ptr = input_buf[row] + ci;
+ output_ptr = output_buf[row];
+ colorindex_ci = cquantize->colorindex[ci];
+ dither = cquantize->odither[ci][row_index];
+ col_index = 0;
+
+ for (col = width; col > 0; col--) {
+ /* Form pixel value + dither, range-limit to 0..MAXJSAMPLE,
+ * select output value, accumulate into output code for this pixel.
+ * Range-limiting need not be done explicitly, as we have extended
+ * the colorindex table to produce the right answers for out-of-range
+ * inputs. The maximum dither is +- MAXJSAMPLE; this sets the
+ * required amount of padding.
+ */
+ *output_ptr += colorindex_ci[GETJSAMPLE(*input_ptr)+dither[col_index]];
+ input_ptr += nc;
+ output_ptr++;
+ col_index = (col_index + 1) & ODITHER_MASK;
+ }
+ }
+ /* Advance row index for next row */
+ row_index = (row_index + 1) & ODITHER_MASK;
+ cquantize->row_index = row_index;
+ }
+}
+
+
+METHODDEF(void)
+quantize3_ord_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
+ JSAMPARRAY output_buf, int num_rows)
+/* Fast path for out_color_components==3, with ordered dithering */
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ register int pixcode;
+ register JSAMPROW input_ptr;
+ register JSAMPROW output_ptr;
+ JSAMPROW colorindex0 = cquantize->colorindex[0];
+ JSAMPROW colorindex1 = cquantize->colorindex[1];
+ JSAMPROW colorindex2 = cquantize->colorindex[2];
+ int * dither0; /* points to active row of dither matrix */
+ int * dither1;
+ int * dither2;
+ int row_index, col_index; /* current indexes into dither matrix */
+ int row;
+ JDIMENSION col;
+ JDIMENSION width = cinfo->output_width;
+
+ for (row = 0; row < num_rows; row++) {
+ row_index = cquantize->row_index;
+ input_ptr = input_buf[row];
+ output_ptr = output_buf[row];
+ dither0 = cquantize->odither[0][row_index];
+ dither1 = cquantize->odither[1][row_index];
+ dither2 = cquantize->odither[2][row_index];
+ col_index = 0;
+
+ for (col = width; col > 0; col--) {
+ pixcode = GETJSAMPLE(colorindex0[GETJSAMPLE(*input_ptr++) +
+ dither0[col_index]]);
+ pixcode += GETJSAMPLE(colorindex1[GETJSAMPLE(*input_ptr++) +
+ dither1[col_index]]);
+ pixcode += GETJSAMPLE(colorindex2[GETJSAMPLE(*input_ptr++) +
+ dither2[col_index]]);
+ *output_ptr++ = (JSAMPLE) pixcode;
+ col_index = (col_index + 1) & ODITHER_MASK;
+ }
+ row_index = (row_index + 1) & ODITHER_MASK;
+ cquantize->row_index = row_index;
+ }
+}
+
+
+METHODDEF(void)
+quantize_fs_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
+ JSAMPARRAY output_buf, int num_rows)
+/* General case, with Floyd-Steinberg dithering */
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ register LOCFSERROR cur; /* current error or pixel value */
+ LOCFSERROR belowerr; /* error for pixel below cur */
+ LOCFSERROR bpreverr; /* error for below/prev col */
+ LOCFSERROR bnexterr; /* error for below/next col */
+ LOCFSERROR delta;
+ register FSERRPTR errorptr; /* => fserrors[] at column before current */
+ register JSAMPROW input_ptr;
+ register JSAMPROW output_ptr;
+ JSAMPROW colorindex_ci;
+ JSAMPROW colormap_ci;
+ int pixcode;
+ int nc = cinfo->out_color_components;
+ int dir; /* 1 for left-to-right, -1 for right-to-left */
+ int dirnc; /* dir * nc */
+ int ci;
+ int row;
+ JDIMENSION col;
+ JDIMENSION width = cinfo->output_width;
+ JSAMPLE *range_limit = cinfo->sample_range_limit;
+ SHIFT_TEMPS
+
+ for (row = 0; row < num_rows; row++) {
+ /* Initialize output values to 0 so can process components separately */
+ jzero_far((void FAR *) output_buf[row],
+ (size_t) (width * SIZEOF(JSAMPLE)));
+ for (ci = 0; ci < nc; ci++) {
+ input_ptr = input_buf[row] + ci;
+ output_ptr = output_buf[row];
+ if (cquantize->on_odd_row) {
+ /* work right to left in this row */
+ input_ptr += (width-1) * nc; /* so point to rightmost pixel */
+ output_ptr += width-1;
+ dir = -1;
+ dirnc = -nc;
+ errorptr = cquantize->fserrors[ci] + (width+1); /* => entry after last column */
+ } else {
+ /* work left to right in this row */
+ dir = 1;
+ dirnc = nc;
+ errorptr = cquantize->fserrors[ci]; /* => entry before first column */
+ }
+ colorindex_ci = cquantize->colorindex[ci];
+ colormap_ci = cquantize->sv_colormap[ci];
+ /* Preset error values: no error propagated to first pixel from left */
+ cur = 0;
+ /* and no error propagated to row below yet */
+ belowerr = bpreverr = 0;
+
+ for (col = width; col > 0; col--) {
+ /* cur holds the error propagated from the previous pixel on the
+ * current line. Add the error propagated from the previous line
+ * to form the complete error correction term for this pixel, and
+ * round the error term (which is expressed * 16) to an integer.
+ * RIGHT_SHIFT rounds towards minus infinity, so adding 8 is correct
+ * for either sign of the error value.
+ * Note: errorptr points to *previous* column's array entry.
+ */
+ cur = RIGHT_SHIFT(cur + errorptr[dir] + 8, 4);
+ /* Form pixel value + error, and range-limit to 0..MAXJSAMPLE.
+ * The maximum error is +- MAXJSAMPLE; this sets the required size
+ * of the range_limit array.
+ */
+ cur += GETJSAMPLE(*input_ptr);
+ cur = GETJSAMPLE(range_limit[cur]);
+ /* Select output value, accumulate into output code for this pixel */
+ pixcode = GETJSAMPLE(colorindex_ci[cur]);
+ *output_ptr += (JSAMPLE) pixcode;
+ /* Compute actual representation error at this pixel */
+ /* Note: we can do this even though we don't have the final */
+ /* pixel code, because the colormap is orthogonal. */
+ cur -= GETJSAMPLE(colormap_ci[pixcode]);
+ /* Compute error fractions to be propagated to adjacent pixels.
+ * Add these into the running sums, and simultaneously shift the
+ * next-line error sums left by 1 column.
+ */
+ bnexterr = cur;
+ delta = cur * 2;
+ cur += delta; /* form error * 3 */
+ errorptr[0] = (FSERROR) (bpreverr + cur);
+ cur += delta; /* form error * 5 */
+ bpreverr = belowerr + cur;
+ belowerr = bnexterr;
+ cur += delta; /* form error * 7 */
+ /* At this point cur contains the 7/16 error value to be propagated
+ * to the next pixel on the current line, and all the errors for the
+ * next line have been shifted over. We are therefore ready to move on.
+ */
+ input_ptr += dirnc; /* advance input ptr to next column */
+ output_ptr += dir; /* advance output ptr to next column */
+ errorptr += dir; /* advance errorptr to current column */
+ }
+ /* Post-loop cleanup: we must unload the final error value into the
+ * final fserrors[] entry. Note we need not unload belowerr because
+ * it is for the dummy column before or after the actual array.
+ */
+ errorptr[0] = (FSERROR) bpreverr; /* unload prev err into array */
+ }
+ cquantize->on_odd_row = (cquantize->on_odd_row ? FALSE : TRUE);
+ }
+}
+
+
+/*
+ * Allocate workspace for Floyd-Steinberg errors.
+ */
+
+LOCAL(void)
+alloc_fs_workspace (j_decompress_ptr cinfo)
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ size_t arraysize;
+ int i;
+
+ arraysize = (size_t) ((cinfo->output_width + 2) * SIZEOF(FSERROR));
+ for (i = 0; i < cinfo->out_color_components; i++) {
+ cquantize->fserrors[i] = (FSERRPTR)
+ (*cinfo->mem->alloc_large)((j_common_ptr) cinfo, JPOOL_IMAGE, arraysize);
+ }
+}
+
+
+/*
+ * Initialize for one-pass color quantization.
+ */
+
+METHODDEF(void)
+start_pass_1_quant (j_decompress_ptr cinfo, boolean is_pre_scan)
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ size_t arraysize;
+ int i;
+
+ /* Install my colormap. */
+ cinfo->colormap = cquantize->sv_colormap;
+ cinfo->actual_number_of_colors = cquantize->sv_actual;
+
+ /* Initialize for desired dithering mode. */
+ switch (cinfo->dither_mode) {
+ case JDITHER_NONE:
+ if (cinfo->out_color_components == 3)
+ cquantize->pub.color_quantize = color_quantize3;
+ else
+ cquantize->pub.color_quantize = color_quantize;
+ break;
+ case JDITHER_ORDERED:
+ if (cinfo->out_color_components == 3)
+ cquantize->pub.color_quantize = quantize3_ord_dither;
+ else
+ cquantize->pub.color_quantize = quantize_ord_dither;
+ cquantize->row_index = 0; /* initialize state for ordered dither */
+ /* If user changed to ordered dither from another mode,
+ * we must recreate the color index table with padding.
+ * This will cost extra space, but probably isn't very likely.
+ */
+ if (! cquantize->is_padded)
+ create_colorindex(cinfo);
+ /* Create ordered-dither tables if we didn't already. */
+ if (cquantize->odither[0] == NULL)
+ create_odither_tables(cinfo);
+ break;
+ case JDITHER_FS:
+ cquantize->pub.color_quantize = quantize_fs_dither;
+ cquantize->on_odd_row = FALSE; /* initialize state for F-S dither */
+ /* Allocate Floyd-Steinberg workspace if didn't already. */
+ if (cquantize->fserrors[0] == NULL)
+ alloc_fs_workspace(cinfo);
+ /* Initialize the propagated errors to zero. */
+ arraysize = (size_t) ((cinfo->output_width + 2) * SIZEOF(FSERROR));
+ for (i = 0; i < cinfo->out_color_components; i++)
+ jzero_far((void FAR *) cquantize->fserrors[i], arraysize);
+ break;
+ default:
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+ break;
+ }
+}
+
+
+/*
+ * Finish up at the end of the pass.
+ */
+
+METHODDEF(void)
+finish_pass_1_quant (j_decompress_ptr cinfo)
+{
+ /* no work in 1-pass case */
+}
+
+
+/*
+ * Switch to a new external colormap between output passes.
+ * Shouldn't get to this module!
+ */
+
+METHODDEF(void)
+new_color_map_1_quant (j_decompress_ptr cinfo)
+{
+ ERREXIT(cinfo, JERR_MODE_CHANGE);
+}
+
+
+/*
+ * Module initialization routine for 1-pass color quantization.
+ */
+
+GLOBAL(void)
+jinit_1pass_quantizer (j_decompress_ptr cinfo)
+{
+ my_cquantize_ptr cquantize;
+
+ cquantize = (my_cquantize_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_cquantizer));
+ cinfo->cquantize = (struct jpeg_color_quantizer *) cquantize;
+ cquantize->pub.start_pass = start_pass_1_quant;
+ cquantize->pub.finish_pass = finish_pass_1_quant;
+ cquantize->pub.new_color_map = new_color_map_1_quant;
+ cquantize->fserrors[0] = NULL; /* Flag FS workspace not allocated */
+ cquantize->odither[0] = NULL; /* Also flag odither arrays not allocated */
+
+ /* Make sure my internal arrays won't overflow */
+ if (cinfo->out_color_components > MAX_Q_COMPS)
+ ERREXIT1(cinfo, JERR_QUANT_COMPONENTS, MAX_Q_COMPS);
+ /* Make sure colormap indexes can be represented by JSAMPLEs */
+ if (cinfo->desired_number_of_colors > (MAXJSAMPLE+1))
+ ERREXIT1(cinfo, JERR_QUANT_MANY_COLORS, MAXJSAMPLE+1);
+
+ /* Create the colormap and color index table. */
+ create_colormap(cinfo);
+ create_colorindex(cinfo);
+
+ /* Allocate Floyd-Steinberg workspace now if requested.
+ * We do this now since it is FAR storage and may affect the memory
+ * manager's space calculations. If the user changes to FS dither
+ * mode in a later pass, we will allocate the space then, and will
+ * possibly overrun the max_memory_to_use setting.
+ */
+ if (cinfo->dither_mode == JDITHER_FS)
+ alloc_fs_workspace(cinfo);
+}
+
+#endif /* QUANT_1PASS_SUPPORTED */
--- /dev/null
+/*
+ * jquant2.c
+ *
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * 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 2-pass color quantization (color mapping) routines.
+ * These routines provide selection of a custom color map for an image,
+ * followed by mapping of the image to that color map, with optional
+ * Floyd-Steinberg dithering.
+ * It is also possible to use just the second pass to map to an arbitrary
+ * externally-given color map.
+ *
+ * Note: ordered dithering is not supported, since there isn't any fast
+ * way to compute intercolor distances; it's unclear that ordered dither's
+ * fundamental assumptions even hold with an irregularly spaced color map.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+#ifdef QUANT_2PASS_SUPPORTED
+
+
+/*
+ * This module implements the well-known Heckbert paradigm for color
+ * quantization. Most of the ideas used here can be traced back to
+ * Heckbert's seminal paper
+ * Heckbert, Paul. "Color Image Quantization for Frame Buffer Display",
+ * Proc. SIGGRAPH '82, Computer Graphics v.16 #3 (July 1982), pp 297-304.
+ *
+ * In the first pass over the image, we accumulate a histogram showing the
+ * usage count of each possible color. To keep the histogram to a reasonable
+ * size, we reduce the precision of the input; typical practice is to retain
+ * 5 or 6 bits per color, so that 8 or 4 different input values are counted
+ * in the same histogram cell.
+ *
+ * Next, the color-selection step begins with a box representing the whole
+ * color space, and repeatedly splits the "largest" remaining box until we
+ * have as many boxes as desired colors. Then the mean color in each
+ * remaining box becomes one of the possible output colors.
+ *
+ * The second pass over the image maps each input pixel to the closest output
+ * color (optionally after applying a Floyd-Steinberg dithering correction).
+ * This mapping is logically trivial, but making it go fast enough requires
+ * considerable care.
+ *
+ * Heckbert-style quantizers vary a good deal in their policies for choosing
+ * the "largest" box and deciding where to cut it. The particular policies
+ * used here have proved out well in experimental comparisons, but better ones
+ * may yet be found.
+ *
+ * In earlier versions of the IJG code, this module quantized in YCbCr color
+ * space, processing the raw upsampled data without a color conversion step.
+ * This allowed the color conversion math to be done only once per colormap
+ * entry, not once per pixel. However, that optimization precluded other
+ * useful optimizations (such as merging color conversion with upsampling)
+ * and it also interfered with desired capabilities such as quantizing to an
+ * externally-supplied colormap. We have therefore abandoned that approach.
+ * The present code works in the post-conversion color space, typically RGB.
+ *
+ * To improve the visual quality of the results, we actually work in scaled
+ * RGB space, giving G distances more weight than R, and R in turn more than
+ * B. To do everything in integer math, we must use integer scale factors.
+ * The 2/3/1 scale factors used here correspond loosely to the relative
+ * weights of the colors in the NTSC grayscale equation.
+ * If you want to use this code to quantize a non-RGB color space, you'll
+ * probably need to change these scale factors.
+ */
+
+#define R_SCALE 2 /* scale R distances by this much */
+#define G_SCALE 3 /* scale G distances by this much */
+#define B_SCALE 1 /* and B by this much */
+
+/* Relabel R/G/B as components 0/1/2, respecting the RGB ordering defined
+ * in jmorecfg.h. As the code stands, it will do the right thing for R,G,B
+ * and B,G,R orders. If you define some other weird order in jmorecfg.h,
+ * you'll get compile errors until you extend this logic. In that case
+ * you'll probably want to tweak the histogram sizes too.
+ */
+
+#if RGB_RED == 0
+#define C0_SCALE R_SCALE
+#endif
+#if RGB_BLUE == 0
+#define C0_SCALE B_SCALE
+#endif
+#if RGB_GREEN == 1
+#define C1_SCALE G_SCALE
+#endif
+#if RGB_RED == 2
+#define C2_SCALE R_SCALE
+#endif
+#if RGB_BLUE == 2
+#define C2_SCALE B_SCALE
+#endif
+
+
+/*
+ * First we have the histogram data structure and routines for creating it.
+ *
+ * The number of bits of precision can be adjusted by changing these symbols.
+ * We recommend keeping 6 bits for G and 5 each for R and B.
+ * If you have plenty of memory and cycles, 6 bits all around gives marginally
+ * better results; if you are short of memory, 5 bits all around will save
+ * some space but degrade the results.
+ * To maintain a fully accurate histogram, we'd need to allocate a "long"
+ * (preferably unsigned long) for each cell. In practice this is overkill;
+ * we can get by with 16 bits per cell. Few of the cell counts will overflow,
+ * and clamping those that do overflow to the maximum value will give close-
+ * enough results. This reduces the recommended histogram size from 256Kb
+ * to 128Kb, which is a useful savings on PC-class machines.
+ * (In the second pass the histogram space is re-used for pixel mapping data;
+ * in that capacity, each cell must be able to store zero to the number of
+ * desired colors. 16 bits/cell is plenty for that too.)
+ * Since the JPEG code is intended to run in small memory model on 80x86
+ * machines, we can't just allocate the histogram in one chunk. Instead
+ * of a true 3-D array, we use a row of pointers to 2-D arrays. Each
+ * pointer corresponds to a C0 value (typically 2^5 = 32 pointers) and
+ * each 2-D array has 2^6*2^5 = 2048 or 2^6*2^6 = 4096 entries. Note that
+ * on 80x86 machines, the pointer row is in near memory but the actual
+ * arrays are in far memory (same arrangement as we use for image arrays).
+ */
+
+#define MAXNUMCOLORS (MAXJSAMPLE+1) /* maximum size of colormap */
+
+/* These will do the right thing for either R,G,B or B,G,R color order,
+ * but you may not like the results for other color orders.
+ */
+#define HIST_C0_BITS 5 /* bits of precision in R/B histogram */
+#define HIST_C1_BITS 6 /* bits of precision in G histogram */
+#define HIST_C2_BITS 5 /* bits of precision in B/R histogram */
+
+/* Number of elements along histogram axes. */
+#define HIST_C0_ELEMS (1<<HIST_C0_BITS)
+#define HIST_C1_ELEMS (1<<HIST_C1_BITS)
+#define HIST_C2_ELEMS (1<<HIST_C2_BITS)
+
+/* These are the amounts to shift an input value to get a histogram index. */
+#define C0_SHIFT (BITS_IN_JSAMPLE-HIST_C0_BITS)
+#define C1_SHIFT (BITS_IN_JSAMPLE-HIST_C1_BITS)
+#define C2_SHIFT (BITS_IN_JSAMPLE-HIST_C2_BITS)
+
+
+typedef UINT16 histcell; /* histogram cell; prefer an unsigned type */
+
+typedef histcell FAR * histptr; /* for pointers to histogram cells */
+
+typedef histcell hist1d[HIST_C2_ELEMS]; /* typedefs for the array */
+typedef hist1d FAR * hist2d; /* type for the 2nd-level pointers */
+typedef hist2d * hist3d; /* type for top-level pointer */
+
+
+/* Declarations for Floyd-Steinberg dithering.
+ *
+ * Errors are accumulated into the array fserrors[], at a resolution of
+ * 1/16th of a pixel count. The error at a given pixel is propagated
+ * to its not-yet-processed neighbors using the standard F-S fractions,
+ * ... (here) 7/16
+ * 3/16 5/16 1/16
+ * We work left-to-right on even rows, right-to-left on odd rows.
+ *
+ * We can get away with a single array (holding one row's worth of errors)
+ * by using it to store the current row's errors at pixel columns not yet
+ * processed, but the next row's errors at columns already processed. We
+ * need only a few extra variables to hold the errors immediately around the
+ * current column. (If we are lucky, those variables are in registers, but
+ * even if not, they're probably cheaper to access than array elements are.)
+ *
+ * The fserrors[] array has (#columns + 2) entries; the extra entry at
+ * each end saves us from special-casing the first and last pixels.
+ * Each entry is three values long, one value for each color component.
+ *
+ * Note: on a wide image, we might not have enough room in a PC's near data
+ * segment to hold the error array; so it is allocated with alloc_large.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+typedef INT16 FSERROR; /* 16 bits should be enough */
+typedef int LOCFSERROR; /* use 'int' for calculation temps */
+#else
+typedef INT32 FSERROR; /* may need more than 16 bits */
+typedef INT32 LOCFSERROR; /* be sure calculation temps are big enough */
+#endif
+
+typedef FSERROR FAR *FSERRPTR; /* pointer to error array (in FAR storage!) */
+
+
+/* Private subobject */
+
+typedef struct {
+ struct jpeg_color_quantizer pub; /* public fields */
+
+ /* Space for the eventually created colormap is stashed here */
+ JSAMPARRAY sv_colormap; /* colormap allocated at init time */
+ int desired; /* desired # of colors = size of colormap */
+
+ /* Variables for accumulating image statistics */
+ hist3d histogram; /* pointer to the histogram */
+
+ boolean needs_zeroed; /* TRUE if next pass must zero histogram */
+
+ /* Variables for Floyd-Steinberg dithering */
+ FSERRPTR fserrors; /* accumulated errors */
+ boolean on_odd_row; /* flag to remember which row we are on */
+ int * error_limiter; /* table for clamping the applied error */
+} my_cquantizer;
+
+typedef my_cquantizer * my_cquantize_ptr;
+
+
+/*
+ * Prescan some rows of pixels.
+ * In this module the prescan simply updates the histogram, which has been
+ * initialized to zeroes by start_pass.
+ * An output_buf parameter is required by the method signature, but no data
+ * is actually output (in fact the buffer controller is probably passing a
+ * NULL pointer).
+ */
+
+METHODDEF(void)
+prescan_quantize (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
+ JSAMPARRAY output_buf, int num_rows)
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ register JSAMPROW ptr;
+ register histptr histp;
+ register hist3d histogram = cquantize->histogram;
+ int row;
+ JDIMENSION col;
+ JDIMENSION width = cinfo->output_width;
+
+ for (row = 0; row < num_rows; row++) {
+ ptr = input_buf[row];
+ for (col = width; col > 0; col--) {
+ /* get pixel value and index into the histogram */
+ histp = & histogram[GETJSAMPLE(ptr[0]) >> C0_SHIFT]
+ [GETJSAMPLE(ptr[1]) >> C1_SHIFT]
+ [GETJSAMPLE(ptr[2]) >> C2_SHIFT];
+ /* increment, check for overflow and undo increment if so. */
+ if (++(*histp) <= 0)
+ (*histp)--;
+ ptr += 3;
+ }
+ }
+}
+
+
+/*
+ * Next we have the really interesting routines: selection of a colormap
+ * given the completed histogram.
+ * These routines work with a list of "boxes", each representing a rectangular
+ * subset of the input color space (to histogram precision).
+ */
+
+typedef struct {
+ /* The bounds of the box (inclusive); expressed as histogram indexes */
+ int c0min, c0max;
+ int c1min, c1max;
+ int c2min, c2max;
+ /* The volume (actually 2-norm) of the box */
+ INT32 volume;
+ /* The number of nonzero histogram cells within this box */
+ long colorcount;
+} box;
+
+typedef box * boxptr;
+
+
+LOCAL(boxptr)
+find_biggest_color_pop (boxptr boxlist, int numboxes)
+/* Find the splittable box with the largest color population */
+/* Returns NULL if no splittable boxes remain */
+{
+ register boxptr boxp;
+ register int i;
+ register long maxc = 0;
+ boxptr which = NULL;
+
+ for (i = 0, boxp = boxlist; i < numboxes; i++, boxp++) {
+ if (boxp->colorcount > maxc && boxp->volume > 0) {
+ which = boxp;
+ maxc = boxp->colorcount;
+ }
+ }
+ return which;
+}
+
+
+LOCAL(boxptr)
+find_biggest_volume (boxptr boxlist, int numboxes)
+/* Find the splittable box with the largest (scaled) volume */
+/* Returns NULL if no splittable boxes remain */
+{
+ register boxptr boxp;
+ register int i;
+ register INT32 maxv = 0;
+ boxptr which = NULL;
+
+ for (i = 0, boxp = boxlist; i < numboxes; i++, boxp++) {
+ if (boxp->volume > maxv) {
+ which = boxp;
+ maxv = boxp->volume;
+ }
+ }
+ return which;
+}
+
+
+LOCAL(void)
+update_box (j_decompress_ptr cinfo, boxptr boxp)
+/* Shrink the min/max bounds of a box to enclose only nonzero elements, */
+/* and recompute its volume and population */
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ hist3d histogram = cquantize->histogram;
+ histptr histp;
+ int c0,c1,c2;
+ int c0min,c0max,c1min,c1max,c2min,c2max;
+ INT32 dist0,dist1,dist2;
+ long ccount;
+
+ c0min = boxp->c0min; c0max = boxp->c0max;
+ c1min = boxp->c1min; c1max = boxp->c1max;
+ c2min = boxp->c2min; c2max = boxp->c2max;
+
+ if (c0max > c0min)
+ for (c0 = c0min; c0 <= c0max; c0++)
+ for (c1 = c1min; c1 <= c1max; c1++) {
+ histp = & histogram[c0][c1][c2min];
+ for (c2 = c2min; c2 <= c2max; c2++)
+ if (*histp++ != 0) {
+ boxp->c0min = c0min = c0;
+ goto have_c0min;
+ }
+ }
+ have_c0min:
+ if (c0max > c0min)
+ for (c0 = c0max; c0 >= c0min; c0--)
+ for (c1 = c1min; c1 <= c1max; c1++) {
+ histp = & histogram[c0][c1][c2min];
+ for (c2 = c2min; c2 <= c2max; c2++)
+ if (*histp++ != 0) {
+ boxp->c0max = c0max = c0;
+ goto have_c0max;
+ }
+ }
+ have_c0max:
+ if (c1max > c1min)
+ for (c1 = c1min; c1 <= c1max; c1++)
+ for (c0 = c0min; c0 <= c0max; c0++) {
+ histp = & histogram[c0][c1][c2min];
+ for (c2 = c2min; c2 <= c2max; c2++)
+ if (*histp++ != 0) {
+ boxp->c1min = c1min = c1;
+ goto have_c1min;
+ }
+ }
+ have_c1min:
+ if (c1max > c1min)
+ for (c1 = c1max; c1 >= c1min; c1--)
+ for (c0 = c0min; c0 <= c0max; c0++) {
+ histp = & histogram[c0][c1][c2min];
+ for (c2 = c2min; c2 <= c2max; c2++)
+ if (*histp++ != 0) {
+ boxp->c1max = c1max = c1;
+ goto have_c1max;
+ }
+ }
+ have_c1max:
+ if (c2max > c2min)
+ for (c2 = c2min; c2 <= c2max; c2++)
+ for (c0 = c0min; c0 <= c0max; c0++) {
+ histp = & histogram[c0][c1min][c2];
+ for (c1 = c1min; c1 <= c1max; c1++, histp += HIST_C2_ELEMS)
+ if (*histp != 0) {
+ boxp->c2min = c2min = c2;
+ goto have_c2min;
+ }
+ }
+ have_c2min:
+ if (c2max > c2min)
+ for (c2 = c2max; c2 >= c2min; c2--)
+ for (c0 = c0min; c0 <= c0max; c0++) {
+ histp = & histogram[c0][c1min][c2];
+ for (c1 = c1min; c1 <= c1max; c1++, histp += HIST_C2_ELEMS)
+ if (*histp != 0) {
+ boxp->c2max = c2max = c2;
+ goto have_c2max;
+ }
+ }
+ have_c2max:
+
+ /* Update box volume.
+ * We use 2-norm rather than real volume here; this biases the method
+ * against making long narrow boxes, and it has the side benefit that
+ * a box is splittable iff norm > 0.
+ * Since the differences are expressed in histogram-cell units,
+ * we have to shift back to JSAMPLE units to get consistent distances;
+ * after which, we scale according to the selected distance scale factors.
+ */
+ dist0 = ((c0max - c0min) << C0_SHIFT) * C0_SCALE;
+ dist1 = ((c1max - c1min) << C1_SHIFT) * C1_SCALE;
+ dist2 = ((c2max - c2min) << C2_SHIFT) * C2_SCALE;
+ boxp->volume = dist0*dist0 + dist1*dist1 + dist2*dist2;
+
+ /* Now scan remaining volume of box and compute population */
+ ccount = 0;
+ for (c0 = c0min; c0 <= c0max; c0++)
+ for (c1 = c1min; c1 <= c1max; c1++) {
+ histp = & histogram[c0][c1][c2min];
+ for (c2 = c2min; c2 <= c2max; c2++, histp++)
+ if (*histp != 0) {
+ ccount++;
+ }
+ }
+ boxp->colorcount = ccount;
+}
+
+
+LOCAL(int)
+median_cut (j_decompress_ptr cinfo, boxptr boxlist, int numboxes,
+ int desired_colors)
+/* Repeatedly select and split the largest box until we have enough boxes */
+{
+ int n,lb;
+ int c0,c1,c2,cmax;
+ register boxptr b1,b2;
+
+ while (numboxes < desired_colors) {
+ /* Select box to split.
+ * Current algorithm: by population for first half, then by volume.
+ */
+ if (numboxes*2 <= desired_colors) {
+ b1 = find_biggest_color_pop(boxlist, numboxes);
+ } else {
+ b1 = find_biggest_volume(boxlist, numboxes);
+ }
+ if (b1 == NULL) /* no splittable boxes left! */
+ break;
+ b2 = &boxlist[numboxes]; /* where new box will go */
+ /* Copy the color bounds to the new box. */
+ b2->c0max = b1->c0max; b2->c1max = b1->c1max; b2->c2max = b1->c2max;
+ b2->c0min = b1->c0min; b2->c1min = b1->c1min; b2->c2min = b1->c2min;
+ /* Choose which axis to split the box on.
+ * Current algorithm: longest scaled axis.
+ * See notes in update_box about scaling distances.
+ */
+ c0 = ((b1->c0max - b1->c0min) << C0_SHIFT) * C0_SCALE;
+ c1 = ((b1->c1max - b1->c1min) << C1_SHIFT) * C1_SCALE;
+ c2 = ((b1->c2max - b1->c2min) << C2_SHIFT) * C2_SCALE;
+ /* We want to break any ties in favor of green, then red, blue last.
+ * This code does the right thing for R,G,B or B,G,R color orders only.
+ */
+#if RGB_RED == 0
+ cmax = c1; n = 1;
+ if (c0 > cmax) { cmax = c0; n = 0; }
+ if (c2 > cmax) { n = 2; }
+#else
+ cmax = c1; n = 1;
+ if (c2 > cmax) { cmax = c2; n = 2; }
+ if (c0 > cmax) { n = 0; }
+#endif
+ /* Choose split point along selected axis, and update box bounds.
+ * Current algorithm: split at halfway point.
+ * (Since the box has been shrunk to minimum volume,
+ * any split will produce two nonempty subboxes.)
+ * Note that lb value is max for lower box, so must be < old max.
+ */
+ switch (n) {
+ case 0:
+ lb = (b1->c0max + b1->c0min) / 2;
+ b1->c0max = lb;
+ b2->c0min = lb+1;
+ break;
+ case 1:
+ lb = (b1->c1max + b1->c1min) / 2;
+ b1->c1max = lb;
+ b2->c1min = lb+1;
+ break;
+ case 2:
+ lb = (b1->c2max + b1->c2min) / 2;
+ b1->c2max = lb;
+ b2->c2min = lb+1;
+ break;
+ }
+ /* Update stats for boxes */
+ update_box(cinfo, b1);
+ update_box(cinfo, b2);
+ numboxes++;
+ }
+ return numboxes;
+}
+
+
+LOCAL(void)
+compute_color (j_decompress_ptr cinfo, boxptr boxp, int icolor)
+/* Compute representative color for a box, put it in colormap[icolor] */
+{
+ /* Current algorithm: mean weighted by pixels (not colors) */
+ /* Note it is important to get the rounding correct! */
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ hist3d histogram = cquantize->histogram;
+ histptr histp;
+ int c0,c1,c2;
+ int c0min,c0max,c1min,c1max,c2min,c2max;
+ long count;
+ long total = 0;
+ long c0total = 0;
+ long c1total = 0;
+ long c2total = 0;
+
+ c0min = boxp->c0min; c0max = boxp->c0max;
+ c1min = boxp->c1min; c1max = boxp->c1max;
+ c2min = boxp->c2min; c2max = boxp->c2max;
+
+ for (c0 = c0min; c0 <= c0max; c0++)
+ for (c1 = c1min; c1 <= c1max; c1++) {
+ histp = & histogram[c0][c1][c2min];
+ for (c2 = c2min; c2 <= c2max; c2++) {
+ if ((count = *histp++) != 0) {
+ total += count;
+ c0total += ((c0 << C0_SHIFT) + ((1<<C0_SHIFT)>>1)) * count;
+ c1total += ((c1 << C1_SHIFT) + ((1<<C1_SHIFT)>>1)) * count;
+ c2total += ((c2 << C2_SHIFT) + ((1<<C2_SHIFT)>>1)) * count;
+ }
+ }
+ }
+
+ cinfo->colormap[0][icolor] = (JSAMPLE) ((c0total + (total>>1)) / total);
+ cinfo->colormap[1][icolor] = (JSAMPLE) ((c1total + (total>>1)) / total);
+ cinfo->colormap[2][icolor] = (JSAMPLE) ((c2total + (total>>1)) / total);
+}
+
+
+LOCAL(void)
+select_colors (j_decompress_ptr cinfo, int desired_colors)
+/* Master routine for color selection */
+{
+ boxptr boxlist;
+ int numboxes;
+ int i;
+
+ /* Allocate workspace for box list */
+ boxlist = (boxptr) (*cinfo->mem->alloc_small)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE, desired_colors * SIZEOF(box));
+ /* Initialize one box containing whole space */
+ numboxes = 1;
+ boxlist[0].c0min = 0;
+ boxlist[0].c0max = MAXJSAMPLE >> C0_SHIFT;
+ boxlist[0].c1min = 0;
+ boxlist[0].c1max = MAXJSAMPLE >> C1_SHIFT;
+ boxlist[0].c2min = 0;
+ boxlist[0].c2max = MAXJSAMPLE >> C2_SHIFT;
+ /* Shrink it to actually-used volume and set its statistics */
+ update_box(cinfo, & boxlist[0]);
+ /* Perform median-cut to produce final box list */
+ numboxes = median_cut(cinfo, boxlist, numboxes, desired_colors);
+ /* Compute the representative color for each box, fill colormap */
+ for (i = 0; i < numboxes; i++)
+ compute_color(cinfo, & boxlist[i], i);
+ cinfo->actual_number_of_colors = numboxes;
+ TRACEMS1(cinfo, 1, JTRC_QUANT_SELECTED, numboxes);
+}
+
+
+/*
+ * These routines are concerned with the time-critical task of mapping input
+ * colors to the nearest color in the selected colormap.
+ *
+ * We re-use the histogram space as an "inverse color map", essentially a
+ * cache for the results of nearest-color searches. All colors within a
+ * histogram cell will be mapped to the same colormap entry, namely the one
+ * closest to the cell's center. This may not be quite the closest entry to
+ * the actual input color, but it's almost as good. A zero in the cache
+ * indicates we haven't found the nearest color for that cell yet; the array
+ * is cleared to zeroes before starting the mapping pass. When we find the
+ * nearest color for a cell, its colormap index plus one is recorded in the
+ * cache for future use. The pass2 scanning routines call fill_inverse_cmap
+ * when they need to use an unfilled entry in the cache.
+ *
+ * Our method of efficiently finding nearest colors is based on the "locally
+ * sorted search" idea described by Heckbert and on the incremental distance
+ * calculation described by Spencer W. Thomas in chapter III.1 of Graphics
+ * Gems II (James Arvo, ed. Academic Press, 1991). Thomas points out that
+ * the distances from a given colormap entry to each cell of the histogram can
+ * be computed quickly using an incremental method: the differences between
+ * distances to adjacent cells themselves differ by a constant. This allows a
+ * fairly fast implementation of the "brute force" approach of computing the
+ * distance from every colormap entry to every histogram cell. Unfortunately,
+ * it needs a work array to hold the best-distance-so-far for each histogram
+ * cell (because the inner loop has to be over cells, not colormap entries).
+ * The work array elements have to be INT32s, so the work array would need
+ * 256Kb at our recommended precision. This is not feasible in DOS machines.
+ *
+ * To get around these problems, we apply Thomas' method to compute the
+ * nearest colors for only the cells within a small subbox of the histogram.
+ * The work array need be only as big as the subbox, so the memory usage
+ * problem is solved. Furthermore, we need not fill subboxes that are never
+ * referenced in pass2; many images use only part of the color gamut, so a
+ * fair amount of work is saved. An additional advantage of this
+ * approach is that we can apply Heckbert's locality criterion to quickly
+ * eliminate colormap entries that are far away from the subbox; typically
+ * three-fourths of the colormap entries are rejected by Heckbert's criterion,
+ * and we need not compute their distances to individual cells in the subbox.
+ * The speed of this approach is heavily influenced by the subbox size: too
+ * small means too much overhead, too big loses because Heckbert's criterion
+ * can't eliminate as many colormap entries. Empirically the best subbox
+ * size seems to be about 1/512th of the histogram (1/8th in each direction).
+ *
+ * Thomas' article also describes a refined method which is asymptotically
+ * faster than the brute-force method, but it is also far more complex and
+ * cannot efficiently be applied to small subboxes. It is therefore not
+ * useful for programs intended to be portable to DOS machines. On machines
+ * with plenty of memory, filling the whole histogram in one shot with Thomas'
+ * refined method might be faster than the present code --- but then again,
+ * it might not be any faster, and it's certainly more complicated.
+ */
+
+
+/* log2(histogram cells in update box) for each axis; this can be adjusted */
+#define BOX_C0_LOG (HIST_C0_BITS-3)
+#define BOX_C1_LOG (HIST_C1_BITS-3)
+#define BOX_C2_LOG (HIST_C2_BITS-3)
+
+#define BOX_C0_ELEMS (1<<BOX_C0_LOG) /* # of hist cells in update box */
+#define BOX_C1_ELEMS (1<<BOX_C1_LOG)
+#define BOX_C2_ELEMS (1<<BOX_C2_LOG)
+
+#define BOX_C0_SHIFT (C0_SHIFT + BOX_C0_LOG)
+#define BOX_C1_SHIFT (C1_SHIFT + BOX_C1_LOG)
+#define BOX_C2_SHIFT (C2_SHIFT + BOX_C2_LOG)
+
+
+/*
+ * The next three routines implement inverse colormap filling. They could
+ * all be folded into one big routine, but splitting them up this way saves
+ * some stack space (the mindist[] and bestdist[] arrays need not coexist)
+ * and may allow some compilers to produce better code by registerizing more
+ * inner-loop variables.
+ */
+
+LOCAL(int)
+find_nearby_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,
+ JSAMPLE colorlist[])
+/* Locate the colormap entries close enough to an update box to be candidates
+ * for the nearest entry to some cell(s) in the update box. The update box
+ * is specified by the center coordinates of its first cell. The number of
+ * candidate colormap entries is returned, and their colormap indexes are
+ * placed in colorlist[].
+ * This routine uses Heckbert's "locally sorted search" criterion to select
+ * the colors that need further consideration.
+ */
+{
+ int numcolors = cinfo->actual_number_of_colors;
+ int maxc0, maxc1, maxc2;
+ int centerc0, centerc1, centerc2;
+ int i, x, ncolors;
+ INT32 minmaxdist, min_dist, max_dist, tdist;
+ INT32 mindist[MAXNUMCOLORS]; /* min distance to colormap entry i */
+
+ /* Compute true coordinates of update box's upper corner and center.
+ * Actually we compute the coordinates of the center of the upper-corner
+ * histogram cell, which are the upper bounds of the volume we care about.
+ * Note that since ">>" rounds down, the "center" values may be closer to
+ * min than to max; hence comparisons to them must be "<=", not "<".
+ */
+ maxc0 = minc0 + ((1 << BOX_C0_SHIFT) - (1 << C0_SHIFT));
+ centerc0 = (minc0 + maxc0) >> 1;
+ maxc1 = minc1 + ((1 << BOX_C1_SHIFT) - (1 << C1_SHIFT));
+ centerc1 = (minc1 + maxc1) >> 1;
+ maxc2 = minc2 + ((1 << BOX_C2_SHIFT) - (1 << C2_SHIFT));
+ centerc2 = (minc2 + maxc2) >> 1;
+
+ /* For each color in colormap, find:
+ * 1. its minimum squared-distance to any point in the update box
+ * (zero if color is within update box);
+ * 2. its maximum squared-distance to any point in the update box.
+ * Both of these can be found by considering only the corners of the box.
+ * We save the minimum distance for each color in mindist[];
+ * only the smallest maximum distance is of interest.
+ */
+ minmaxdist = 0x7FFFFFFFL;
+
+ for (i = 0; i < numcolors; i++) {
+ /* We compute the squared-c0-distance term, then add in the other two. */
+ x = GETJSAMPLE(cinfo->colormap[0][i]);
+ if (x < minc0) {
+ tdist = (x - minc0) * C0_SCALE;
+ min_dist = tdist*tdist;
+ tdist = (x - maxc0) * C0_SCALE;
+ max_dist = tdist*tdist;
+ } else if (x > maxc0) {
+ tdist = (x - maxc0) * C0_SCALE;
+ min_dist = tdist*tdist;
+ tdist = (x - minc0) * C0_SCALE;
+ max_dist = tdist*tdist;
+ } else {
+ /* within cell range so no contribution to min_dist */
+ min_dist = 0;
+ if (x <= centerc0) {
+ tdist = (x - maxc0) * C0_SCALE;
+ max_dist = tdist*tdist;
+ } else {
+ tdist = (x - minc0) * C0_SCALE;
+ max_dist = tdist*tdist;
+ }
+ }
+
+ x = GETJSAMPLE(cinfo->colormap[1][i]);
+ if (x < minc1) {
+ tdist = (x - minc1) * C1_SCALE;
+ min_dist += tdist*tdist;
+ tdist = (x - maxc1) * C1_SCALE;
+ max_dist += tdist*tdist;
+ } else if (x > maxc1) {
+ tdist = (x - maxc1) * C1_SCALE;
+ min_dist += tdist*tdist;
+ tdist = (x - minc1) * C1_SCALE;
+ max_dist += tdist*tdist;
+ } else {
+ /* within cell range so no contribution to min_dist */
+ if (x <= centerc1) {
+ tdist = (x - maxc1) * C1_SCALE;
+ max_dist += tdist*tdist;
+ } else {
+ tdist = (x - minc1) * C1_SCALE;
+ max_dist += tdist*tdist;
+ }
+ }
+
+ x = GETJSAMPLE(cinfo->colormap[2][i]);
+ if (x < minc2) {
+ tdist = (x - minc2) * C2_SCALE;
+ min_dist += tdist*tdist;
+ tdist = (x - maxc2) * C2_SCALE;
+ max_dist += tdist*tdist;
+ } else if (x > maxc2) {
+ tdist = (x - maxc2) * C2_SCALE;
+ min_dist += tdist*tdist;
+ tdist = (x - minc2) * C2_SCALE;
+ max_dist += tdist*tdist;
+ } else {
+ /* within cell range so no contribution to min_dist */
+ if (x <= centerc2) {
+ tdist = (x - maxc2) * C2_SCALE;
+ max_dist += tdist*tdist;
+ } else {
+ tdist = (x - minc2) * C2_SCALE;
+ max_dist += tdist*tdist;
+ }
+ }
+
+ mindist[i] = min_dist; /* save away the results */
+ if (max_dist < minmaxdist)
+ minmaxdist = max_dist;
+ }
+
+ /* Now we know that no cell in the update box is more than minmaxdist
+ * away from some colormap entry. Therefore, only colors that are
+ * within minmaxdist of some part of the box need be considered.
+ */
+ ncolors = 0;
+ for (i = 0; i < numcolors; i++) {
+ if (mindist[i] <= minmaxdist)
+ colorlist[ncolors++] = (JSAMPLE) i;
+ }
+ return ncolors;
+}
+
+
+LOCAL(void)
+find_best_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,
+ int numcolors, JSAMPLE colorlist[], JSAMPLE bestcolor[])
+/* Find the closest colormap entry for each cell in the update box,
+ * given the list of candidate colors prepared by find_nearby_colors.
+ * Return the indexes of the closest entries in the bestcolor[] array.
+ * This routine uses Thomas' incremental distance calculation method to
+ * find the distance from a colormap entry to successive cells in the box.
+ */
+{
+ int ic0, ic1, ic2;
+ int i, icolor;
+ register INT32 * bptr; /* pointer into bestdist[] array */
+ JSAMPLE * cptr; /* pointer into bestcolor[] array */
+ INT32 dist0, dist1; /* initial distance values */
+ register INT32 dist2; /* current distance in inner loop */
+ INT32 xx0, xx1; /* distance increments */
+ register INT32 xx2;
+ INT32 inc0, inc1, inc2; /* initial values for increments */
+ /* This array holds the distance to the nearest-so-far color for each cell */
+ INT32 bestdist[BOX_C0_ELEMS * BOX_C1_ELEMS * BOX_C2_ELEMS];
+
+ /* Initialize best-distance for each cell of the update box */
+ bptr = bestdist;
+ for (i = BOX_C0_ELEMS*BOX_C1_ELEMS*BOX_C2_ELEMS-1; i >= 0; i--)
+ *bptr++ = 0x7FFFFFFFL;
+
+ /* For each color selected by find_nearby_colors,
+ * compute its distance to the center of each cell in the box.
+ * If that's less than best-so-far, update best distance and color number.
+ */
+
+ /* Nominal steps between cell centers ("x" in Thomas article) */
+#define STEP_C0 ((1 << C0_SHIFT) * C0_SCALE)
+#define STEP_C1 ((1 << C1_SHIFT) * C1_SCALE)
+#define STEP_C2 ((1 << C2_SHIFT) * C2_SCALE)
+
+ for (i = 0; i < numcolors; i++) {
+ icolor = GETJSAMPLE(colorlist[i]);
+ /* Compute (square of) distance from minc0/c1/c2 to this color */
+ inc0 = (minc0 - GETJSAMPLE(cinfo->colormap[0][icolor])) * C0_SCALE;
+ dist0 = inc0*inc0;
+ inc1 = (minc1 - GETJSAMPLE(cinfo->colormap[1][icolor])) * C1_SCALE;
+ dist0 += inc1*inc1;
+ inc2 = (minc2 - GETJSAMPLE(cinfo->colormap[2][icolor])) * C2_SCALE;
+ dist0 += inc2*inc2;
+ /* Form the initial difference increments */
+ inc0 = inc0 * (2 * STEP_C0) + STEP_C0 * STEP_C0;
+ inc1 = inc1 * (2 * STEP_C1) + STEP_C1 * STEP_C1;
+ inc2 = inc2 * (2 * STEP_C2) + STEP_C2 * STEP_C2;
+ /* Now loop over all cells in box, updating distance per Thomas method */
+ bptr = bestdist;
+ cptr = bestcolor;
+ xx0 = inc0;
+ for (ic0 = BOX_C0_ELEMS-1; ic0 >= 0; ic0--) {
+ dist1 = dist0;
+ xx1 = inc1;
+ for (ic1 = BOX_C1_ELEMS-1; ic1 >= 0; ic1--) {
+ dist2 = dist1;
+ xx2 = inc2;
+ for (ic2 = BOX_C2_ELEMS-1; ic2 >= 0; ic2--) {
+ if (dist2 < *bptr) {
+ *bptr = dist2;
+ *cptr = (JSAMPLE) icolor;
+ }
+ dist2 += xx2;
+ xx2 += 2 * STEP_C2 * STEP_C2;
+ bptr++;
+ cptr++;
+ }
+ dist1 += xx1;
+ xx1 += 2 * STEP_C1 * STEP_C1;
+ }
+ dist0 += xx0;
+ xx0 += 2 * STEP_C0 * STEP_C0;
+ }
+ }
+}
+
+
+LOCAL(void)
+fill_inverse_cmap (j_decompress_ptr cinfo, int c0, int c1, int c2)
+/* Fill the inverse-colormap entries in the update box that contains */
+/* histogram cell c0/c1/c2. (Only that one cell MUST be filled, but */
+/* we can fill as many others as we wish.) */
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ hist3d histogram = cquantize->histogram;
+ int minc0, minc1, minc2; /* lower left corner of update box */
+ int ic0, ic1, ic2;
+ register JSAMPLE * cptr; /* pointer into bestcolor[] array */
+ register histptr cachep; /* pointer into main cache array */
+ /* This array lists the candidate colormap indexes. */
+ JSAMPLE colorlist[MAXNUMCOLORS];
+ int numcolors; /* number of candidate colors */
+ /* This array holds the actually closest colormap index for each cell. */
+ JSAMPLE bestcolor[BOX_C0_ELEMS * BOX_C1_ELEMS * BOX_C2_ELEMS];
+
+ /* Convert cell coordinates to update box ID */
+ c0 >>= BOX_C0_LOG;
+ c1 >>= BOX_C1_LOG;
+ c2 >>= BOX_C2_LOG;
+
+ /* Compute true coordinates of update box's origin corner.
+ * Actually we compute the coordinates of the center of the corner
+ * histogram cell, which are the lower bounds of the volume we care about.
+ */
+ minc0 = (c0 << BOX_C0_SHIFT) + ((1 << C0_SHIFT) >> 1);
+ minc1 = (c1 << BOX_C1_SHIFT) + ((1 << C1_SHIFT) >> 1);
+ minc2 = (c2 << BOX_C2_SHIFT) + ((1 << C2_SHIFT) >> 1);
+
+ /* Determine which colormap entries are close enough to be candidates
+ * for the nearest entry to some cell in the update box.
+ */
+ numcolors = find_nearby_colors(cinfo, minc0, minc1, minc2, colorlist);
+
+ /* Determine the actually nearest colors. */
+ find_best_colors(cinfo, minc0, minc1, minc2, numcolors, colorlist,
+ bestcolor);
+
+ /* Save the best color numbers (plus 1) in the main cache array */
+ c0 <<= BOX_C0_LOG; /* convert ID back to base cell indexes */
+ c1 <<= BOX_C1_LOG;
+ c2 <<= BOX_C2_LOG;
+ cptr = bestcolor;
+ for (ic0 = 0; ic0 < BOX_C0_ELEMS; ic0++) {
+ for (ic1 = 0; ic1 < BOX_C1_ELEMS; ic1++) {
+ cachep = & histogram[c0+ic0][c1+ic1][c2];
+ for (ic2 = 0; ic2 < BOX_C2_ELEMS; ic2++) {
+ *cachep++ = (histcell) (GETJSAMPLE(*cptr++) + 1);
+ }
+ }
+ }
+}
+
+
+/*
+ * Map some rows of pixels to the output colormapped representation.
+ */
+
+METHODDEF(void)
+pass2_no_dither (j_decompress_ptr cinfo,
+ JSAMPARRAY input_buf, JSAMPARRAY output_buf, int num_rows)
+/* This version performs no dithering */
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ hist3d histogram = cquantize->histogram;
+ register JSAMPROW inptr, outptr;
+ register histptr cachep;
+ register int c0, c1, c2;
+ int row;
+ JDIMENSION col;
+ JDIMENSION width = cinfo->output_width;
+
+ for (row = 0; row < num_rows; row++) {
+ inptr = input_buf[row];
+ outptr = output_buf[row];
+ for (col = width; col > 0; col--) {
+ /* get pixel value and index into the cache */
+ c0 = GETJSAMPLE(*inptr++) >> C0_SHIFT;
+ c1 = GETJSAMPLE(*inptr++) >> C1_SHIFT;
+ c2 = GETJSAMPLE(*inptr++) >> C2_SHIFT;
+ cachep = & histogram[c0][c1][c2];
+ /* If we have not seen this color before, find nearest colormap entry */
+ /* and update the cache */
+ if (*cachep == 0)
+ fill_inverse_cmap(cinfo, c0,c1,c2);
+ /* Now emit the colormap index for this cell */
+ *outptr++ = (JSAMPLE) (*cachep - 1);
+ }
+ }
+}
+
+
+METHODDEF(void)
+pass2_fs_dither (j_decompress_ptr cinfo,
+ JSAMPARRAY input_buf, JSAMPARRAY output_buf, int num_rows)
+/* This version performs Floyd-Steinberg dithering */
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ hist3d histogram = cquantize->histogram;
+ register LOCFSERROR cur0, cur1, cur2; /* current error or pixel value */
+ LOCFSERROR belowerr0, belowerr1, belowerr2; /* error for pixel below cur */
+ LOCFSERROR bpreverr0, bpreverr1, bpreverr2; /* error for below/prev col */
+ register FSERRPTR errorptr; /* => fserrors[] at column before current */
+ JSAMPROW inptr; /* => current input pixel */
+ JSAMPROW outptr; /* => current output pixel */
+ histptr cachep;
+ int dir; /* +1 or -1 depending on direction */
+ int dir3; /* 3*dir, for advancing inptr & errorptr */
+ int row;
+ JDIMENSION col;
+ JDIMENSION width = cinfo->output_width;
+ JSAMPLE *range_limit = cinfo->sample_range_limit;
+ int *error_limit = cquantize->error_limiter;
+ JSAMPROW colormap0 = cinfo->colormap[0];
+ JSAMPROW colormap1 = cinfo->colormap[1];
+ JSAMPROW colormap2 = cinfo->colormap[2];
+ SHIFT_TEMPS
+
+ for (row = 0; row < num_rows; row++) {
+ inptr = input_buf[row];
+ outptr = output_buf[row];
+ if (cquantize->on_odd_row) {
+ /* work right to left in this row */
+ inptr += (width-1) * 3; /* so point to rightmost pixel */
+ outptr += width-1;
+ dir = -1;
+ dir3 = -3;
+ errorptr = cquantize->fserrors + (width+1)*3; /* => entry after last column */
+ cquantize->on_odd_row = FALSE; /* flip for next time */
+ } else {
+ /* work left to right in this row */
+ dir = 1;
+ dir3 = 3;
+ errorptr = cquantize->fserrors; /* => entry before first real column */
+ cquantize->on_odd_row = TRUE; /* flip for next time */
+ }
+ /* Preset error values: no error propagated to first pixel from left */
+ cur0 = cur1 = cur2 = 0;
+ /* and no error propagated to row below yet */
+ belowerr0 = belowerr1 = belowerr2 = 0;
+ bpreverr0 = bpreverr1 = bpreverr2 = 0;
+
+ for (col = width; col > 0; col--) {
+ /* curN holds the error propagated from the previous pixel on the
+ * current line. Add the error propagated from the previous line
+ * to form the complete error correction term for this pixel, and
+ * round the error term (which is expressed * 16) to an integer.
+ * RIGHT_SHIFT rounds towards minus infinity, so adding 8 is correct
+ * for either sign of the error value.
+ * Note: errorptr points to *previous* column's array entry.
+ */
+ cur0 = RIGHT_SHIFT(cur0 + errorptr[dir3+0] + 8, 4);
+ cur1 = RIGHT_SHIFT(cur1 + errorptr[dir3+1] + 8, 4);
+ cur2 = RIGHT_SHIFT(cur2 + errorptr[dir3+2] + 8, 4);
+ /* Limit the error using transfer function set by init_error_limit.
+ * See comments with init_error_limit for rationale.
+ */
+ cur0 = error_limit[cur0];
+ cur1 = error_limit[cur1];
+ cur2 = error_limit[cur2];
+ /* Form pixel value + error, and range-limit to 0..MAXJSAMPLE.
+ * The maximum error is +- MAXJSAMPLE (or less with error limiting);
+ * this sets the required size of the range_limit array.
+ */
+ cur0 += GETJSAMPLE(inptr[0]);
+ cur1 += GETJSAMPLE(inptr[1]);
+ cur2 += GETJSAMPLE(inptr[2]);
+ cur0 = GETJSAMPLE(range_limit[cur0]);
+ cur1 = GETJSAMPLE(range_limit[cur1]);
+ cur2 = GETJSAMPLE(range_limit[cur2]);
+ /* Index into the cache with adjusted pixel value */
+ cachep = & histogram[cur0>>C0_SHIFT][cur1>>C1_SHIFT][cur2>>C2_SHIFT];
+ /* If we have not seen this color before, find nearest colormap */
+ /* entry and update the cache */
+ if (*cachep == 0)
+ fill_inverse_cmap(cinfo, cur0>>C0_SHIFT,cur1>>C1_SHIFT,cur2>>C2_SHIFT);
+ /* Now emit the colormap index for this cell */
+ { register int pixcode = *cachep - 1;
+ *outptr = (JSAMPLE) pixcode;
+ /* Compute representation error for this pixel */
+ cur0 -= GETJSAMPLE(colormap0[pixcode]);
+ cur1 -= GETJSAMPLE(colormap1[pixcode]);
+ cur2 -= GETJSAMPLE(colormap2[pixcode]);
+ }
+ /* Compute error fractions to be propagated to adjacent pixels.
+ * Add these into the running sums, and simultaneously shift the
+ * next-line error sums left by 1 column.
+ */
+ { register LOCFSERROR bnexterr, delta;
+
+ bnexterr = cur0; /* Process component 0 */
+ delta = cur0 * 2;
+ cur0 += delta; /* form error * 3 */
+ errorptr[0] = (FSERROR) (bpreverr0 + cur0);
+ cur0 += delta; /* form error * 5 */
+ bpreverr0 = belowerr0 + cur0;
+ belowerr0 = bnexterr;
+ cur0 += delta; /* form error * 7 */
+ bnexterr = cur1; /* Process component 1 */
+ delta = cur1 * 2;
+ cur1 += delta; /* form error * 3 */
+ errorptr[1] = (FSERROR) (bpreverr1 + cur1);
+ cur1 += delta; /* form error * 5 */
+ bpreverr1 = belowerr1 + cur1;
+ belowerr1 = bnexterr;
+ cur1 += delta; /* form error * 7 */
+ bnexterr = cur2; /* Process component 2 */
+ delta = cur2 * 2;
+ cur2 += delta; /* form error * 3 */
+ errorptr[2] = (FSERROR) (bpreverr2 + cur2);
+ cur2 += delta; /* form error * 5 */
+ bpreverr2 = belowerr2 + cur2;
+ belowerr2 = bnexterr;
+ cur2 += delta; /* form error * 7 */
+ }
+ /* At this point curN contains the 7/16 error value to be propagated
+ * to the next pixel on the current line, and all the errors for the
+ * next line have been shifted over. We are therefore ready to move on.
+ */
+ inptr += dir3; /* Advance pixel pointers to next column */
+ outptr += dir;
+ errorptr += dir3; /* advance errorptr to current column */
+ }
+ /* Post-loop cleanup: we must unload the final error values into the
+ * final fserrors[] entry. Note we need not unload belowerrN because
+ * it is for the dummy column before or after the actual array.
+ */
+ errorptr[0] = (FSERROR) bpreverr0; /* unload prev errs into array */
+ errorptr[1] = (FSERROR) bpreverr1;
+ errorptr[2] = (FSERROR) bpreverr2;
+ }
+}
+
+
+/*
+ * Initialize the error-limiting transfer function (lookup table).
+ * The raw F-S error computation can potentially compute error values of up to
+ * +- MAXJSAMPLE. But we want the maximum correction applied to a pixel to be
+ * much less, otherwise obviously wrong pixels will be created. (Typical
+ * effects include weird fringes at color-area boundaries, isolated bright
+ * pixels in a dark area, etc.) The standard advice for avoiding this problem
+ * is to ensure that the "corners" of the color cube are allocated as output
+ * colors; then repeated errors in the same direction cannot cause cascading
+ * error buildup. However, that only prevents the error from getting
+ * completely out of hand; Aaron Giles reports that error limiting improves
+ * the results even with corner colors allocated.
+ * A simple clamping of the error values to about +- MAXJSAMPLE/8 works pretty
+ * well, but the smoother transfer function used below is even better. Thanks
+ * to Aaron Giles for this idea.
+ */
+
+LOCAL(void)
+init_error_limit (j_decompress_ptr cinfo)
+/* Allocate and fill in the error_limiter table */
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ int * table;
+ int in, out;
+
+ table = (int *) (*cinfo->mem->alloc_small)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE*2+1) * SIZEOF(int));
+ table += MAXJSAMPLE; /* so can index -MAXJSAMPLE .. +MAXJSAMPLE */
+ cquantize->error_limiter = table;
+
+#define STEPSIZE ((MAXJSAMPLE+1)/16)
+ /* Map errors 1:1 up to +- MAXJSAMPLE/16 */
+ out = 0;
+ for (in = 0; in < STEPSIZE; in++, out++) {
+ table[in] = out; table[-in] = -out;
+ }
+ /* Map errors 1:2 up to +- 3*MAXJSAMPLE/16 */
+ for (; in < STEPSIZE*3; in++, out += (in&1) ? 0 : 1) {
+ table[in] = out; table[-in] = -out;
+ }
+ /* Clamp the rest to final out value (which is (MAXJSAMPLE+1)/8) */
+ for (; in <= MAXJSAMPLE; in++) {
+ table[in] = out; table[-in] = -out;
+ }
+#undef STEPSIZE
+}
+
+
+/*
+ * Finish up at the end of each pass.
+ */
+
+METHODDEF(void)
+finish_pass1 (j_decompress_ptr cinfo)
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+
+ /* Select the representative colors and fill in cinfo->colormap */
+ cinfo->colormap = cquantize->sv_colormap;
+ select_colors(cinfo, cquantize->desired);
+ /* Force next pass to zero the color index table */
+ cquantize->needs_zeroed = TRUE;
+}
+
+
+METHODDEF(void)
+finish_pass2 (j_decompress_ptr cinfo)
+{
+ /* no work */
+}
+
+
+/*
+ * Initialize for each processing pass.
+ */
+
+METHODDEF(void)
+start_pass_2_quant (j_decompress_ptr cinfo, boolean is_pre_scan)
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ hist3d histogram = cquantize->histogram;
+ int i;
+
+ /* Only F-S dithering or no dithering is supported. */
+ /* If user asks for ordered dither, give him F-S. */
+ if (cinfo->dither_mode != JDITHER_NONE)
+ cinfo->dither_mode = JDITHER_FS;
+
+ if (is_pre_scan) {
+ /* Set up method pointers */
+ cquantize->pub.color_quantize = prescan_quantize;
+ cquantize->pub.finish_pass = finish_pass1;
+ cquantize->needs_zeroed = TRUE; /* Always zero histogram */
+ } else {
+ /* Set up method pointers */
+ if (cinfo->dither_mode == JDITHER_FS)
+ cquantize->pub.color_quantize = pass2_fs_dither;
+ else
+ cquantize->pub.color_quantize = pass2_no_dither;
+ cquantize->pub.finish_pass = finish_pass2;
+
+ /* Make sure color count is acceptable */
+ i = cinfo->actual_number_of_colors;
+ if (i < 1)
+ ERREXIT1(cinfo, JERR_QUANT_FEW_COLORS, 1);
+ if (i > MAXNUMCOLORS)
+ ERREXIT1(cinfo, JERR_QUANT_MANY_COLORS, MAXNUMCOLORS);
+
+ if (cinfo->dither_mode == JDITHER_FS) {
+ size_t arraysize = (size_t) ((cinfo->output_width + 2) *
+ (3 * SIZEOF(FSERROR)));
+ /* Allocate Floyd-Steinberg workspace if we didn't already. */
+ if (cquantize->fserrors == NULL)
+ cquantize->fserrors = (FSERRPTR) (*cinfo->mem->alloc_large)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE, arraysize);
+ /* Initialize the propagated errors to zero. */
+ jzero_far((void FAR *) cquantize->fserrors, arraysize);
+ /* Make the error-limit table if we didn't already. */
+ if (cquantize->error_limiter == NULL)
+ init_error_limit(cinfo);
+ cquantize->on_odd_row = FALSE;
+ }
+
+ }
+ /* Zero the histogram or inverse color map, if necessary */
+ if (cquantize->needs_zeroed) {
+ for (i = 0; i < HIST_C0_ELEMS; i++) {
+ jzero_far((void FAR *) histogram[i],
+ HIST_C1_ELEMS*HIST_C2_ELEMS * SIZEOF(histcell));
+ }
+ cquantize->needs_zeroed = FALSE;
+ }
+}
+
+
+/*
+ * Switch to a new external colormap between output passes.
+ */
+
+METHODDEF(void)
+new_color_map_2_quant (j_decompress_ptr cinfo)
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+
+ /* Reset the inverse color map */
+ cquantize->needs_zeroed = TRUE;
+}
+
+
+/*
+ * Module initialization routine for 2-pass color quantization.
+ */
+
+GLOBAL(void)
+jinit_2pass_quantizer (j_decompress_ptr cinfo)
+{
+ my_cquantize_ptr cquantize;
+ int i;
+
+ cquantize = (my_cquantize_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_cquantizer));
+ cinfo->cquantize = (struct jpeg_color_quantizer *) cquantize;
+ cquantize->pub.start_pass = start_pass_2_quant;
+ cquantize->pub.new_color_map = new_color_map_2_quant;
+ cquantize->fserrors = NULL; /* flag optional arrays not allocated */
+ cquantize->error_limiter = NULL;
+
+ /* Make sure jdmaster didn't give me a case I can't handle */
+ if (cinfo->out_color_components != 3)
+ ERREXIT(cinfo, JERR_NOTIMPL);
+
+ /* Allocate the histogram/inverse colormap storage */
+ cquantize->histogram = (hist3d) (*cinfo->mem->alloc_small)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE, HIST_C0_ELEMS * SIZEOF(hist2d));
+ for (i = 0; i < HIST_C0_ELEMS; i++) {
+ cquantize->histogram[i] = (hist2d) (*cinfo->mem->alloc_large)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ HIST_C1_ELEMS*HIST_C2_ELEMS * SIZEOF(histcell));
+ }
+ cquantize->needs_zeroed = TRUE; /* histogram is garbage now */
+
+ /* Allocate storage for the completed colormap, if required.
+ * We do this now since it is FAR storage and may affect
+ * the memory manager's space calculations.
+ */
+ if (cinfo->enable_2pass_quant) {
+ /* Make sure color count is acceptable */
+ int desired = cinfo->desired_number_of_colors;
+ /* Lower bound on # of colors ... somewhat arbitrary as long as > 0 */
+ if (desired < 8)
+ ERREXIT1(cinfo, JERR_QUANT_FEW_COLORS, 8);
+ /* Make sure colormap indexes can be represented by JSAMPLEs */
+ if (desired > MAXNUMCOLORS)
+ ERREXIT1(cinfo, JERR_QUANT_MANY_COLORS, MAXNUMCOLORS);
+ cquantize->sv_colormap = (*cinfo->mem->alloc_sarray)
+ ((j_common_ptr) cinfo,JPOOL_IMAGE, (JDIMENSION) desired, (JDIMENSION) 3);
+ cquantize->desired = desired;
+ } else
+ cquantize->sv_colormap = NULL;
+
+ /* Only F-S dithering or no dithering is supported. */
+ /* If user asks for ordered dither, give him F-S. */
+ if (cinfo->dither_mode != JDITHER_NONE)
+ cinfo->dither_mode = JDITHER_FS;
+
+ /* Allocate Floyd-Steinberg workspace if necessary.
+ * This isn't really needed until pass 2, but again it is FAR storage.
+ * Although we will cope with a later change in dither_mode,
+ * we do not promise to honor max_memory_to_use if dither_mode changes.
+ */
+ if (cinfo->dither_mode == JDITHER_FS) {
+ cquantize->fserrors = (FSERRPTR) (*cinfo->mem->alloc_large)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (size_t) ((cinfo->output_width + 2) * (3 * SIZEOF(FSERROR))));
+ /* Might as well create the error-limiting table too. */
+ init_error_limit(cinfo);
+ }
+}
+
+#endif /* QUANT_2PASS_SUPPORTED */
--- /dev/null
+/*
+ * jutils.c
+ *
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * 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 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"
+
+
+/*
+ * 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);
+}
+
+
+/* On normal machines we can apply MEMCOPY() and MEMZERO() to sample arrays
+ * and coefficient-block arrays. This won't work on 80x86 because the arrays
+ * are FAR and we're assuming a small-pointer memory model. However, some
+ * DOS compilers provide far-pointer versions of memcpy() and memset() even
+ * in the small-model libraries. These will be used if USE_FMEM is defined.
+ * Otherwise, the routines below do it the hard way. (The performance cost
+ * is not all that great, because these routines aren't very heavily used.)
+ */
+
+#ifndef NEED_FAR_POINTERS /* normal case, same as regular macros */
+#define FMEMCOPY(dest,src,size) MEMCOPY(dest,src,size)
+#define FMEMZERO(target,size) MEMZERO(target,size)
+#else /* 80x86 case, define if we can */
+#ifdef USE_FMEM
+#define FMEMCOPY(dest,src,size) _fmemcpy((void FAR *)(dest), (const void FAR *)(src), (size_t)(size))
+#define FMEMZERO(target,size) _fmemset((void FAR *)(target), 0, (size_t)(size))
+#endif
+#endif
+
+
+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;
+#ifdef FMEMCOPY
+ register size_t count = (size_t) (num_cols * SIZEOF(JSAMPLE));
+#else
+ register JDIMENSION count;
+#endif
+ register int row;
+
+ input_array += source_row;
+ output_array += dest_row;
+
+ for (row = num_rows; row > 0; row--) {
+ inptr = *input_array++;
+ outptr = *output_array++;
+#ifdef FMEMCOPY
+ FMEMCOPY(outptr, inptr, count);
+#else
+ for (count = num_cols; count > 0; count--)
+ *outptr++ = *inptr++; /* needn't bother with GETJSAMPLE() here */
+#endif
+ }
+}
+
+
+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. */
+{
+#ifdef FMEMCOPY
+ FMEMCOPY(output_row, input_row, num_blocks * (DCTSIZE2 * SIZEOF(JCOEF)));
+#else
+ register JCOEFPTR inptr, outptr;
+ register long count;
+
+ inptr = (JCOEFPTR) input_row;
+ outptr = (JCOEFPTR) output_row;
+ for (count = (long) num_blocks * DCTSIZE2; count > 0; count--) {
+ *outptr++ = *inptr++;
+ }
+#endif
+}
+
+
+GLOBAL(void)
+jzero_far (void FAR * target, size_t bytestozero)
+/* Zero out a chunk of FAR memory. */
+/* This might be sample-array data, block-array data, or alloc_large data. */
+{
+#ifdef FMEMZERO
+ FMEMZERO(target, bytestozero);
+#else
+ register char FAR * ptr = (char FAR *) target;
+ register size_t count;
+
+ for (count = bytestozero; count > 0; count--) {
+ *ptr++ = 0;
+ }
+#endif
+}
--- /dev/null
+/*
+ * jversion.h
+ *
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * 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 software version identification.
+ */
+
+
+#define JVERSION "6b 27-Mar-1998"
+
+#define JCOPYRIGHT "Copyright (C) 1998, Thomas G. Lane"
--- /dev/null
+obj = atmosphere.o background.o camera.o chunk.o ease.o file.o float.o io.o \
+ light.o material.o matrix.o mesh.o node.o quat.o shadow.o tcb.o tracks.o \
+ vector.o viewport.o
+
+liba = ../lib3ds.a
+
+CFLAGS = -O3 -I..
+
+$(liba): $(obj)
+ $(AR) rcs $@ $(obj)
+
+.PHONY: clean
+clean:
+ rm -f $(obj) $(liba)
--- /dev/null
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: atmosphere.c,v 1.9 2001/07/07 19:05:30 jeh Exp $
+ */
+#define LIB3DS_EXPORT
+#include <lib3ds/atmosphere.h>
+#include <lib3ds/chunk.h>
+#include <lib3ds/io.h>
+
+
+/*!
+ * \defgroup atmosphere Atmosphere Settings
+ *
+ * \author J.E. Hoffmann <je-h@gmx.net>
+ */
+
+
+static Lib3dsBool
+fog_read(Lib3dsFog *fog, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+ Lib3dsWord chunk;
+
+ if (!lib3ds_chunk_read_start(&c, LIB3DS_FOG, io)) {
+ return(LIB3DS_FALSE);
+ }
+ fog->near_plane = lib3ds_io_read_float(io);
+ fog->near_density=lib3ds_io_read_float(io);
+ fog->far_plane=lib3ds_io_read_float(io);
+ fog->far_density=lib3ds_io_read_float(io);
+ lib3ds_chunk_read_tell(&c, io);
+
+ while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
+ switch (chunk) {
+ case LIB3DS_LIN_COLOR_F:
+ {
+ int i;
+ for (i=0; i<3; ++i) {
+ fog->col[i]=lib3ds_io_read_float(io);
+ }
+ }
+ break;
+ case LIB3DS_COLOR_F:
+ break;
+ case LIB3DS_FOG_BGND:
+ {
+ fog->fog_background=LIB3DS_TRUE;
+ }
+ break;
+ default:
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+
+ lib3ds_chunk_read_end(&c, io);
+ return(LIB3DS_TRUE);
+}
+
+
+static Lib3dsBool
+layer_fog_read(Lib3dsLayerFog *fog, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+ Lib3dsWord chunk;
+
+ if (!lib3ds_chunk_read_start(&c, LIB3DS_LAYER_FOG, io)) {
+ return(LIB3DS_FALSE);
+ }
+ fog->near_y=lib3ds_io_read_float(io);
+ fog->far_y=lib3ds_io_read_float(io);
+ fog->density=lib3ds_io_read_float(io);
+ fog->flags=lib3ds_io_read_dword(io);
+ lib3ds_chunk_read_tell(&c, io);
+
+ while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
+ switch (chunk) {
+ case LIB3DS_LIN_COLOR_F:
+ lib3ds_io_read_rgb(io, fog->col);
+ break;
+ case LIB3DS_COLOR_F:
+ lib3ds_io_read_rgb(io, fog->col);
+ break;
+ default:
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+
+ lib3ds_chunk_read_end(&c, io);
+ return(LIB3DS_TRUE);
+}
+
+
+static Lib3dsBool
+distance_cue_read(Lib3dsDistanceCue *cue, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+ Lib3dsWord chunk;
+
+ if (!lib3ds_chunk_read_start(&c, LIB3DS_DISTANCE_CUE, io)) {
+ return(LIB3DS_FALSE);
+ }
+ cue->near_plane=lib3ds_io_read_float(io);
+ cue->near_dimming=lib3ds_io_read_float(io);
+ cue->far_plane=lib3ds_io_read_float(io);
+ cue->far_dimming=lib3ds_io_read_float(io);
+ lib3ds_chunk_read_tell(&c, io);
+
+ while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
+ switch (chunk) {
+ case LIB3DS_DCUE_BGND:
+ {
+ cue->cue_background=LIB3DS_TRUE;
+ }
+ break;
+ default:
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+
+ lib3ds_chunk_read_end(&c, io);
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup atmosphere
+ */
+Lib3dsBool
+lib3ds_atmosphere_read(Lib3dsAtmosphere *atmosphere, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+
+ if (!lib3ds_chunk_read(&c, io)) {
+ return(LIB3DS_FALSE);
+ }
+
+ switch (c.chunk) {
+ case LIB3DS_FOG:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!fog_read(&atmosphere->fog, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_LAYER_FOG:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!layer_fog_read(&atmosphere->layer_fog, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_DISTANCE_CUE:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!distance_cue_read(&atmosphere->dist_cue, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_USE_FOG:
+ {
+ atmosphere->fog.use=LIB3DS_TRUE;
+ }
+ break;
+ case LIB3DS_USE_LAYER_FOG:
+ {
+ atmosphere->fog.use=LIB3DS_TRUE;
+ }
+ break;
+ case LIB3DS_USE_DISTANCE_CUE:
+ {
+ atmosphere->dist_cue.use=LIB3DS_TRUE;
+ }
+ break;
+ }
+
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup atmosphere
+ */
+Lib3dsBool
+lib3ds_atmosphere_write(Lib3dsAtmosphere *atmosphere, Lib3dsIo *io)
+{
+ if (atmosphere->fog.use) { /*---- LIB3DS_FOG ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_FOG;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_io_write_float(io, atmosphere->fog.near_plane);
+ lib3ds_io_write_float(io, atmosphere->fog.near_density);
+ lib3ds_io_write_float(io, atmosphere->fog.far_plane);
+ lib3ds_io_write_float(io, atmosphere->fog.far_density);
+ {
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_COLOR_F;
+ c.size=18;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_rgb(io, atmosphere->fog.col);
+ }
+ if (atmosphere->fog.fog_background) {
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_FOG_BGND;
+ c.size=6;
+ lib3ds_chunk_write(&c,io);
+ }
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+
+ if (atmosphere->layer_fog.use) { /*---- LIB3DS_LAYER_FOG ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_LAYER_FOG;
+ c.size=40;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_float(io, atmosphere->layer_fog.near_y);
+ lib3ds_io_write_float(io, atmosphere->layer_fog.far_y);
+ lib3ds_io_write_float(io, atmosphere->layer_fog.near_y);
+ lib3ds_io_write_dword(io, atmosphere->layer_fog.flags);
+ {
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_COLOR_F;
+ c.size=18;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_rgb(io, atmosphere->fog.col);
+ }
+ }
+
+ if (atmosphere->dist_cue.use) { /*---- LIB3DS_DISTANCE_CUE ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_DISTANCE_CUE;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_io_write_float(io, atmosphere->dist_cue.near_plane);
+ lib3ds_io_write_float(io, atmosphere->dist_cue.near_dimming);
+ lib3ds_io_write_float(io, atmosphere->dist_cue.far_plane);
+ lib3ds_io_write_float(io, atmosphere->dist_cue.far_dimming);
+ if (atmosphere->dist_cue.cue_background) {
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_DCUE_BGND;
+ c.size=6;
+ lib3ds_chunk_write(&c,io);
+ }
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+
+ if (atmosphere->fog.use) { /*---- LIB3DS_USE_FOG ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_USE_FOG;
+ c.size=6;
+ lib3ds_chunk_write(&c,io);
+ }
+
+ if (atmosphere->layer_fog.use) { /*---- LIB3DS_USE_LAYER_FOG ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_USE_LAYER_FOG;
+ c.size=6;
+ lib3ds_chunk_write(&c,io);
+ }
+
+ if (atmosphere->dist_cue.use) { /*---- LIB3DS_USE_DISTANCE_CUE ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_USE_V_GRADIENT;
+ c.size=6;
+ lib3ds_chunk_write(&c,io);
+ }
+
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+
+\typedef Lib3dsAtmosphere
+ \ingroup atmosphere
+ \sa _Lib3dsAtmosphere
+
+*/
+
--- /dev/null
+/* -*- c -*- */
+#ifndef INCLUDED_LIB3DS_ATMOSPHERE_H
+#define INCLUDED_LIB3DS_ATMOSPHERE_H
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: atmosphere.h,v 1.6 2004/12/31 16:17:15 reed Exp $
+ */
+
+#ifndef INCLUDED_LIB3DS_TYPES_H
+#include <lib3ds/types.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*!
+ * Fog atmosphere settings
+ * \ingroup atmosphere
+ */
+typedef struct _Lib3dsFog {
+ Lib3dsBool use;
+ Lib3dsRgb col;
+ Lib3dsBool fog_background;
+ Lib3dsFloat near_plane;
+ Lib3dsFloat near_density;
+ Lib3dsFloat far_plane;
+ Lib3dsFloat far_density;
+} Lib3dsFog;
+
+/*!
+ * Layer fog atmosphere flags
+ * \ingroup atmosphere
+ */
+typedef enum _Lib3dsLayerFogFlags {
+ LIB3DS_BOTTOM_FALL_OFF =0x00000001,
+ LIB3DS_TOP_FALL_OFF =0x00000002,
+ LIB3DS_FOG_BACKGROUND =0x00100000
+} Lib3dsLayerFogFlags;
+
+/*!
+ * Layer fog atmosphere settings
+ * \ingroup atmosphere
+ */
+typedef struct _Lib3dsLayerFog {
+ Lib3dsBool use;
+ Lib3dsDword flags;
+ Lib3dsRgb col;
+ Lib3dsFloat near_y;
+ Lib3dsFloat far_y;
+ Lib3dsFloat density;
+} Lib3dsLayerFog;
+
+/*!
+ * Distance cue atmosphere settings
+ * \ingroup atmosphere
+ */
+typedef struct _Lib3dsDistanceCue {
+ Lib3dsBool use;
+ Lib3dsBool cue_background;
+ Lib3dsFloat near_plane;
+ Lib3dsFloat near_dimming;
+ Lib3dsFloat far_plane;
+ Lib3dsFloat far_dimming;
+} Lib3dsDistanceCue;
+
+/*!
+ * Atmosphere settings
+ * \ingroup atmosphere
+ */
+struct _Lib3dsAtmosphere {
+ Lib3dsFog fog;
+ Lib3dsLayerFog layer_fog;
+ Lib3dsDistanceCue dist_cue;
+};
+
+extern LIB3DSAPI Lib3dsBool lib3ds_atmosphere_read(Lib3dsAtmosphere *atmosphere, Lib3dsIo *io);
+extern LIB3DSAPI Lib3dsBool lib3ds_atmosphere_write(Lib3dsAtmosphere *atmosphere, Lib3dsIo *io);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
--- /dev/null
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: background.c,v 1.8 2001/07/07 19:05:30 jeh Exp $
+ */
+#define LIB3DS_EXPORT
+#include <lib3ds/background.h>
+#include <lib3ds/chunk.h>
+#include <lib3ds/io.h>
+#include <string.h>
+#include <math.h>
+
+
+/*!
+ * \defgroup background Background Settings
+ *
+ * \author J.E. Hoffmann <je-h@gmx.net>
+ */
+
+
+static Lib3dsBool
+solid_bgnd_read(Lib3dsBackground *background, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+ Lib3dsWord chunk;
+
+ if (!lib3ds_chunk_read_start(&c, LIB3DS_SOLID_BGND, io)) {
+ return(LIB3DS_FALSE);
+ }
+
+ while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
+ switch (chunk) {
+ case LIB3DS_LIN_COLOR_F:
+ lib3ds_io_read_rgb(io, background->solid.col);
+ break;
+ case LIB3DS_COLOR_F:
+ lib3ds_io_read_rgb(io, background->solid.col);
+ break;
+ default:
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+
+ lib3ds_chunk_read_end(&c, io);
+ return(LIB3DS_TRUE);
+}
+
+
+static Lib3dsBool
+v_gradient_read(Lib3dsBackground *background, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+ Lib3dsWord chunk;
+ int index[2];
+ Lib3dsRgb col[2][3];
+ int have_lin=0;
+
+
+ if (!lib3ds_chunk_read_start(&c, LIB3DS_V_GRADIENT, io)) {
+ return(LIB3DS_FALSE);
+ }
+ background->gradient.percent=lib3ds_io_read_float(io);
+ lib3ds_chunk_read_tell(&c, io);
+
+ index[0]=index[1]=0;
+ while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
+ switch (chunk) {
+ case LIB3DS_COLOR_F:
+ lib3ds_io_read_rgb(io, col[0][index[0]]);
+ index[0]++;
+ break;
+ case LIB3DS_LIN_COLOR_F:
+ lib3ds_io_read_rgb(io, col[1][index[1]]);
+ index[1]++;
+ have_lin=1;
+ break;
+ default:
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+ {
+ int i;
+ for (i=0; i<3; ++i) {
+ background->gradient.top[i]=col[have_lin][0][i];
+ background->gradient.middle[i]=col[have_lin][1][i];
+ background->gradient.bottom[i]=col[have_lin][2][i];
+ }
+ }
+ lib3ds_chunk_read_end(&c, io);
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup background
+ */
+Lib3dsBool
+lib3ds_background_read(Lib3dsBackground *background, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+
+ if (!lib3ds_chunk_read(&c, io)) {
+ return(LIB3DS_FALSE);
+ }
+
+ switch (c.chunk) {
+ case LIB3DS_BIT_MAP:
+ {
+ if (!lib3ds_io_read_string(io, background->bitmap.name, 64)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_SOLID_BGND:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!solid_bgnd_read(background, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_V_GRADIENT:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!v_gradient_read(background, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_USE_BIT_MAP:
+ {
+ background->bitmap.use=LIB3DS_TRUE;
+ }
+ break;
+ case LIB3DS_USE_SOLID_BGND:
+ {
+ background->solid.use=LIB3DS_TRUE;
+ }
+ break;
+ case LIB3DS_USE_V_GRADIENT:
+ {
+ background->gradient.use=LIB3DS_TRUE;
+ }
+ break;
+ }
+
+ return(LIB3DS_TRUE);
+}
+
+
+static Lib3dsBool
+colorf_write(Lib3dsRgba rgb, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+
+ c.chunk=LIB3DS_COLOR_F;
+ c.size=18;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_rgb(io, rgb);
+
+ c.chunk=LIB3DS_LIN_COLOR_F;
+ c.size=18;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_rgb(io, rgb);
+ return(LIB3DS_TRUE);
+}
+
+
+static Lib3dsBool
+colorf_defined(Lib3dsRgba rgb)
+{
+ int i;
+ for (i=0; i<3; ++i) {
+ if (fabs(rgb[i])>LIB3DS_EPSILON) {
+ break;
+ }
+ }
+ return(i<3);
+}
+
+
+/*!
+ * \ingroup background
+ */
+Lib3dsBool
+lib3ds_background_write(Lib3dsBackground *background, Lib3dsIo *io)
+{
+ if (strlen(background->bitmap.name)) { /*---- LIB3DS_BIT_MAP ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_BIT_MAP;
+ c.size=6+1+strlen(background->bitmap.name);
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_string(io, background->bitmap.name);
+ }
+
+ if (colorf_defined(background->solid.col)) { /*---- LIB3DS_SOLID_BGND ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_SOLID_BGND;
+ c.size=42;
+ lib3ds_chunk_write(&c,io);
+ colorf_write(background->solid.col, io);
+ }
+
+ if (colorf_defined(background->gradient.top) ||
+ colorf_defined(background->gradient.middle) ||
+ colorf_defined(background->gradient.bottom)) { /*---- LIB3DS_V_GRADIENT ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_V_GRADIENT;
+ c.size=118;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_float(io, background->gradient.percent);
+ colorf_write(background->gradient.top,io);
+ colorf_write(background->gradient.middle,io);
+ colorf_write(background->gradient.bottom,io);
+ }
+
+ if (background->bitmap.use) { /*---- LIB3DS_USE_BIT_MAP ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_USE_BIT_MAP;
+ c.size=6;
+ lib3ds_chunk_write(&c,io);
+ }
+
+ if (background->solid.use) { /*---- LIB3DS_USE_SOLID_BGND ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_USE_SOLID_BGND;
+ c.size=6;
+ lib3ds_chunk_write(&c,io);
+ }
+
+ if (background->gradient.use) { /*---- LIB3DS_USE_V_GRADIENT ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_USE_V_GRADIENT;
+ c.size=6;
+ lib3ds_chunk_write(&c,io);
+ }
+
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+
+\typedef Lib3dsBackground
+ \ingroup background
+ \sa _Lib3dsBackground
+
+*/
--- /dev/null
+/* -*- c -*- */
+#ifndef INCLUDED_LIB3DS_BACKGROUND_H
+#define INCLUDED_LIB3DS_BACKGROUND_H
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: background.h,v 1.6 2004/12/31 16:17:15 reed Exp $
+ */
+
+#ifndef INCLUDED_LIB3DS_TYPES_H
+#include <lib3ds/types.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*!
+ * Bitmap background settings
+ * \ingroup background
+ */
+typedef struct _Lib3dsBitmap {
+ Lib3dsBool use;
+ char name[64];
+} Lib3dsBitmap;
+
+/*!
+ * Solid color background settings
+ * \ingroup background
+ */
+typedef struct _Lib3dsSolid {
+ Lib3dsBool use;
+ Lib3dsRgb col;
+} Lib3dsSolid;
+
+/*!
+ * Gradient background settings
+ * \ingroup background
+ */
+typedef struct _Lib3dsGradient {
+ Lib3dsBool use;
+ Lib3dsFloat percent;
+ Lib3dsRgb top;
+ Lib3dsRgb middle;
+ Lib3dsRgb bottom;
+} Lib3dsGradient;
+
+/*!
+ * Background settings
+ * \ingroup background
+ */
+struct _Lib3dsBackground {
+ Lib3dsBitmap bitmap;
+ Lib3dsSolid solid;
+ Lib3dsGradient gradient;
+};
+
+extern LIB3DSAPI Lib3dsBool lib3ds_background_read(Lib3dsBackground *background, Lib3dsIo *io);
+extern LIB3DSAPI Lib3dsBool lib3ds_background_write(Lib3dsBackground *background, Lib3dsIo *io);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+
+
+
+
--- /dev/null
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: camera.c,v 1.12 2004/11/16 07:41:44 efalk Exp $
+ */
+#define LIB3DS_EXPORT
+#include <lib3ds/camera.h>
+#include <lib3ds/chunk.h>
+#include <lib3ds/io.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+#ifdef WITH_DMALLOC
+#include <dmalloc.h>
+#endif
+
+
+/*!
+ * \defgroup camera Cameras
+ *
+ * \author J.E. Hoffmann <je-h@gmx.net>
+ */
+
+
+/*!
+ * Return a new Lib3dsCamera object.
+ *
+ * Object is initialized with the given name and fov=45. All other
+ * values are 0.
+ *
+ * \param name Name of this camera. Must not be NULL. Must be < 64 characters.
+ *
+ * \return Lib3dsCamera object or NULL on failure.
+ *
+ * \ingroup camera
+ */
+Lib3dsCamera*
+lib3ds_camera_new(const char *name)
+{
+ Lib3dsCamera *camera;
+
+ ASSERT(name);
+ ASSERT(strlen(name)<64);
+
+ camera=(Lib3dsCamera*)calloc(sizeof(Lib3dsCamera), 1);
+ if (!camera) {
+ return(0);
+ }
+ strcpy(camera->name, name);
+ camera->fov=45.0f;
+ return(camera);
+}
+
+
+/*!
+ * Free a Lib3dsCamera object and all of its resources.
+ *
+ * \param camera Lib3dsCamera object to be freed.
+ *
+ * \ingroup camera
+ */
+void
+lib3ds_camera_free(Lib3dsCamera *camera)
+{
+ memset(camera, 0, sizeof(Lib3dsCamera));
+ free(camera);
+}
+
+
+/*!
+ * Dump information about a Lib3dsCamera object to stdout.
+ *
+ * \param camera Object to be dumped.
+ *
+ * \see lib3ds_file_dump_cameras
+ *
+ * \ingroup camera
+ */
+void
+lib3ds_camera_dump(Lib3dsCamera *camera)
+{
+ ASSERT(camera);
+ printf(" name: %s\n", camera->name);
+ printf(" position: (%f, %f, %f)\n",
+ camera->position[0], camera->position[1], camera->position[2]);
+ printf(" target (%f, %f, %f)\n",
+ camera->target[0], camera->target[1], camera->target[2]);
+ printf(" roll: %f\n", camera->roll);
+ printf(" fov: %f\n", camera->fov);
+ printf(" see_cone: %s\n", camera->see_cone ? "yes" : "no");
+ printf(" near_range: %f\n", camera->near_range);
+ printf(" far_range: %f\n", camera->far_range);
+ printf("\n");
+}
+
+
+/*!
+ * Read a camera definition from a file.
+ *
+ * This function is called by lib3ds_file_read(), and you probably
+ * don't want to call it directly.
+ *
+ * \param camera A Lib3dsCamera to be filled in.
+ * \param io A Lib3dsIo object previously set up by the caller.
+ *
+ * \return LIB3DS_TRUE on success, LIB3DS_FALSE on failure.
+ *
+ * \see lib3ds_file_read
+ *
+ * \ingroup camera
+ */
+Lib3dsBool
+lib3ds_camera_read(Lib3dsCamera *camera, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+ Lib3dsWord chunk;
+
+ if (!lib3ds_chunk_read_start(&c, LIB3DS_N_CAMERA, io)) {
+ return(LIB3DS_FALSE);
+ }
+ {
+ int i;
+ for (i=0; i<3; ++i) {
+ camera->position[i]=lib3ds_io_read_float(io);
+ }
+ for (i=0; i<3; ++i) {
+ camera->target[i]=lib3ds_io_read_float(io);
+ }
+ }
+ camera->roll=lib3ds_io_read_float(io);
+ {
+ float s;
+ s=lib3ds_io_read_float(io);
+ if (fabs(s)<LIB3DS_EPSILON) {
+ camera->fov=45.0;
+ }
+ else {
+ camera->fov=2400.0f/s;
+ }
+ }
+ lib3ds_chunk_read_tell(&c, io);
+
+ while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
+ switch (chunk) {
+ case LIB3DS_CAM_SEE_CONE:
+ {
+ camera->see_cone=LIB3DS_TRUE;
+ }
+ break;
+ case LIB3DS_CAM_RANGES:
+ {
+ camera->near_range=lib3ds_io_read_float(io);
+ camera->far_range=lib3ds_io_read_float(io);
+ }
+ break;
+ default:
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+
+ lib3ds_chunk_read_end(&c, io);
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * Write a camera definition to a file.
+ *
+ * This function is called by lib3ds_file_write(), and you probably
+ * don't want to call it directly.
+ *
+ * \param camera A Lib3dsCamera to be written.
+ * \param io A Lib3dsIo object previously set up by the caller.
+ *
+ * \return LIB3DS_TRUE on success, LIB3DS_FALSE on failure.
+ *
+ * \see lib3ds_file_write
+ *
+ * \ingroup camera
+ */
+Lib3dsBool
+lib3ds_camera_write(Lib3dsCamera *camera, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+
+ c.chunk=LIB3DS_N_CAMERA;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+
+ lib3ds_io_write_vector(io, camera->position);
+ lib3ds_io_write_vector(io, camera->target);
+ lib3ds_io_write_float(io, camera->roll);
+ if (fabs(camera->fov)<LIB3DS_EPSILON) {
+ lib3ds_io_write_float(io, 2400.0f/45.0f);
+ }
+ else {
+ lib3ds_io_write_float(io, 2400.0f/camera->fov);
+ }
+
+ if (camera->see_cone) {
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_CAM_SEE_CONE;
+ c.size=6;
+ lib3ds_chunk_write(&c, io);
+ }
+ {
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_CAM_RANGES;
+ c.size=14;
+ lib3ds_chunk_write(&c, io);
+ lib3ds_io_write_float(io, camera->near_range);
+ lib3ds_io_write_float(io, camera->far_range);
+ }
+
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+
+\typedef Lib3dsCamera
+ \ingroup camera
+ \sa _Lib3dsCamera
+
+*/
--- /dev/null
+/* -*- c -*- */
+#ifndef INCLUDED_LIB3DS_CAMERA_H
+#define INCLUDED_LIB3DS_CAMERA_H
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: camera.h,v 1.8 2004/12/31 16:17:15 reed Exp $
+ */
+
+#ifndef INCLUDED_LIB3DS_TYPES_H
+#include <lib3ds/types.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*!
+ * Camera object
+ * \ingroup camera
+ */
+struct _Lib3dsCamera {
+ Lib3dsCamera *next;
+ char name[64];
+ Lib3dsVector position;
+ Lib3dsVector target;
+ Lib3dsFloat roll;
+ Lib3dsFloat fov;
+ Lib3dsBool see_cone;
+ Lib3dsFloat near_range;
+ Lib3dsFloat far_range;
+};
+
+extern LIB3DSAPI Lib3dsCamera* lib3ds_camera_new(const char *name);
+extern LIB3DSAPI void lib3ds_camera_free(Lib3dsCamera *mesh);
+extern LIB3DSAPI void lib3ds_camera_dump(Lib3dsCamera *camera);
+extern LIB3DSAPI Lib3dsBool lib3ds_camera_read(Lib3dsCamera *camera, Lib3dsIo *io);
+extern LIB3DSAPI Lib3dsBool lib3ds_camera_write(Lib3dsCamera *camera, Lib3dsIo *io);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+
--- /dev/null
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: chunk.c,v 1.14 2001/07/07 19:05:30 jeh Exp $
+ */
+#define LIB3DS_EXPORT
+#include <lib3ds/chunk.h>
+#include <lib3ds/io.h>
+#include <lib3ds/chunktable.h>
+#include <string.h>
+#include <stdarg.h>
+
+
+/*#define LIB3DS_CHUNK_DEBUG*/
+/*#define LIB3DS_CHUNK_WARNING*/
+
+
+/*!
+ * \defgroup chunk Chunk Handling
+ *
+ * \author J.E. Hoffmann <je-h@gmx.net>
+ */
+
+
+static Lib3dsBool enable_dump=LIB3DS_FALSE;
+static Lib3dsBool enable_unknown=LIB3DS_FALSE;
+static char lib3ds_chunk_level[128]="";
+
+
+static void
+lib3ds_chunk_debug_enter(Lib3dsChunk *c)
+{
+ strcat(lib3ds_chunk_level, " ");
+}
+
+
+static void
+lib3ds_chunk_debug_leave(Lib3dsChunk *c)
+{
+ lib3ds_chunk_level[strlen(lib3ds_chunk_level)-2]=0;
+}
+
+
+static void
+lib3ds_chunk_debug_dump(Lib3dsChunk *c)
+{
+ if (enable_dump) {
+ printf("%s%s (0x%X) size=%lu\n",
+ lib3ds_chunk_level,
+ lib3ds_chunk_name(c->chunk),
+ c->chunk,
+ c->size
+ );
+ }
+}
+
+
+/*!
+ * \ingroup chunk
+ */
+void
+lib3ds_chunk_enable_dump(Lib3dsBool enable, Lib3dsBool unknown)
+{
+ enable_dump=enable;
+ enable_unknown=unknown;
+}
+
+
+/*!
+ * \ingroup chunk
+ *
+ * Reads a 3d-Studio chunk header from a little endian file stream.
+ *
+ * \param c The chunk to store the data.
+ * \param f The file stream.
+ *
+ * \return True on success, False otherwise.
+ */
+Lib3dsBool
+lib3ds_chunk_read(Lib3dsChunk *c, Lib3dsIo *io)
+{
+ ASSERT(c);
+ ASSERT(io);
+ c->cur=lib3ds_io_tell(io);
+ c->chunk=lib3ds_io_read_word(io);
+ c->size=lib3ds_io_read_dword(io);
+ c->end=c->cur+c->size;
+ c->cur+=6;
+ if (lib3ds_io_error(io) || (c->size<6)) {
+ return(LIB3DS_FALSE);
+ }
+ return(LIB3DS_TRUE);
+
+}
+
+
+/*!
+ * \ingroup chunk
+ */
+Lib3dsBool
+lib3ds_chunk_read_start(Lib3dsChunk *c, Lib3dsWord chunk, Lib3dsIo *io)
+{
+ ASSERT(c);
+ ASSERT(io);
+ if (!lib3ds_chunk_read(c, io)) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_chunk_debug_enter(c);
+ return((chunk==0) || (c->chunk==chunk));
+}
+
+
+/*!
+ * \ingroup chunk
+ */
+void
+lib3ds_chunk_read_tell(Lib3dsChunk *c, Lib3dsIo *io)
+{
+ c->cur=lib3ds_io_tell(io);
+}
+
+
+/*!
+ * \ingroup chunk
+ */
+Lib3dsWord
+lib3ds_chunk_read_next(Lib3dsChunk *c, Lib3dsIo *io)
+{
+ Lib3dsChunk d;
+
+ if (c->cur>=c->end) {
+ ASSERT(c->cur==c->end);
+ return(0);
+ }
+
+ lib3ds_io_seek(io, (long)c->cur, LIB3DS_SEEK_SET);
+ d.chunk=lib3ds_io_read_word(io);
+ d.size=lib3ds_io_read_dword(io);
+ lib3ds_chunk_debug_dump(&d);
+ c->cur+=d.size;
+ return(d.chunk);
+}
+
+
+/*!
+ * \ingroup chunk
+ */
+void
+lib3ds_chunk_read_reset(Lib3dsChunk *c, Lib3dsIo *io)
+{
+ lib3ds_io_seek(io, -6, LIB3DS_SEEK_CUR);
+}
+
+
+/*!
+ * \ingroup chunk
+ */
+void
+lib3ds_chunk_read_end(Lib3dsChunk *c, Lib3dsIo *io)
+{
+ lib3ds_chunk_debug_leave(c);
+ lib3ds_io_seek(io, c->end, LIB3DS_SEEK_SET);
+}
+
+
+/*!
+ * \ingroup chunk
+ *
+ * Writes a 3d-Studio chunk header into a little endian file stream.
+ *
+ * \param c The chunk to be written.
+ * \param f The file stream.
+ *
+ * \return True on success, False otherwise.
+ */
+Lib3dsBool
+lib3ds_chunk_write(Lib3dsChunk *c, Lib3dsIo *io)
+{
+ ASSERT(c);
+ if (!lib3ds_io_write_word(io, c->chunk)) {
+ LIB3DS_ERROR_LOG;
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_io_write_dword(io, c->size)) {
+ LIB3DS_ERROR_LOG;
+ return(LIB3DS_FALSE);
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup chunk
+ */
+Lib3dsBool
+lib3ds_chunk_write_start(Lib3dsChunk *c, Lib3dsIo *io)
+{
+ ASSERT(c);
+ c->size=0;
+ c->cur=lib3ds_io_tell(io);
+ if (!lib3ds_io_write_word(io, c->chunk)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_io_write_dword(io, c->size)) {
+ return(LIB3DS_FALSE);
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup chunk
+ */
+Lib3dsBool
+lib3ds_chunk_write_end(Lib3dsChunk *c, Lib3dsIo *io)
+{
+ ASSERT(c);
+ c->size=lib3ds_io_tell(io) - c->cur;
+ lib3ds_io_seek(io, c->cur+2, LIB3DS_SEEK_SET);
+ if (!lib3ds_io_write_dword(io, c->size)) {
+ LIB3DS_ERROR_LOG;
+ return(LIB3DS_FALSE);
+ }
+
+ c->cur+=c->size;
+ lib3ds_io_seek(io, c->cur, LIB3DS_SEEK_SET);
+ if (lib3ds_io_error(io)) {
+ LIB3DS_ERROR_LOG;
+ return(LIB3DS_FALSE);
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup chunk
+ */
+const char*
+lib3ds_chunk_name(Lib3dsWord chunk)
+{
+ Lib3dsChunkTable *p;
+
+ for (p=lib3ds_chunk_table; p->name!=0; ++p) {
+ if (p->chunk==chunk) {
+ return(p->name);
+ }
+ }
+ return("***UNKNOWN***");
+}
+
+
+/*!
+ * \ingroup chunk
+ */
+void
+lib3ds_chunk_unknown(Lib3dsWord chunk)
+{
+ if (enable_unknown) {
+ printf("%s***WARNING*** Unknown Chunk: %s (0x%X)\n",
+ lib3ds_chunk_level,
+ lib3ds_chunk_name(chunk),
+ chunk
+ );
+ }
+}
+
+
+/*!
+ * \ingroup chunk
+ */
+void
+lib3ds_chunk_dump_info(const char *format, ...)
+{
+ if (enable_dump) {
+ char s[1024];
+ va_list marker;
+
+ va_start(marker, format);
+ vsprintf(s, format, marker);
+ va_end(marker);
+
+ printf("%s%s\n", lib3ds_chunk_level, s);
+ }
+}
+
+
+
+
+
+
+
--- /dev/null
+/* -*- c -*- */
+#ifndef INCLUDED_LIB3DS_CHUNK_H
+#define INCLUDED_LIB3DS_CHUNK_H
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: chunk.h,v 1.13 2004/12/31 16:17:15 reed Exp $
+ */
+
+#ifndef INCLUDED_LIB3DS_TYPES_H
+#include <lib3ds/types.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum _Lib3dsChunks {
+ LIB3DS_NULL_CHUNK =0x0000,
+ LIB3DS_M3DMAGIC =0x4D4D, /*3DS file*/
+ LIB3DS_SMAGIC =0x2D2D,
+ LIB3DS_LMAGIC =0x2D3D,
+ LIB3DS_MLIBMAGIC =0x3DAA, /*MLI file*/
+ LIB3DS_MATMAGIC =0x3DFF,
+ LIB3DS_CMAGIC =0xC23D, /*PRJ file*/
+ LIB3DS_M3D_VERSION =0x0002,
+ LIB3DS_M3D_KFVERSION =0x0005,
+
+ LIB3DS_COLOR_F =0x0010,
+ LIB3DS_COLOR_24 =0x0011,
+ LIB3DS_LIN_COLOR_24 =0x0012,
+ LIB3DS_LIN_COLOR_F =0x0013,
+ LIB3DS_INT_PERCENTAGE =0x0030,
+ LIB3DS_FLOAT_PERCENTAGE =0x0031,
+
+ LIB3DS_MDATA =0x3D3D,
+ LIB3DS_MESH_VERSION =0x3D3E,
+ LIB3DS_MASTER_SCALE =0x0100,
+ LIB3DS_LO_SHADOW_BIAS =0x1400,
+ LIB3DS_HI_SHADOW_BIAS =0x1410,
+ LIB3DS_SHADOW_MAP_SIZE =0x1420,
+ LIB3DS_SHADOW_SAMPLES =0x1430,
+ LIB3DS_SHADOW_RANGE =0x1440,
+ LIB3DS_SHADOW_FILTER =0x1450,
+ LIB3DS_RAY_BIAS =0x1460,
+ LIB3DS_O_CONSTS =0x1500,
+ LIB3DS_AMBIENT_LIGHT =0x2100,
+ LIB3DS_BIT_MAP =0x1100,
+ LIB3DS_SOLID_BGND =0x1200,
+ LIB3DS_V_GRADIENT =0x1300,
+ LIB3DS_USE_BIT_MAP =0x1101,
+ LIB3DS_USE_SOLID_BGND =0x1201,
+ LIB3DS_USE_V_GRADIENT =0x1301,
+ LIB3DS_FOG =0x2200,
+ LIB3DS_FOG_BGND =0x2210,
+ LIB3DS_LAYER_FOG =0x2302,
+ LIB3DS_DISTANCE_CUE =0x2300,
+ LIB3DS_DCUE_BGND =0x2310,
+ LIB3DS_USE_FOG =0x2201,
+ LIB3DS_USE_LAYER_FOG =0x2303,
+ LIB3DS_USE_DISTANCE_CUE =0x2301,
+
+ LIB3DS_MAT_ENTRY =0xAFFF,
+ LIB3DS_MAT_NAME =0xA000,
+ LIB3DS_MAT_AMBIENT =0xA010,
+ LIB3DS_MAT_DIFFUSE =0xA020,
+ LIB3DS_MAT_SPECULAR =0xA030,
+ LIB3DS_MAT_SHININESS =0xA040,
+ LIB3DS_MAT_SHIN2PCT =0xA041,
+ LIB3DS_MAT_TRANSPARENCY =0xA050,
+ LIB3DS_MAT_XPFALL =0xA052,
+ LIB3DS_MAT_USE_XPFALL =0xA240,
+ LIB3DS_MAT_REFBLUR =0xA053,
+ LIB3DS_MAT_SHADING =0xA100,
+ LIB3DS_MAT_USE_REFBLUR =0xA250,
+ LIB3DS_MAT_SELF_ILLUM =0xA080,
+ LIB3DS_MAT_TWO_SIDE =0xA081,
+ LIB3DS_MAT_DECAL =0xA082,
+ LIB3DS_MAT_ADDITIVE =0xA083,
+ LIB3DS_MAT_SELF_ILPCT =0xA084,
+ LIB3DS_MAT_WIRE =0xA085,
+ LIB3DS_MAT_FACEMAP =0xA088,
+ LIB3DS_MAT_PHONGSOFT =0xA08C,
+ LIB3DS_MAT_WIREABS =0xA08E,
+ LIB3DS_MAT_WIRE_SIZE =0xA087,
+ LIB3DS_MAT_TEXMAP =0xA200,
+ LIB3DS_MAT_SXP_TEXT_DATA =0xA320,
+ LIB3DS_MAT_TEXMASK =0xA33E,
+ LIB3DS_MAT_SXP_TEXTMASK_DATA =0xA32A,
+ LIB3DS_MAT_TEX2MAP =0xA33A,
+ LIB3DS_MAT_SXP_TEXT2_DATA =0xA321,
+ LIB3DS_MAT_TEX2MASK =0xA340,
+ LIB3DS_MAT_SXP_TEXT2MASK_DATA =0xA32C,
+ LIB3DS_MAT_OPACMAP =0xA210,
+ LIB3DS_MAT_SXP_OPAC_DATA =0xA322,
+ LIB3DS_MAT_OPACMASK =0xA342,
+ LIB3DS_MAT_SXP_OPACMASK_DATA =0xA32E,
+ LIB3DS_MAT_BUMPMAP =0xA230,
+ LIB3DS_MAT_SXP_BUMP_DATA =0xA324,
+ LIB3DS_MAT_BUMPMASK =0xA344,
+ LIB3DS_MAT_SXP_BUMPMASK_DATA =0xA330,
+ LIB3DS_MAT_SPECMAP =0xA204,
+ LIB3DS_MAT_SXP_SPEC_DATA =0xA325,
+ LIB3DS_MAT_SPECMASK =0xA348,
+ LIB3DS_MAT_SXP_SPECMASK_DATA =0xA332,
+ LIB3DS_MAT_SHINMAP =0xA33C,
+ LIB3DS_MAT_SXP_SHIN_DATA =0xA326,
+ LIB3DS_MAT_SHINMASK =0xA346,
+ LIB3DS_MAT_SXP_SHINMASK_DATA =0xA334,
+ LIB3DS_MAT_SELFIMAP =0xA33D,
+ LIB3DS_MAT_SXP_SELFI_DATA =0xA328,
+ LIB3DS_MAT_SELFIMASK =0xA34A,
+ LIB3DS_MAT_SXP_SELFIMASK_DATA =0xA336,
+ LIB3DS_MAT_REFLMAP =0xA220,
+ LIB3DS_MAT_REFLMASK =0xA34C,
+ LIB3DS_MAT_SXP_REFLMASK_DATA =0xA338,
+ LIB3DS_MAT_ACUBIC =0xA310,
+ LIB3DS_MAT_MAPNAME =0xA300,
+ LIB3DS_MAT_MAP_TILING =0xA351,
+ LIB3DS_MAT_MAP_TEXBLUR =0xA353,
+ LIB3DS_MAT_MAP_USCALE =0xA354,
+ LIB3DS_MAT_MAP_VSCALE =0xA356,
+ LIB3DS_MAT_MAP_UOFFSET =0xA358,
+ LIB3DS_MAT_MAP_VOFFSET =0xA35A,
+ LIB3DS_MAT_MAP_ANG =0xA35C,
+ LIB3DS_MAT_MAP_COL1 =0xA360,
+ LIB3DS_MAT_MAP_COL2 =0xA362,
+ LIB3DS_MAT_MAP_RCOL =0xA364,
+ LIB3DS_MAT_MAP_GCOL =0xA366,
+ LIB3DS_MAT_MAP_BCOL =0xA368,
+
+ LIB3DS_NAMED_OBJECT =0x4000,
+ LIB3DS_N_DIRECT_LIGHT =0x4600,
+ LIB3DS_DL_OFF =0x4620,
+ LIB3DS_DL_OUTER_RANGE =0x465A,
+ LIB3DS_DL_INNER_RANGE =0x4659,
+ LIB3DS_DL_MULTIPLIER =0x465B,
+ LIB3DS_DL_EXCLUDE =0x4654,
+ LIB3DS_DL_ATTENUATE =0x4625,
+ LIB3DS_DL_SPOTLIGHT =0x4610,
+ LIB3DS_DL_SPOT_ROLL =0x4656,
+ LIB3DS_DL_SHADOWED =0x4630,
+ LIB3DS_DL_LOCAL_SHADOW2 =0x4641,
+ LIB3DS_DL_SEE_CONE =0x4650,
+ LIB3DS_DL_SPOT_RECTANGULAR =0x4651,
+ LIB3DS_DL_SPOT_ASPECT =0x4657,
+ LIB3DS_DL_SPOT_PROJECTOR =0x4653,
+ LIB3DS_DL_SPOT_OVERSHOOT =0x4652,
+ LIB3DS_DL_RAY_BIAS =0x4658,
+ LIB3DS_DL_RAYSHAD =0x4627,
+ LIB3DS_N_CAMERA =0x4700,
+ LIB3DS_CAM_SEE_CONE =0x4710,
+ LIB3DS_CAM_RANGES =0x4720,
+ LIB3DS_OBJ_HIDDEN =0x4010,
+ LIB3DS_OBJ_VIS_LOFTER =0x4011,
+ LIB3DS_OBJ_DOESNT_CAST =0x4012,
+ LIB3DS_OBJ_DONT_RECVSHADOW =0x4017,
+ LIB3DS_OBJ_MATTE =0x4013,
+ LIB3DS_OBJ_FAST =0x4014,
+ LIB3DS_OBJ_PROCEDURAL =0x4015,
+ LIB3DS_OBJ_FROZEN =0x4016,
+ LIB3DS_N_TRI_OBJECT =0x4100,
+ LIB3DS_POINT_ARRAY =0x4110,
+ LIB3DS_POINT_FLAG_ARRAY =0x4111,
+ LIB3DS_FACE_ARRAY =0x4120,
+ LIB3DS_MSH_MAT_GROUP =0x4130,
+ LIB3DS_SMOOTH_GROUP =0x4150,
+ LIB3DS_MSH_BOXMAP =0x4190,
+ LIB3DS_TEX_VERTS =0x4140,
+ LIB3DS_MESH_MATRIX =0x4160,
+ LIB3DS_MESH_COLOR =0x4165,
+ LIB3DS_MESH_TEXTURE_INFO =0x4170,
+
+ LIB3DS_KFDATA =0xB000,
+ LIB3DS_KFHDR =0xB00A,
+ LIB3DS_KFSEG =0xB008,
+ LIB3DS_KFCURTIME =0xB009,
+ LIB3DS_AMBIENT_NODE_TAG =0xB001,
+ LIB3DS_OBJECT_NODE_TAG =0xB002,
+ LIB3DS_CAMERA_NODE_TAG =0xB003,
+ LIB3DS_TARGET_NODE_TAG =0xB004,
+ LIB3DS_LIGHT_NODE_TAG =0xB005,
+ LIB3DS_L_TARGET_NODE_TAG =0xB006,
+ LIB3DS_SPOTLIGHT_NODE_TAG =0xB007,
+ LIB3DS_NODE_ID =0xB030,
+ LIB3DS_NODE_HDR =0xB010,
+ LIB3DS_PIVOT =0xB013,
+ LIB3DS_INSTANCE_NAME =0xB011,
+ LIB3DS_MORPH_SMOOTH =0xB015,
+ LIB3DS_BOUNDBOX =0xB014,
+ LIB3DS_POS_TRACK_TAG =0xB020,
+ LIB3DS_COL_TRACK_TAG =0xB025,
+ LIB3DS_ROT_TRACK_TAG =0xB021,
+ LIB3DS_SCL_TRACK_TAG =0xB022,
+ LIB3DS_MORPH_TRACK_TAG =0xB026,
+ LIB3DS_FOV_TRACK_TAG =0xB023,
+ LIB3DS_ROLL_TRACK_TAG =0xB024,
+ LIB3DS_HOT_TRACK_TAG =0xB027,
+ LIB3DS_FALL_TRACK_TAG =0xB028,
+ LIB3DS_HIDE_TRACK_TAG =0xB029,
+
+ LIB3DS_POLY_2D = 0x5000,
+ LIB3DS_SHAPE_OK = 0x5010,
+ LIB3DS_SHAPE_NOT_OK = 0x5011,
+ LIB3DS_SHAPE_HOOK = 0x5020,
+ LIB3DS_PATH_3D = 0x6000,
+ LIB3DS_PATH_MATRIX = 0x6005,
+ LIB3DS_SHAPE_2D = 0x6010,
+ LIB3DS_M_SCALE = 0x6020,
+ LIB3DS_M_TWIST = 0x6030,
+ LIB3DS_M_TEETER = 0x6040,
+ LIB3DS_M_FIT = 0x6050,
+ LIB3DS_M_BEVEL = 0x6060,
+ LIB3DS_XZ_CURVE = 0x6070,
+ LIB3DS_YZ_CURVE = 0x6080,
+ LIB3DS_INTERPCT = 0x6090,
+ LIB3DS_DEFORM_LIMIT = 0x60A0,
+
+ LIB3DS_USE_CONTOUR = 0x6100,
+ LIB3DS_USE_TWEEN = 0x6110,
+ LIB3DS_USE_SCALE = 0x6120,
+ LIB3DS_USE_TWIST = 0x6130,
+ LIB3DS_USE_TEETER = 0x6140,
+ LIB3DS_USE_FIT = 0x6150,
+ LIB3DS_USE_BEVEL = 0x6160,
+
+ LIB3DS_DEFAULT_VIEW = 0x3000,
+ LIB3DS_VIEW_TOP = 0x3010,
+ LIB3DS_VIEW_BOTTOM = 0x3020,
+ LIB3DS_VIEW_LEFT = 0x3030,
+ LIB3DS_VIEW_RIGHT = 0x3040,
+ LIB3DS_VIEW_FRONT = 0x3050,
+ LIB3DS_VIEW_BACK = 0x3060,
+ LIB3DS_VIEW_USER = 0x3070,
+ LIB3DS_VIEW_CAMERA = 0x3080,
+ LIB3DS_VIEW_WINDOW = 0x3090,
+
+ LIB3DS_VIEWPORT_LAYOUT_OLD = 0x7000,
+ LIB3DS_VIEWPORT_DATA_OLD = 0x7010,
+ LIB3DS_VIEWPORT_LAYOUT = 0x7001,
+ LIB3DS_VIEWPORT_DATA = 0x7011,
+ LIB3DS_VIEWPORT_DATA_3 = 0x7012,
+ LIB3DS_VIEWPORT_SIZE = 0x7020,
+ LIB3DS_NETWORK_VIEW = 0x7030
+} Lib3dsChunks;
+
+typedef struct _Lib3dsChunk {
+ Lib3dsWord chunk;
+ Lib3dsDword size;
+ Lib3dsDword end;
+ Lib3dsDword cur;
+} Lib3dsChunk;
+
+extern LIB3DSAPI void lib3ds_chunk_enable_dump(Lib3dsBool enable, Lib3dsBool unknown);
+extern LIB3DSAPI Lib3dsBool lib3ds_chunk_read(Lib3dsChunk *c, Lib3dsIo *io);
+extern LIB3DSAPI Lib3dsBool lib3ds_chunk_read_start(Lib3dsChunk *c, Lib3dsWord chunk, Lib3dsIo *io);
+extern LIB3DSAPI void lib3ds_chunk_read_tell(Lib3dsChunk *c, Lib3dsIo *io);
+extern LIB3DSAPI Lib3dsWord lib3ds_chunk_read_next(Lib3dsChunk *c, Lib3dsIo *io);
+extern LIB3DSAPI void lib3ds_chunk_read_reset(Lib3dsChunk *c, Lib3dsIo *io);
+extern LIB3DSAPI void lib3ds_chunk_read_end(Lib3dsChunk *c, Lib3dsIo *io);
+extern LIB3DSAPI Lib3dsBool lib3ds_chunk_write(Lib3dsChunk *c, Lib3dsIo *io);
+extern LIB3DSAPI Lib3dsBool lib3ds_chunk_write_start(Lib3dsChunk *c, Lib3dsIo *io);
+extern LIB3DSAPI Lib3dsBool lib3ds_chunk_write_end(Lib3dsChunk *c, Lib3dsIo *io);
+extern LIB3DSAPI const char* lib3ds_chunk_name(Lib3dsWord chunk);
+extern LIB3DSAPI void lib3ds_chunk_unknown(Lib3dsWord chunk);
+extern LIB3DSAPI void lib3ds_chunk_dump_info(const char *format, ...);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+
--- /dev/null
+/* -*- c -*- */
+#ifndef INCLUDED_LIB3DS_CHUNKTABLE_H
+#define INCLUDED_LIB3DS_CHUNKTABLE_H
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: chunktable.h,v 1.13 2004/12/31 16:17:15 reed Exp $
+ */
+
+#ifndef INCLUDED_LIB3DS_CHUNK_H
+#include <lib3ds/chunk.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct _Lib3dsChunkTable {
+ Lib3dsDword chunk;
+ const char* name;
+} Lib3dsChunkTable;
+
+static Lib3dsChunkTable lib3ds_chunk_table[]={
+ {LIB3DS_NULL_CHUNK, "LIB3DS_NULL_CHUNK"},
+ {LIB3DS_M3DMAGIC, "LIB3DS_M3DMAGIC"},
+ {LIB3DS_SMAGIC, "LIB3DS_SMAGIC"},
+ {LIB3DS_LMAGIC, "LIB3DS_LMAGIC"},
+ {LIB3DS_MLIBMAGIC, "LIB3DS_MLIBMAGIC"},
+ {LIB3DS_MATMAGIC, "LIB3DS_MATMAGIC"},
+ {LIB3DS_CMAGIC, "LIB3DS_CMAGIC"},
+ {LIB3DS_M3D_VERSION, "LIB3DS_M3D_VERSION"},
+ {LIB3DS_M3D_KFVERSION, "LIB3DS_M3D_KFVERSION"},
+ {LIB3DS_COLOR_F, "LIB3DS_COLOR_F"},
+ {LIB3DS_COLOR_24, "LIB3DS_COLOR_24"},
+ {LIB3DS_LIN_COLOR_24, "LIB3DS_LIN_COLOR_24"},
+ {LIB3DS_LIN_COLOR_F, "LIB3DS_LIN_COLOR_F"},
+ {LIB3DS_INT_PERCENTAGE, "LIB3DS_INT_PERCENTAGE"},
+ {LIB3DS_FLOAT_PERCENTAGE, "LIB3DS_FLOAT_PERCENTAGE"},
+ {LIB3DS_MDATA, "LIB3DS_MDATA"},
+ {LIB3DS_MESH_VERSION, "LIB3DS_MESH_VERSION"},
+ {LIB3DS_MASTER_SCALE, "LIB3DS_MASTER_SCALE"},
+ {LIB3DS_LO_SHADOW_BIAS, "LIB3DS_LO_SHADOW_BIAS"},
+ {LIB3DS_HI_SHADOW_BIAS, "LIB3DS_HI_SHADOW_BIAS"},
+ {LIB3DS_SHADOW_MAP_SIZE, "LIB3DS_SHADOW_MAP_SIZE"},
+ {LIB3DS_SHADOW_SAMPLES, "LIB3DS_SHADOW_SAMPLES"},
+ {LIB3DS_SHADOW_RANGE, "LIB3DS_SHADOW_RANGE"},
+ {LIB3DS_SHADOW_FILTER, "LIB3DS_SHADOW_FILTER"},
+ {LIB3DS_RAY_BIAS, "LIB3DS_RAY_BIAS"},
+ {LIB3DS_O_CONSTS, "LIB3DS_O_CONSTS"},
+ {LIB3DS_AMBIENT_LIGHT, "LIB3DS_AMBIENT_LIGHT"},
+ {LIB3DS_BIT_MAP, "LIB3DS_BIT_MAP"},
+ {LIB3DS_SOLID_BGND, "LIB3DS_SOLID_BGND"},
+ {LIB3DS_V_GRADIENT, "LIB3DS_V_GRADIENT"},
+ {LIB3DS_USE_BIT_MAP, "LIB3DS_USE_BIT_MAP"},
+ {LIB3DS_USE_SOLID_BGND, "LIB3DS_USE_SOLID_BGND"},
+ {LIB3DS_USE_V_GRADIENT, "LIB3DS_USE_V_GRADIENT"},
+ {LIB3DS_FOG, "LIB3DS_FOG"},
+ {LIB3DS_FOG_BGND, "LIB3DS_FOG_BGND"},
+ {LIB3DS_LAYER_FOG, "LIB3DS_LAYER_FOG"},
+ {LIB3DS_DISTANCE_CUE, "LIB3DS_DISTANCE_CUE"},
+ {LIB3DS_DCUE_BGND, "LIB3DS_DCUE_BGND"},
+ {LIB3DS_USE_FOG, "LIB3DS_USE_FOG"},
+ {LIB3DS_USE_LAYER_FOG, "LIB3DS_USE_LAYER_FOG"},
+ {LIB3DS_USE_DISTANCE_CUE, "LIB3DS_USE_DISTANCE_CUE"},
+ {LIB3DS_MAT_ENTRY, "LIB3DS_MAT_ENTRY"},
+ {LIB3DS_MAT_NAME, "LIB3DS_MAT_NAME"},
+ {LIB3DS_MAT_AMBIENT, "LIB3DS_MAT_AMBIENT"},
+ {LIB3DS_MAT_DIFFUSE, "LIB3DS_MAT_DIFFUSE"},
+ {LIB3DS_MAT_SPECULAR, "LIB3DS_MAT_SPECULAR"},
+ {LIB3DS_MAT_SHININESS, "LIB3DS_MAT_SHININESS"},
+ {LIB3DS_MAT_SHIN2PCT, "LIB3DS_MAT_SHIN2PCT"},
+ {LIB3DS_MAT_TRANSPARENCY, "LIB3DS_MAT_TRANSPARENCY"},
+ {LIB3DS_MAT_XPFALL, "LIB3DS_MAT_XPFALL"},
+ {LIB3DS_MAT_USE_XPFALL, "LIB3DS_MAT_USE_XPFALL"},
+ {LIB3DS_MAT_REFBLUR, "LIB3DS_MAT_REFBLUR"},
+ {LIB3DS_MAT_SHADING, "LIB3DS_MAT_SHADING"},
+ {LIB3DS_MAT_USE_REFBLUR, "LIB3DS_MAT_USE_REFBLUR"},
+ {LIB3DS_MAT_SELF_ILLUM, "LIB3DS_MAT_SELF_ILLUM"},
+ {LIB3DS_MAT_TWO_SIDE, "LIB3DS_MAT_TWO_SIDE"},
+ {LIB3DS_MAT_DECAL, "LIB3DS_MAT_DECAL"},
+ {LIB3DS_MAT_ADDITIVE, "LIB3DS_MAT_ADDITIVE"},
+ {LIB3DS_MAT_SELF_ILPCT, "LIB3DS_MAT_SELF_ILPCT"},
+ {LIB3DS_MAT_WIRE, "LIB3DS_MAT_WIRE"},
+ {LIB3DS_MAT_FACEMAP, "LIB3DS_MAT_FACEMAP"},
+ {LIB3DS_MAT_PHONGSOFT, "LIB3DS_MAT_PHONGSOFT"},
+ {LIB3DS_MAT_WIREABS, "LIB3DS_MAT_WIREABS"},
+ {LIB3DS_MAT_WIRE_SIZE, "LIB3DS_MAT_WIRE_SIZE"},
+ {LIB3DS_MAT_TEXMAP, "LIB3DS_MAT_TEXMAP"},
+ {LIB3DS_MAT_SXP_TEXT_DATA, "LIB3DS_MAT_SXP_TEXT_DATA"},
+ {LIB3DS_MAT_TEXMASK, "LIB3DS_MAT_TEXMASK"},
+ {LIB3DS_MAT_SXP_TEXTMASK_DATA, "LIB3DS_MAT_SXP_TEXTMASK_DATA"},
+ {LIB3DS_MAT_TEX2MAP, "LIB3DS_MAT_TEX2MAP"},
+ {LIB3DS_MAT_SXP_TEXT2_DATA, "LIB3DS_MAT_SXP_TEXT2_DATA"},
+ {LIB3DS_MAT_TEX2MASK, "LIB3DS_MAT_TEX2MASK"},
+ {LIB3DS_MAT_SXP_TEXT2MASK_DATA, "LIB3DS_MAT_SXP_TEXT2MASK_DATA"},
+ {LIB3DS_MAT_OPACMAP, "LIB3DS_MAT_OPACMAP"},
+ {LIB3DS_MAT_SXP_OPAC_DATA, "LIB3DS_MAT_SXP_OPAC_DATA"},
+ {LIB3DS_MAT_OPACMASK, "LIB3DS_MAT_OPACMASK"},
+ {LIB3DS_MAT_SXP_OPACMASK_DATA, "LIB3DS_MAT_SXP_OPACMASK_DATA"},
+ {LIB3DS_MAT_BUMPMAP, "LIB3DS_MAT_BUMPMAP"},
+ {LIB3DS_MAT_SXP_BUMP_DATA, "LIB3DS_MAT_SXP_BUMP_DATA"},
+ {LIB3DS_MAT_BUMPMASK, "LIB3DS_MAT_BUMPMASK"},
+ {LIB3DS_MAT_SXP_BUMPMASK_DATA, "LIB3DS_MAT_SXP_BUMPMASK_DATA"},
+ {LIB3DS_MAT_SPECMAP, "LIB3DS_MAT_SPECMAP"},
+ {LIB3DS_MAT_SXP_SPEC_DATA, "LIB3DS_MAT_SXP_SPEC_DATA"},
+ {LIB3DS_MAT_SPECMASK, "LIB3DS_MAT_SPECMASK"},
+ {LIB3DS_MAT_SXP_SPECMASK_DATA, "LIB3DS_MAT_SXP_SPECMASK_DATA"},
+ {LIB3DS_MAT_SHINMAP, "LIB3DS_MAT_SHINMAP"},
+ {LIB3DS_MAT_SXP_SHIN_DATA, "LIB3DS_MAT_SXP_SHIN_DATA"},
+ {LIB3DS_MAT_SHINMASK, "LIB3DS_MAT_SHINMASK"},
+ {LIB3DS_MAT_SXP_SHINMASK_DATA, "LIB3DS_MAT_SXP_SHINMASK_DATA"},
+ {LIB3DS_MAT_SELFIMAP, "LIB3DS_MAT_SELFIMAP"},
+ {LIB3DS_MAT_SXP_SELFI_DATA, "LIB3DS_MAT_SXP_SELFI_DATA"},
+ {LIB3DS_MAT_SELFIMASK, "LIB3DS_MAT_SELFIMASK"},
+ {LIB3DS_MAT_SXP_SELFIMASK_DATA, "LIB3DS_MAT_SXP_SELFIMASK_DATA"},
+ {LIB3DS_MAT_REFLMAP, "LIB3DS_MAT_REFLMAP"},
+ {LIB3DS_MAT_REFLMASK, "LIB3DS_MAT_REFLMASK"},
+ {LIB3DS_MAT_SXP_REFLMASK_DATA, "LIB3DS_MAT_SXP_REFLMASK_DATA"},
+ {LIB3DS_MAT_ACUBIC, "LIB3DS_MAT_ACUBIC"},
+ {LIB3DS_MAT_MAPNAME, "LIB3DS_MAT_MAPNAME"},
+ {LIB3DS_MAT_MAP_TILING, "LIB3DS_MAT_MAP_TILING"},
+ {LIB3DS_MAT_MAP_TEXBLUR, "LIB3DS_MAT_MAP_TEXBLUR"},
+ {LIB3DS_MAT_MAP_USCALE, "LIB3DS_MAT_MAP_USCALE"},
+ {LIB3DS_MAT_MAP_VSCALE, "LIB3DS_MAT_MAP_VSCALE"},
+ {LIB3DS_MAT_MAP_UOFFSET, "LIB3DS_MAT_MAP_UOFFSET"},
+ {LIB3DS_MAT_MAP_VOFFSET, "LIB3DS_MAT_MAP_VOFFSET"},
+ {LIB3DS_MAT_MAP_ANG, "LIB3DS_MAT_MAP_ANG"},
+ {LIB3DS_MAT_MAP_COL1, "LIB3DS_MAT_MAP_COL1"},
+ {LIB3DS_MAT_MAP_COL2, "LIB3DS_MAT_MAP_COL2"},
+ {LIB3DS_MAT_MAP_RCOL, "LIB3DS_MAT_MAP_RCOL"},
+ {LIB3DS_MAT_MAP_GCOL, "LIB3DS_MAT_MAP_GCOL"},
+ {LIB3DS_MAT_MAP_BCOL, "LIB3DS_MAT_MAP_BCOL"},
+ {LIB3DS_NAMED_OBJECT, "LIB3DS_NAMED_OBJECT"},
+ {LIB3DS_N_DIRECT_LIGHT, "LIB3DS_N_DIRECT_LIGHT"},
+ {LIB3DS_DL_OFF, "LIB3DS_DL_OFF"},
+ {LIB3DS_DL_OUTER_RANGE, "LIB3DS_DL_OUTER_RANGE"},
+ {LIB3DS_DL_INNER_RANGE, "LIB3DS_DL_INNER_RANGE"},
+ {LIB3DS_DL_MULTIPLIER, "LIB3DS_DL_MULTIPLIER"},
+ {LIB3DS_DL_EXCLUDE, "LIB3DS_DL_EXCLUDE"},
+ {LIB3DS_DL_ATTENUATE, "LIB3DS_DL_ATTENUATE"},
+ {LIB3DS_DL_SPOTLIGHT, "LIB3DS_DL_SPOTLIGHT"},
+ {LIB3DS_DL_SPOT_ROLL, "LIB3DS_DL_SPOT_ROLL"},
+ {LIB3DS_DL_SHADOWED, "LIB3DS_DL_SHADOWED"},
+ {LIB3DS_DL_LOCAL_SHADOW2, "LIB3DS_DL_LOCAL_SHADOW2"},
+ {LIB3DS_DL_SEE_CONE, "LIB3DS_DL_SEE_CONE"},
+ {LIB3DS_DL_SPOT_RECTANGULAR, "LIB3DS_DL_SPOT_RECTANGULAR"},
+ {LIB3DS_DL_SPOT_ASPECT, "LIB3DS_DL_SPOT_ASPECT"},
+ {LIB3DS_DL_SPOT_PROJECTOR, "LIB3DS_DL_SPOT_PROJECTOR"},
+ {LIB3DS_DL_SPOT_OVERSHOOT, "LIB3DS_DL_SPOT_OVERSHOOT"},
+ {LIB3DS_DL_RAY_BIAS, "LIB3DS_DL_RAY_BIAS"},
+ {LIB3DS_DL_RAYSHAD, "LIB3DS_DL_RAYSHAD"},
+ {LIB3DS_N_CAMERA, "LIB3DS_N_CAMERA"},
+ {LIB3DS_CAM_SEE_CONE, "LIB3DS_CAM_SEE_CONE"},
+ {LIB3DS_CAM_RANGES, "LIB3DS_CAM_RANGES"},
+ {LIB3DS_OBJ_HIDDEN, "LIB3DS_OBJ_HIDDEN"},
+ {LIB3DS_OBJ_VIS_LOFTER, "LIB3DS_OBJ_VIS_LOFTER"},
+ {LIB3DS_OBJ_DOESNT_CAST, "LIB3DS_OBJ_DOESNT_CAST"},
+ {LIB3DS_OBJ_DONT_RECVSHADOW, "LIB3DS_OBJ_DONT_RECVSHADOW"},
+ {LIB3DS_OBJ_MATTE, "LIB3DS_OBJ_MATTE"},
+ {LIB3DS_OBJ_FAST, "LIB3DS_OBJ_FAST"},
+ {LIB3DS_OBJ_PROCEDURAL, "LIB3DS_OBJ_PROCEDURAL"},
+ {LIB3DS_OBJ_FROZEN, "LIB3DS_OBJ_FROZEN"},
+ {LIB3DS_N_TRI_OBJECT, "LIB3DS_N_TRI_OBJECT"},
+ {LIB3DS_POINT_ARRAY, "LIB3DS_POINT_ARRAY"},
+ {LIB3DS_POINT_FLAG_ARRAY, "LIB3DS_POINT_FLAG_ARRAY"},
+ {LIB3DS_FACE_ARRAY, "LIB3DS_FACE_ARRAY"},
+ {LIB3DS_MSH_MAT_GROUP, "LIB3DS_MSH_MAT_GROUP"},
+ {LIB3DS_SMOOTH_GROUP, "LIB3DS_SMOOTH_GROUP"},
+ {LIB3DS_MSH_BOXMAP, "LIB3DS_MSH_BOXMAP"},
+ {LIB3DS_TEX_VERTS, "LIB3DS_TEX_VERTS"},
+ {LIB3DS_MESH_MATRIX, "LIB3DS_MESH_MATRIX"},
+ {LIB3DS_MESH_COLOR, "LIB3DS_MESH_COLOR"},
+ {LIB3DS_MESH_TEXTURE_INFO, "LIB3DS_MESH_TEXTURE_INFO"},
+ {LIB3DS_KFDATA, "LIB3DS_KFDATA"},
+ {LIB3DS_KFHDR, "LIB3DS_KFHDR"},
+ {LIB3DS_KFSEG, "LIB3DS_KFSEG"},
+ {LIB3DS_KFCURTIME, "LIB3DS_KFCURTIME"},
+ {LIB3DS_AMBIENT_NODE_TAG, "LIB3DS_AMBIENT_NODE_TAG"},
+ {LIB3DS_OBJECT_NODE_TAG, "LIB3DS_OBJECT_NODE_TAG"},
+ {LIB3DS_CAMERA_NODE_TAG, "LIB3DS_CAMERA_NODE_TAG"},
+ {LIB3DS_TARGET_NODE_TAG, "LIB3DS_TARGET_NODE_TAG"},
+ {LIB3DS_LIGHT_NODE_TAG, "LIB3DS_LIGHT_NODE_TAG"},
+ {LIB3DS_L_TARGET_NODE_TAG, "LIB3DS_L_TARGET_NODE_TAG"},
+ {LIB3DS_SPOTLIGHT_NODE_TAG, "LIB3DS_SPOTLIGHT_NODE_TAG"},
+ {LIB3DS_NODE_ID, "LIB3DS_NODE_ID"},
+ {LIB3DS_NODE_HDR, "LIB3DS_NODE_HDR"},
+ {LIB3DS_PIVOT, "LIB3DS_PIVOT"},
+ {LIB3DS_INSTANCE_NAME, "LIB3DS_INSTANCE_NAME"},
+ {LIB3DS_MORPH_SMOOTH, "LIB3DS_MORPH_SMOOTH"},
+ {LIB3DS_BOUNDBOX, "LIB3DS_BOUNDBOX"},
+ {LIB3DS_POS_TRACK_TAG, "LIB3DS_POS_TRACK_TAG"},
+ {LIB3DS_COL_TRACK_TAG, "LIB3DS_COL_TRACK_TAG"},
+ {LIB3DS_ROT_TRACK_TAG, "LIB3DS_ROT_TRACK_TAG"},
+ {LIB3DS_SCL_TRACK_TAG, "LIB3DS_SCL_TRACK_TAG"},
+ {LIB3DS_MORPH_TRACK_TAG, "LIB3DS_MORPH_TRACK_TAG"},
+ {LIB3DS_FOV_TRACK_TAG, "LIB3DS_FOV_TRACK_TAG"},
+ {LIB3DS_ROLL_TRACK_TAG, "LIB3DS_ROLL_TRACK_TAG"},
+ {LIB3DS_HOT_TRACK_TAG, "LIB3DS_HOT_TRACK_TAG"},
+ {LIB3DS_FALL_TRACK_TAG, "LIB3DS_FALL_TRACK_TAG"},
+ {LIB3DS_HIDE_TRACK_TAG, "LIB3DS_HIDE_TRACK_TAG"},
+ {LIB3DS_POLY_2D, "LIB3DS_POLY_2D"},
+ {LIB3DS_SHAPE_OK, "LIB3DS_SHAPE_OK"},
+ {LIB3DS_SHAPE_NOT_OK, "LIB3DS_SHAPE_NOT_OK"},
+ {LIB3DS_SHAPE_HOOK, "LIB3DS_SHAPE_HOOK"},
+ {LIB3DS_PATH_3D, "LIB3DS_PATH_3D"},
+ {LIB3DS_PATH_MATRIX, "LIB3DS_PATH_MATRIX"},
+ {LIB3DS_SHAPE_2D, "LIB3DS_SHAPE_2D"},
+ {LIB3DS_M_SCALE, "LIB3DS_M_SCALE"},
+ {LIB3DS_M_TWIST, "LIB3DS_M_TWIST"},
+ {LIB3DS_M_TEETER, "LIB3DS_M_TEETER"},
+ {LIB3DS_M_FIT, "LIB3DS_M_FIT"},
+ {LIB3DS_M_BEVEL, "LIB3DS_M_BEVEL"},
+ {LIB3DS_XZ_CURVE, "LIB3DS_XZ_CURVE"},
+ {LIB3DS_YZ_CURVE, "LIB3DS_YZ_CURVE"},
+ {LIB3DS_INTERPCT, "LIB3DS_INTERPCT"},
+ {LIB3DS_DEFORM_LIMIT, "LIB3DS_DEFORM_LIMIT"},
+ {LIB3DS_USE_CONTOUR, "LIB3DS_USE_CONTOUR"},
+ {LIB3DS_USE_TWEEN, "LIB3DS_USE_TWEEN"},
+ {LIB3DS_USE_SCALE, "LIB3DS_USE_SCALE"},
+ {LIB3DS_USE_TWIST, "LIB3DS_USE_TWIST"},
+ {LIB3DS_USE_TEETER, "LIB3DS_USE_TEETER"},
+ {LIB3DS_USE_FIT, "LIB3DS_USE_FIT"},
+ {LIB3DS_USE_BEVEL, "LIB3DS_USE_BEVEL"},
+ {LIB3DS_DEFAULT_VIEW, "LIB3DS_DEFAULT_VIEW"},
+ {LIB3DS_VIEW_TOP, "LIB3DS_VIEW_TOP"},
+ {LIB3DS_VIEW_BOTTOM, "LIB3DS_VIEW_BOTTOM"},
+ {LIB3DS_VIEW_LEFT, "LIB3DS_VIEW_LEFT"},
+ {LIB3DS_VIEW_RIGHT, "LIB3DS_VIEW_RIGHT"},
+ {LIB3DS_VIEW_FRONT, "LIB3DS_VIEW_FRONT"},
+ {LIB3DS_VIEW_BACK, "LIB3DS_VIEW_BACK"},
+ {LIB3DS_VIEW_USER, "LIB3DS_VIEW_USER"},
+ {LIB3DS_VIEW_CAMERA, "LIB3DS_VIEW_CAMERA"},
+ {LIB3DS_VIEW_WINDOW, "LIB3DS_VIEW_WINDOW"},
+ {LIB3DS_VIEWPORT_LAYOUT_OLD, "LIB3DS_VIEWPORT_LAYOUT_OLD"},
+ {LIB3DS_VIEWPORT_DATA_OLD, "LIB3DS_VIEWPORT_DATA_OLD"},
+ {LIB3DS_VIEWPORT_LAYOUT, "LIB3DS_VIEWPORT_LAYOUT"},
+ {LIB3DS_VIEWPORT_DATA, "LIB3DS_VIEWPORT_DATA"},
+ {LIB3DS_VIEWPORT_DATA_3, "LIB3DS_VIEWPORT_DATA_3"},
+ {LIB3DS_VIEWPORT_SIZE, "LIB3DS_VIEWPORT_SIZE"},
+ {LIB3DS_NETWORK_VIEW, "LIB3DS_NETWORK_VIEW"},
+ {0,0}
+};
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+
--- /dev/null
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: ease.c,v 1.4 2001/01/12 10:29:17 jeh Exp $
+ */
+#define LIB3DS_EXPORT
+#include <lib3ds/ease.h>
+
+
+/*!
+ * \defgroup ease Ease
+ *
+ * \author J.E. Hoffmann <je-h@gmx.net>
+ */
+
+
+/*!
+ * \ingroup ease
+ */
+Lib3dsFloat
+lib3ds_ease(Lib3dsFloat fp, Lib3dsFloat fc, Lib3dsFloat fn,
+ Lib3dsFloat ease_from, Lib3dsFloat ease_to)
+{
+ Lib3dsDouble s,step;
+ Lib3dsDouble tofrom;
+ Lib3dsDouble a;
+
+ s=step=(Lib3dsFloat)(fc-fp)/(fn-fp);
+ tofrom=ease_to+ease_from;
+ if (tofrom!=0.0) {
+ if (tofrom>1.0) {
+ ease_to=(Lib3dsFloat)(ease_to/tofrom);
+ ease_from=(Lib3dsFloat)(ease_from/tofrom);
+ }
+ a=1.0/(2.0-(ease_to+ease_from));
+
+ if (step<ease_from) s=a/ease_from*step*step;
+ else {
+ if ((1.0-ease_to)<=step) {
+ step=1.0-step;
+ s=1.0-a/ease_to*step*step;
+ }
+ else {
+ s=((2.0*step)-ease_from)*a;
+ }
+ }
+ }
+ return((Lib3dsFloat)s);
+}
--- /dev/null
+/* -*- c -*- */
+#ifndef INCLUDED_LIB3DS_EASE_H
+#define INCLUDED_LIB3DS_EASE_H
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: ease.h,v 1.5 2004/12/31 16:17:15 reed Exp $
+ */
+
+#ifndef INCLUDED_LIB3DS_TYPES_H
+#include <lib3ds/types.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern LIB3DSAPI Lib3dsFloat lib3ds_ease(Lib3dsFloat fp, Lib3dsFloat fc,
+ Lib3dsFloat fn, Lib3dsFloat ease_from, Lib3dsFloat ease_to);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+
--- /dev/null
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: file.c,v 1.23 2005/01/11 10:20:36 madmac Exp $
+ */
+#define LIB3DS_EXPORT
+#include <lib3ds/file.h>
+#include <lib3ds/chunk.h>
+#include <lib3ds/io.h>
+#include <lib3ds/material.h>
+#include <lib3ds/mesh.h>
+#include <lib3ds/camera.h>
+#include <lib3ds/light.h>
+#include <lib3ds/node.h>
+#include <lib3ds/vector.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#ifdef WITH_DMALLOC
+#include <dmalloc.h>
+#endif
+
+
+
+/*!
+ * \defgroup file Files
+ *
+ * \author J.E. Hoffmann <je-h@gmx.net>
+ */
+
+
+static Lib3dsBool
+fileio_error_func(void *self)
+{
+ FILE *f = (FILE*)self;
+ return(ferror(f)!=0);
+}
+
+
+static long
+fileio_seek_func(void *self, long offset, Lib3dsIoSeek origin)
+{
+ FILE *f = (FILE*)self;
+ int o;
+ switch (origin) {
+ case LIB3DS_SEEK_SET:
+ o = SEEK_SET;
+ break;
+ case LIB3DS_SEEK_CUR:
+ o = SEEK_CUR;
+ break;
+ case LIB3DS_SEEK_END:
+ o = SEEK_END;
+ break;
+ default:
+ ASSERT(0);
+ return(0);
+ }
+ return (fseek(f, offset, o));
+}
+
+
+static long
+fileio_tell_func(void *self)
+{
+ FILE *f = (FILE*)self;
+ return(ftell(f));
+}
+
+
+static int
+fileio_read_func(void *self, Lib3dsByte *buffer, int size)
+{
+ FILE *f = (FILE*)self;
+ return(fread(buffer, 1, size, f));
+}
+
+
+static int
+fileio_write_func(void *self, const Lib3dsByte *buffer, int size)
+{
+ FILE *f = (FILE*)self;
+ return(fwrite(buffer, 1, size, f));
+}
+
+
+/*!
+ * Loads a .3DS file from disk into memory.
+ *
+ * \param filename The filename of the .3DS file
+ *
+ * \return A pointer to the Lib3dsFile structure containing the
+ * data of the .3DS file.
+ * If the .3DS file can not be loaded NULL is returned.
+ *
+ * \note To free the returned structure use lib3ds_free.
+ *
+ * \see lib3ds_file_save
+ * \see lib3ds_file_new
+ * \see lib3ds_file_free
+ *
+ * \ingroup file
+ */
+Lib3dsFile*
+lib3ds_file_load(const char *filename)
+{
+ FILE *f;
+ Lib3dsFile *file;
+ Lib3dsIo *io;
+
+
+ f = fopen(filename, "rb");
+ if (!f) {
+ return(0);
+ }
+ file = lib3ds_file_new();
+ if (!file) {
+ fclose(f);
+ return(0);
+ }
+ io = lib3ds_io_new(
+ f,
+ fileio_error_func,
+ fileio_seek_func,
+ fileio_tell_func,
+ fileio_read_func,
+ fileio_write_func
+ );
+ if (!io) {
+ lib3ds_file_free(file);
+ fclose(f);
+ return(0);
+ }
+
+ if (!lib3ds_file_read(file, io)) {
+ free(file);
+ fclose(f);
+ return(0);
+ }
+
+ lib3ds_io_free(io);
+ fclose(f);
+ return(file);
+}
+
+
+/*!
+ * Saves a .3DS file from memory to disk.
+ *
+ * \param file A pointer to a Lib3dsFile structure containing the
+ * the data that should be stored.
+ * \param filename The filename of the .3DS file to store the data in.
+ *
+ * \return TRUE on success, FALSE otherwise.
+ *
+ * \see lib3ds_file_load
+ *
+ * \ingroup file
+ */
+Lib3dsBool
+lib3ds_file_save(Lib3dsFile *file, const char *filename)
+{
+ FILE *f;
+ Lib3dsIo *io;
+ Lib3dsBool result;
+
+ f = fopen(filename, "wb");
+ if (!f) {
+ return(LIB3DS_FALSE);
+ }
+ io = lib3ds_io_new(
+ f,
+ fileio_error_func,
+ fileio_seek_func,
+ fileio_tell_func,
+ fileio_read_func,
+ fileio_write_func
+ );
+ if (!io) {
+ fclose(f);
+ return LIB3DS_FALSE;
+ }
+
+ result = lib3ds_file_write(file, io);
+
+ fclose(f);
+
+ lib3ds_io_free(io);
+ return(result);
+}
+
+
+/*!
+ * Creates and returns a new, empty Lib3dsFile object.
+ *
+ * \return A pointer to the Lib3dsFile structure.
+ * If the structure cannot be allocated, NULL is returned.
+ *
+ * \ingroup file
+ */
+Lib3dsFile*
+lib3ds_file_new()
+{
+ Lib3dsFile *file;
+
+ file=(Lib3dsFile*)calloc(sizeof(Lib3dsFile),1);
+ if (!file) {
+ return(0);
+ }
+ file->mesh_version=3;
+ file->master_scale=1.0f;
+ file->keyf_revision=5;
+ strcpy(file->name, "LIB3DS");
+
+ file->frames=100;
+ file->segment_from=0;
+ file->segment_to=100;
+ file->current_frame=0;
+
+ return(file);
+}
+
+
+/*!
+ * Free a Lib3dsFile object and all of its resources.
+ *
+ * \param file The Lib3dsFile object to be freed.
+ *
+ * \ingroup file
+ */
+void
+lib3ds_file_free(Lib3dsFile* file)
+{
+ ASSERT(file);
+ lib3ds_viewport_set_views(&file->viewport,0);
+ {
+ Lib3dsMaterial *p,*q;
+
+ for (p=file->materials; p; p=q) {
+ q=p->next;
+ lib3ds_material_free(p);
+ }
+ file->materials=0;
+ }
+ {
+ Lib3dsCamera *p,*q;
+
+ for (p=file->cameras; p; p=q) {
+ q=p->next;
+ lib3ds_camera_free(p);
+ }
+ file->cameras=0;
+ }
+ {
+ Lib3dsLight *p,*q;
+
+ for (p=file->lights; p; p=q) {
+ q=p->next;
+ lib3ds_light_free(p);
+ }
+ file->lights=0;
+ }
+ {
+ Lib3dsMesh *p,*q;
+
+ for (p=file->meshes; p; p=q) {
+ q=p->next;
+ lib3ds_mesh_free(p);
+ }
+ file->meshes=0;
+ }
+ {
+ Lib3dsNode *p,*q;
+
+ for (p=file->nodes; p; p=q) {
+ q=p->next;
+ lib3ds_node_free(p);
+ }
+ }
+ free(file);
+}
+
+
+/*!
+ * Evaluate all of the nodes in this Lib3dsFile object.
+ *
+ * \param file The Lib3dsFile object to be evaluated.
+ * \param t time value, between 0. and file->frames
+ *
+ * \see lib3ds_node_eval
+ *
+ * \ingroup file
+ */
+void
+lib3ds_file_eval(Lib3dsFile *file, Lib3dsFloat t)
+{
+ Lib3dsNode *p;
+
+ for (p=file->nodes; p!=0; p=p->next) {
+ lib3ds_node_eval(p, t);
+ }
+}
+
+
+static Lib3dsBool
+named_object_read(Lib3dsFile *file, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+ char name[64];
+ Lib3dsWord chunk;
+
+ if (!lib3ds_chunk_read_start(&c, LIB3DS_NAMED_OBJECT, io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_io_read_string(io, name, 64)) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_chunk_dump_info(" NAME=%s", name);
+ lib3ds_chunk_read_tell(&c, io);
+
+ while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
+ switch (chunk) {
+ case LIB3DS_N_TRI_OBJECT:
+ {
+ Lib3dsMesh *mesh;
+
+ mesh=lib3ds_mesh_new(name);
+ if (!mesh) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_chunk_read_reset(&c, io);
+ if (!lib3ds_mesh_read(mesh, io)) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_file_insert_mesh(file, mesh);
+ }
+ break;
+ case LIB3DS_N_CAMERA:
+ {
+ Lib3dsCamera *camera;
+
+ camera=lib3ds_camera_new(name);
+ if (!camera) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_chunk_read_reset(&c, io);
+ if (!lib3ds_camera_read(camera, io)) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_file_insert_camera(file, camera);
+ }
+ break;
+ case LIB3DS_N_DIRECT_LIGHT:
+ {
+ Lib3dsLight *light;
+
+ light=lib3ds_light_new(name);
+ if (!light) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_chunk_read_reset(&c, io);
+ if (!lib3ds_light_read(light, io)) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_file_insert_light(file, light);
+ }
+ break;
+ default:
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+
+ lib3ds_chunk_read_end(&c, io);
+ return(LIB3DS_TRUE);
+}
+
+
+static Lib3dsBool
+ambient_read(Lib3dsFile *file, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+ Lib3dsWord chunk;
+ Lib3dsBool have_lin=LIB3DS_FALSE;
+
+ if (!lib3ds_chunk_read_start(&c, LIB3DS_AMBIENT_LIGHT, io)) {
+ return(LIB3DS_FALSE);
+ }
+
+ while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
+ switch (chunk) {
+ case LIB3DS_LIN_COLOR_F:
+ {
+ int i;
+ for (i=0; i<3; ++i) {
+ file->ambient[i]=lib3ds_io_read_float(io);
+ }
+ }
+ have_lin=LIB3DS_TRUE;
+ break;
+ case LIB3DS_COLOR_F:
+ {
+ /* gamma corrected color chunk
+ replaced in 3ds R3 by LIN_COLOR_24 */
+ if (!have_lin) {
+ int i;
+ for (i=0; i<3; ++i) {
+ file->ambient[i]=lib3ds_io_read_float(io);
+ }
+ }
+ }
+ break;
+ default:
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+
+ lib3ds_chunk_read_end(&c, io);
+ return(LIB3DS_TRUE);
+}
+
+
+static Lib3dsBool
+mdata_read(Lib3dsFile *file, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+ Lib3dsWord chunk;
+
+ if (!lib3ds_chunk_read_start(&c, LIB3DS_MDATA, io)) {
+ return(LIB3DS_FALSE);
+ }
+
+ while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
+ switch (chunk) {
+ case LIB3DS_MESH_VERSION:
+ {
+ file->mesh_version=lib3ds_io_read_intd(io);
+ }
+ break;
+ case LIB3DS_MASTER_SCALE:
+ {
+ file->master_scale=lib3ds_io_read_float(io);
+ }
+ break;
+ case LIB3DS_SHADOW_MAP_SIZE:
+ case LIB3DS_LO_SHADOW_BIAS:
+ case LIB3DS_HI_SHADOW_BIAS:
+ case LIB3DS_SHADOW_SAMPLES:
+ case LIB3DS_SHADOW_RANGE:
+ case LIB3DS_SHADOW_FILTER:
+ case LIB3DS_RAY_BIAS:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!lib3ds_shadow_read(&file->shadow, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_VIEWPORT_LAYOUT:
+ case LIB3DS_DEFAULT_VIEW:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!lib3ds_viewport_read(&file->viewport, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_O_CONSTS:
+ {
+ int i;
+ for (i=0; i<3; ++i) {
+ file->construction_plane[i]=lib3ds_io_read_float(io);
+ }
+ }
+ break;
+ case LIB3DS_AMBIENT_LIGHT:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!ambient_read(file, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_BIT_MAP:
+ case LIB3DS_SOLID_BGND:
+ case LIB3DS_V_GRADIENT:
+ case LIB3DS_USE_BIT_MAP:
+ case LIB3DS_USE_SOLID_BGND:
+ case LIB3DS_USE_V_GRADIENT:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!lib3ds_background_read(&file->background, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_FOG:
+ case LIB3DS_LAYER_FOG:
+ case LIB3DS_DISTANCE_CUE:
+ case LIB3DS_USE_FOG:
+ case LIB3DS_USE_LAYER_FOG:
+ case LIB3DS_USE_DISTANCE_CUE:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!lib3ds_atmosphere_read(&file->atmosphere, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_MAT_ENTRY:
+ {
+ Lib3dsMaterial *material;
+
+ material=lib3ds_material_new();
+ if (!material) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_chunk_read_reset(&c, io);
+ if (!lib3ds_material_read(material, io)) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_file_insert_material(file, material);
+ }
+ break;
+ case LIB3DS_NAMED_OBJECT:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!named_object_read(file, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ default:
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+
+ lib3ds_chunk_read_end(&c, io);
+ return(LIB3DS_TRUE);
+}
+
+
+static Lib3dsBool
+kfdata_read(Lib3dsFile *file, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+ Lib3dsWord chunk;
+
+ if (!lib3ds_chunk_read_start(&c, LIB3DS_KFDATA, io)) {
+ return(LIB3DS_FALSE);
+ }
+
+ while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
+ switch (chunk) {
+ case LIB3DS_KFHDR:
+ {
+ file->keyf_revision=lib3ds_io_read_word(io);
+ if (!lib3ds_io_read_string(io, file->name, 12+1)) {
+ return(LIB3DS_FALSE);
+ }
+ file->frames=lib3ds_io_read_intd(io);
+ }
+ break;
+ case LIB3DS_KFSEG:
+ {
+ file->segment_from=lib3ds_io_read_intd(io);
+ file->segment_to=lib3ds_io_read_intd(io);
+ }
+ break;
+ case LIB3DS_KFCURTIME:
+ {
+ file->current_frame=lib3ds_io_read_intd(io);
+ }
+ break;
+ case LIB3DS_VIEWPORT_LAYOUT:
+ case LIB3DS_DEFAULT_VIEW:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!lib3ds_viewport_read(&file->viewport_keyf, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_AMBIENT_NODE_TAG:
+ {
+ Lib3dsNode *node;
+
+ node=lib3ds_node_new_ambient();
+ if (!node) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_chunk_read_reset(&c, io);
+ if (!lib3ds_node_read(node, file, io)) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_file_insert_node(file, node);
+ }
+ break;
+ case LIB3DS_OBJECT_NODE_TAG:
+ {
+ Lib3dsNode *node;
+
+ node=lib3ds_node_new_object();
+ if (!node) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_chunk_read_reset(&c, io);
+ if (!lib3ds_node_read(node, file, io)) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_file_insert_node(file, node);
+ }
+ break;
+ case LIB3DS_CAMERA_NODE_TAG:
+ {
+ Lib3dsNode *node;
+
+ node=lib3ds_node_new_camera();
+ if (!node) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_chunk_read_reset(&c, io);
+ if (!lib3ds_node_read(node, file, io)) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_file_insert_node(file, node);
+ }
+ break;
+ case LIB3DS_TARGET_NODE_TAG:
+ {
+ Lib3dsNode *node;
+
+ node=lib3ds_node_new_target();
+ if (!node) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_chunk_read_reset(&c, io);
+ if (!lib3ds_node_read(node, file, io)) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_file_insert_node(file, node);
+ }
+ break;
+ case LIB3DS_LIGHT_NODE_TAG:
+ case LIB3DS_SPOTLIGHT_NODE_TAG:
+ {
+ Lib3dsNode *node;
+
+ node=lib3ds_node_new_light();
+ if (!node) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_chunk_read_reset(&c, io);
+ if (!lib3ds_node_read(node, file, io)) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_file_insert_node(file, node);
+ }
+ break;
+ case LIB3DS_L_TARGET_NODE_TAG:
+ {
+ Lib3dsNode *node;
+
+ node=lib3ds_node_new_spot();
+ if (!node) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_chunk_read_reset(&c, io);
+ if (!lib3ds_node_read(node, file, io)) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_file_insert_node(file, node);
+ }
+ break;
+ default:
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+
+ lib3ds_chunk_read_end(&c, io);
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * Read 3ds file data into a Lib3dsFile object.
+ *
+ * \param file The Lib3dsFile object to be filled.
+ * \param io A Lib3dsIo object previously set up by the caller.
+ *
+ * \return LIB3DS_TRUE on success, LIB3DS_FALSE on failure.
+ *
+ * \ingroup file
+ */
+Lib3dsBool
+lib3ds_file_read(Lib3dsFile *file, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+ Lib3dsWord chunk;
+
+ if (!lib3ds_chunk_read_start(&c, 0, io)) {
+ return(LIB3DS_FALSE);
+ }
+ switch (c.chunk) {
+ case LIB3DS_MDATA:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!mdata_read(file, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_M3DMAGIC:
+ case LIB3DS_MLIBMAGIC:
+ case LIB3DS_CMAGIC:
+ {
+ while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
+ switch (chunk) {
+ case LIB3DS_M3D_VERSION:
+ {
+ file->mesh_version=lib3ds_io_read_dword(io);
+ }
+ break;
+ case LIB3DS_MDATA:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!mdata_read(file, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_KFDATA:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!kfdata_read(file, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ default:
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+ }
+ break;
+ default:
+ lib3ds_chunk_unknown(c.chunk);
+ return(LIB3DS_FALSE);
+ }
+
+ lib3ds_chunk_read_end(&c, io);
+ return(LIB3DS_TRUE);
+}
+
+
+static Lib3dsBool
+colorf_write(Lib3dsRgba rgb, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+
+ c.chunk=LIB3DS_COLOR_F;
+ c.size=18;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_rgb(io, rgb);
+
+ c.chunk=LIB3DS_LIN_COLOR_F;
+ c.size=18;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_rgb(io, rgb);
+ return(LIB3DS_TRUE);
+}
+
+
+static Lib3dsBool
+mdata_write(Lib3dsFile *file, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+
+ c.chunk=LIB3DS_MDATA;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+
+ { /*---- LIB3DS_MESH_VERSION ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MESH_VERSION;
+ c.size=10;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_intd(io, file->mesh_version);
+ }
+ { /*---- LIB3DS_MASTER_SCALE ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MASTER_SCALE;
+ c.size=10;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_float(io, file->master_scale);
+ }
+ { /*---- LIB3DS_O_CONSTS ----*/
+ int i;
+ for (i=0; i<3; ++i) {
+ if (fabs(file->construction_plane[i])>LIB3DS_EPSILON) {
+ break;
+ }
+ }
+ if (i<3) {
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_O_CONSTS;
+ c.size=18;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_vector(io, file->construction_plane);
+ }
+ }
+
+ { /*---- LIB3DS_AMBIENT_LIGHT ----*/
+ int i;
+ for (i=0; i<3; ++i) {
+ if (fabs(file->ambient[i])>LIB3DS_EPSILON) {
+ break;
+ }
+ }
+ if (i<3) {
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_AMBIENT_LIGHT;
+ c.size=42;
+ lib3ds_chunk_write(&c,io);
+ colorf_write(file->ambient,io);
+ }
+ }
+ lib3ds_background_write(&file->background, io);
+ lib3ds_atmosphere_write(&file->atmosphere, io);
+ lib3ds_shadow_write(&file->shadow, io);
+ lib3ds_viewport_write(&file->viewport, io);
+ {
+ Lib3dsMaterial *p;
+ for (p=file->materials; p!=0; p=p->next) {
+ if (!lib3ds_material_write(p,io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ }
+ {
+ Lib3dsCamera *p;
+ Lib3dsChunk c;
+
+ for (p=file->cameras; p!=0; p=p->next) {
+ c.chunk=LIB3DS_NAMED_OBJECT;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_io_write_string(io, p->name);
+ lib3ds_camera_write(p,io);
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ }
+ {
+ Lib3dsLight *p;
+ Lib3dsChunk c;
+
+ for (p=file->lights; p!=0; p=p->next) {
+ c.chunk=LIB3DS_NAMED_OBJECT;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_io_write_string(io,p->name);
+ lib3ds_light_write(p,io);
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ }
+ {
+ Lib3dsMesh *p;
+ Lib3dsChunk c;
+
+ for (p=file->meshes; p!=0; p=p->next) {
+ c.chunk=LIB3DS_NAMED_OBJECT;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_io_write_string(io, p->name);
+ lib3ds_mesh_write(p,io);
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ }
+
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+
+static Lib3dsBool
+nodes_write(Lib3dsNode *node, Lib3dsFile *file, Lib3dsIo *io)
+{
+ {
+ Lib3dsNode *p;
+ for (p=node->childs; p!=0; p=p->next) {
+ if (!lib3ds_node_write(p, file, io)) {
+ return(LIB3DS_FALSE);
+ }
+ nodes_write(p, file, io);
+ }
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+static Lib3dsBool
+kfdata_write(Lib3dsFile *file, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+
+ if (!file->nodes) {
+ return(LIB3DS_TRUE);
+ }
+
+ c.chunk=LIB3DS_KFDATA;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+
+ { /*---- LIB3DS_KFHDR ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_KFHDR;
+ c.size=6 + 2 + strlen(file->name)+1 +4;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_intw(io, file->keyf_revision);
+ lib3ds_io_write_string(io, file->name);
+ lib3ds_io_write_intd(io, file->frames);
+ }
+ { /*---- LIB3DS_KFSEG ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_KFSEG;
+ c.size=14;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_intd(io, file->segment_from);
+ lib3ds_io_write_intd(io, file->segment_to);
+ }
+ { /*---- LIB3DS_KFCURTIME ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_KFCURTIME;
+ c.size=10;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_intd(io, file->current_frame);
+ }
+ lib3ds_viewport_write(&file->viewport_keyf, io);
+
+ {
+ Lib3dsNode *p;
+ for (p=file->nodes; p!=0; p=p->next) {
+ if (!lib3ds_node_write(p, file, io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!nodes_write(p, file, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ }
+
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * Write 3ds file data from a Lib3dsFile object to a file.
+ *
+ * \param file The Lib3dsFile object to be written.
+ * \param io A Lib3dsIo object previously set up by the caller.
+ *
+ * \return LIB3DS_TRUE on success, LIB3DS_FALSE on failure.
+ *
+ * \ingroup file
+ */
+Lib3dsBool
+lib3ds_file_write(Lib3dsFile *file, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+
+ c.chunk=LIB3DS_M3DMAGIC;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ LIB3DS_ERROR_LOG;
+ return(LIB3DS_FALSE);
+ }
+
+ { /*---- LIB3DS_M3D_VERSION ----*/
+ Lib3dsChunk c;
+
+ c.chunk=LIB3DS_M3D_VERSION;
+ c.size=10;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_dword(io, file->mesh_version);
+ }
+
+ if (!mdata_write(file, io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!kfdata_write(file, io)) {
+ return(LIB3DS_FALSE);
+ }
+
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * Insert a new Lib3dsMaterial object into the materials list of
+ * a Lib3dsFile object.
+ *
+ * The new Lib3dsMaterial object is inserted into the materials list
+ * in alphabetic order by name.
+ *
+ * \param file The Lib3dsFile object to be modified.
+ * \param material The Lib3dsMaterial object to be inserted into file->materials
+ *
+ * \ingroup file
+ */
+void
+lib3ds_file_insert_material(Lib3dsFile *file, Lib3dsMaterial *material)
+{
+ Lib3dsMaterial *p,*q;
+
+ ASSERT(file);
+ ASSERT(material);
+ ASSERT(!material->next);
+
+ q=0;
+ for (p=file->materials; p!=0; p=p->next) {
+ if (strcmp(material->name, p->name)<0) {
+ break;
+ }
+ q=p;
+ }
+ if (!q) {
+ material->next=file->materials;
+ file->materials=material;
+ }
+ else {
+ material->next=q->next;
+ q->next=material;
+ }
+}
+
+
+/*!
+ * Remove a Lib3dsMaterial object from the materials list of
+ * a Lib3dsFile object.
+ *
+ * If the Lib3dsMaterial is not found in the materials list, nothing is
+ * done (except that an error log message may be generated.)
+ *
+ * \param file The Lib3dsFile object to be modified.
+ * \param material The Lib3dsMaterial object to be removed from file->materials
+ *
+ * \ingroup file
+ */
+void
+lib3ds_file_remove_material(Lib3dsFile *file, Lib3dsMaterial *material)
+{
+ Lib3dsMaterial *p,*q;
+
+ ASSERT(file);
+ ASSERT(material);
+ ASSERT(file->materials);
+ for (p=0,q=file->materials; q; p=q,q=q->next) {
+ if (q==material) {
+ break;
+ }
+ }
+ if (!q) {
+ ASSERT(LIB3DS_FALSE);
+ return;
+ }
+ if (!p) {
+ file->materials=material->next;
+ }
+ else {
+ p->next=q->next;
+ }
+ material->next=0;
+}
+
+
+/*!
+ * Return a Lib3dsMaterial object by name.
+ *
+ * \param file Lib3dsFile object to be searched.
+ * \param name Name of the Lib3dsMaterial object to be searched for.
+ *
+ * \return A pointer to the named Lib3dsMaterial, or NULL if not found.
+ *
+ * \ingroup file
+ */
+Lib3dsMaterial*
+lib3ds_file_material_by_name(Lib3dsFile *file, const char *name)
+{
+ Lib3dsMaterial *p;
+
+ ASSERT(file);
+ for (p=file->materials; p!=0; p=p->next) {
+ if (strcmp(p->name,name)==0) {
+ return(p);
+ }
+ }
+ return(0);
+}
+
+
+/*!
+ * Dump all Lib3dsMaterial objects found in a Lib3dsFile object.
+ *
+ * \param file Lib3dsFile object to be dumped.
+ *
+ * \see lib3ds_material_dump
+ *
+ * \ingroup file
+ */
+void
+lib3ds_file_dump_materials(Lib3dsFile *file)
+{
+ Lib3dsMaterial *p;
+
+ ASSERT(file);
+ for (p=file->materials; p!=0; p=p->next) {
+ lib3ds_material_dump(p);
+ }
+}
+
+
+/*!
+ * Insert a new Lib3dsMesh object into the meshes list of
+ * a Lib3dsFile object.
+ *
+ * The new Lib3dsMesh object is inserted into the meshes list
+ * in alphabetic order by name.
+ *
+ * \param file The Lib3dsFile object to be modified.
+ * \param material The Lib3dsMesh object to be inserted into file->meshes
+ *
+ * \ingroup file
+ */
+void
+lib3ds_file_insert_mesh(Lib3dsFile *file, Lib3dsMesh *mesh)
+{
+ Lib3dsMesh *p,*q;
+
+ ASSERT(file);
+ ASSERT(mesh);
+ ASSERT(!mesh->next);
+
+ q=0;
+ for (p=file->meshes; p!=0; p=p->next) {
+ if (strcmp(mesh->name, p->name)<0) {
+ break;
+ }
+ q=p;
+ }
+ if (!q) {
+ mesh->next=file->meshes;
+ file->meshes=mesh;
+ }
+ else {
+ mesh->next=q->next;
+ q->next=mesh;
+ }
+}
+
+
+/*!
+ * Remove a Lib3dsMesh object from the meshes list of
+ * a Lib3dsFile object.
+ *
+ * If the Lib3dsMesh is not found in the meshes list, nothing is done
+ * (except that an error log message may be generated.)
+ *
+ * \param file The Lib3dsFile object to be modified.
+ * \param material The Lib3dsMesh object to be removed from file->meshes
+ *
+ * \ingroup file
+ */
+void
+lib3ds_file_remove_mesh(Lib3dsFile *file, Lib3dsMesh *mesh)
+{
+ Lib3dsMesh *p,*q;
+
+ ASSERT(file);
+ ASSERT(mesh);
+ ASSERT(file->meshes);
+ for (p=0,q=file->meshes; q; p=q,q=q->next) {
+ if (q==mesh) {
+ break;
+ }
+ }
+ if (!q) {
+ ASSERT(LIB3DS_FALSE);
+ return;
+ }
+ if (!p) {
+ file->meshes=mesh->next;
+ }
+ else {
+ p->next=q->next;
+ }
+ mesh->next=0;
+}
+
+
+/*!
+ * Return a Lib3dsMesh object from a Lib3dsFile by name.
+ *
+ * \param file Lib3dsFile object to be searched.
+ * \param name Name of the Lib3dsMesh object to be searched for.
+ *
+ * \return A pointer to the named Lib3dsMesh, or NULL if not found.
+ *
+ * \ingroup file
+ */
+Lib3dsMesh*
+lib3ds_file_mesh_by_name(Lib3dsFile *file, const char *name)
+{
+ Lib3dsMesh *p;
+
+ ASSERT(file);
+ for (p=file->meshes; p!=0; p=p->next) {
+ if (strcmp(p->name,name)==0) {
+ return(p);
+ }
+ }
+ return(0);
+}
+
+
+/*!
+ * Dump all Lib3dsMesh objects found in a Lib3dsFile object.
+ *
+ * \param file Lib3dsFile object to be dumped.
+ *
+ * \see lib3ds_mesh_dump
+ *
+ * \ingroup file
+ */
+void
+lib3ds_file_dump_meshes(Lib3dsFile *file)
+{
+ Lib3dsMesh *p;
+
+ ASSERT(file);
+ for (p=file->meshes; p!=0; p=p->next) {
+ lib3ds_mesh_dump(p);
+ }
+}
+
+
+static void
+dump_instances(Lib3dsNode *node, const char* parent)
+{
+ Lib3dsNode *p;
+ char name[255];
+
+ ASSERT(node);
+ ASSERT(parent);
+ strcpy(name, parent);
+ strcat(name, ".");
+ strcat(name, node->name);
+ if (node->type==LIB3DS_OBJECT_NODE) {
+ printf(" %s : %s\n", name, node->data.object.instance);
+ }
+ for (p=node->childs; p!=0; p=p->next) {
+ dump_instances(p, parent);
+ }
+}
+
+
+/*!
+ * Dump all Lib3dsNode object names found in a Lib3dsFile object.
+ *
+ * For each node of type OBJECT_NODE, its name and data.object.instance
+ * fields are printed to stdout. Consider using lib3ds_file_dump_nodes()
+ * instead, as that function dumps more information.
+ *
+ * Nodes are dumped recursively.
+ *
+ * \param file Lib3dsFile object to be dumped.
+ *
+ * \see lib3ds_file_dump_nodes
+ *
+ * \ingroup file
+ */
+void
+lib3ds_file_dump_instances(Lib3dsFile *file)
+{
+ Lib3dsNode *p;
+
+ ASSERT(file);
+ for (p=file->nodes; p!=0; p=p->next) {
+ dump_instances(p,"");
+ }
+}
+
+
+/*!
+ * Insert a new Lib3dsCamera object into the cameras list of
+ * a Lib3dsFile object.
+ *
+ * The new Lib3dsCamera object is inserted into the cameras list
+ * in alphabetic order by name.
+ *
+ * \param file The Lib3dsFile object to be modified.
+ * \param material The Lib3dsCamera object to be inserted into file->cameras
+ *
+ * \ingroup file
+ */
+void
+lib3ds_file_insert_camera(Lib3dsFile *file, Lib3dsCamera *camera)
+{
+ Lib3dsCamera *p,*q;
+
+ ASSERT(file);
+ ASSERT(camera);
+ ASSERT(!camera->next);
+
+ q=0;
+ for (p=file->cameras; p!=0; p=p->next) {
+ if (strcmp(camera->name, p->name)<0) {
+ break;
+ }
+ q=p;
+ }
+ if (!q) {
+ camera->next=file->cameras;
+ file->cameras=camera;
+ }
+ else {
+ camera->next=q->next;
+ q->next=camera;
+ }
+}
+
+
+/*!
+ * Remove a Lib3dsCamera object from the cameras list of
+ * a Lib3dsFile object.
+ *
+ * If the Lib3dsCamera is not found in the cameras list, nothing is done
+ * (except that an error log message may be generated.)
+ *
+ * \param file The Lib3dsFile object to be modified.
+ * \param material The Lib3dsCamera object to be removed from file->cameras
+ *
+ * \ingroup file
+ */
+void
+lib3ds_file_remove_camera(Lib3dsFile *file, Lib3dsCamera *camera)
+{
+ Lib3dsCamera *p,*q;
+
+ ASSERT(file);
+ ASSERT(camera);
+ ASSERT(file->cameras);
+ for (p=0,q=file->cameras; q; p=q,q=q->next) {
+ if (q==camera) {
+ break;
+ }
+ }
+ if (!q) {
+ ASSERT(LIB3DS_FALSE);
+ return;
+ }
+ if (!p) {
+ file->cameras=camera->next;
+ }
+ else {
+ p->next=q->next;
+ }
+ camera->next=0;
+}
+
+
+/*!
+ * Return a Lib3dsCamera object from a Lib3dsFile by name.
+ *
+ * \param file Lib3dsFile object to be searched.
+ * \param name Name of the Lib3dsCamera object to be searched for.
+ *
+ * \return A pointer to the named Lib3dsCamera, or NULL if not found.
+ *
+ * \ingroup file
+ */
+Lib3dsCamera*
+lib3ds_file_camera_by_name(Lib3dsFile *file, const char *name)
+{
+ Lib3dsCamera *p;
+
+ ASSERT(file);
+ for (p=file->cameras; p!=0; p=p->next) {
+ if (strcmp(p->name,name)==0) {
+ return(p);
+ }
+ }
+ return(0);
+}
+
+
+/*!
+ * Dump all Lib3dsCamera objects found in a Lib3dsFile object.
+ *
+ * \param file Lib3dsFile object to be dumped.
+ *
+ * \see lib3ds_camera_dump
+ *
+ * \ingroup file
+ */
+void
+lib3ds_file_dump_cameras(Lib3dsFile *file)
+{
+ Lib3dsCamera *p;
+
+ ASSERT(file);
+ for (p=file->cameras; p!=0; p=p->next) {
+ lib3ds_camera_dump(p);
+ }
+}
+
+
+/*!
+ * Insert a new Lib3dsLight object into the lights list of
+ * a Lib3dsFile object.
+ *
+ * The new Lib3dsLight object is inserted into the lights list
+ * in alphabetic order by name.
+ *
+ * \param file The Lib3dsFile object to be modified.
+ * \param material The Lib3dsLight object to be inserted into file->lights
+ *
+ * \ingroup file
+ */
+void
+lib3ds_file_insert_light(Lib3dsFile *file, Lib3dsLight *light)
+{
+ Lib3dsLight *p,*q;
+
+ ASSERT(file);
+ ASSERT(light);
+ ASSERT(!light->next);
+
+ q=0;
+ for (p=file->lights; p!=0; p=p->next) {
+ if (strcmp(light->name, p->name)<0) {
+ break;
+ }
+ q=p;
+ }
+ if (!q) {
+ light->next=file->lights;
+ file->lights=light;
+ }
+ else {
+ light->next=q->next;
+ q->next=light;
+ }
+}
+
+
+/*!
+ * Remove a Lib3dsLight object from the lights list of
+ * a Lib3dsFile object.
+ *
+ * If the Lib3dsLight is not found in the lights list, nothing is done
+ * (except that an error log message may be generated.)
+ *
+ * \param file The Lib3dsFile object to be modified.
+ * \param material The Lib3dsLight object to be removed from file->lights
+ *
+ * \ingroup file
+ */
+void
+lib3ds_file_remove_light(Lib3dsFile *file, Lib3dsLight *light)
+{
+ Lib3dsLight *p,*q;
+
+ ASSERT(file);
+ ASSERT(light);
+ ASSERT(file->lights);
+ for (p=0,q=file->lights; q; p=q,q=q->next) {
+ if (q==light) {
+ break;
+ }
+ }
+ if (!q) {
+ ASSERT(LIB3DS_FALSE);
+ return;
+ }
+ if (!p) {
+ file->lights=light->next;
+ }
+ else {
+ p->next=q->next;
+ }
+ light->next=0;
+}
+
+
+/*!
+ * Return a Lib3dsLight object from a Lib3dsFile by name.
+ *
+ * \param file Lib3dsFile object to be searched.
+ * \param name Name of the Lib3dsLight object to be searched for.
+ *
+ * \return A pointer to the named Lib3dsLight, or NULL if not found.
+ *
+ * \ingroup file
+ */
+Lib3dsLight*
+lib3ds_file_light_by_name(Lib3dsFile *file, const char *name)
+{
+ Lib3dsLight *p;
+
+ ASSERT(file);
+ for (p=file->lights; p!=0; p=p->next) {
+ if (strcmp(p->name,name)==0) {
+ return(p);
+ }
+ }
+ return(0);
+}
+
+
+/*!
+ * Dump all Lib3dsLight objects found in a Lib3dsFile object.
+ *
+ * \param file Lib3dsFile object to be dumped.
+ *
+ * \see lib3ds_light_dump
+ *
+ * \ingroup file
+ */
+void
+lib3ds_file_dump_lights(Lib3dsFile *file)
+{
+ Lib3dsLight *p;
+
+ ASSERT(file);
+ for (p=file->lights; p!=0; p=p->next) {
+ lib3ds_light_dump(p);
+ }
+}
+
+
+/*!
+ * Compute the bounding box for Lib3dsFile objects.
+ *
+ * This function computes the bounding box for all meshes
+ * in the Lib3dsFile object. Cameras and lights are not included.
+ *
+ * \param file The Lib3dsFile object to be examined.
+ * \param min Returned minimum x,y,z values.
+ * \param max Returned maximum x,y,z values.
+ *
+ * \ingroup file
+ */
+void
+lib3ds_object_bounding_box(Lib3dsFile *file, Lib3dsVector min, Lib3dsVector max)
+{
+ {
+ Lib3dsVector lmin, lmax;
+ Lib3dsMesh *p=file->meshes;
+
+ if (p) {
+ lib3ds_mesh_bounding_box(p, min, max);
+ p = p->next;
+ }
+ while (p) {
+ lib3ds_mesh_bounding_box(p, lmin, lmax);
+ lib3ds_vector_min(min, lmin);
+ lib3ds_vector_max(max, lmax);
+ p=p->next;
+ }
+ }
+}
+
+
+/*!
+ * Compute the bounding box for a Lib3dsFile.
+ *
+ * This function computes the bounding box for all meshes, cameras,
+ * and lights in the Lib3dsFile object.
+ *
+ * \param file The Lib3dsFile object to be examined.
+ * \param min Returned minimum x,y,z values.
+ * \param max Returned maximum x,y,z values.
+ *
+ * \ingroup file
+ */
+void
+lib3ds_file_bounding_box(Lib3dsFile *file, Lib3dsVector min, Lib3dsVector max)
+{
+ Lib3dsBool init=LIB3DS_FALSE;
+
+ {
+ Lib3dsVector lmin, lmax;
+ Lib3dsMesh *p=file->meshes;
+
+ if (!init && p) {
+ init = LIB3DS_TRUE;
+ lib3ds_mesh_bounding_box(p, min, max);
+ p = p->next;
+ }
+ while (p) {
+ lib3ds_mesh_bounding_box(p, lmin, lmax);
+ lib3ds_vector_min(min, lmin);
+ lib3ds_vector_max(max, lmax);
+ p=p->next;
+ }
+ }
+ {
+ Lib3dsCamera *p=file->cameras;
+ if (!init && p) {
+ init = LIB3DS_TRUE;
+ lib3ds_vector_copy(min, p->position);
+ lib3ds_vector_copy(max, p->position);
+ }
+
+ while (p) {
+ lib3ds_vector_min(min, p->position);
+ lib3ds_vector_max(max, p->position);
+ lib3ds_vector_min(min, p->target);
+ lib3ds_vector_max(max, p->target);
+ p=p->next;
+ }
+ }
+ {
+ Lib3dsLight *p=file->lights;
+ if (!init && p) {
+ init = LIB3DS_TRUE;
+ lib3ds_vector_copy(min, p->position);
+ lib3ds_vector_copy(max, p->position);
+ }
+
+ while (p) {
+ lib3ds_vector_min(min, p->position);
+ lib3ds_vector_max(max, p->position);
+ if (p->spot_light) {
+ lib3ds_vector_min(min, p->spot);
+ lib3ds_vector_max(max, p->spot);
+ }
+ p=p->next;
+ }
+ }
+}
+
+
+/*!
+ * Return a node object by name and type.
+ *
+ * This function performs a recursive search for the specified node.
+ * Both name and type must match.
+ *
+ * \param file The Lib3dsFile to be searched.
+ * \param name The target node name.
+ * \param type The target node type
+ *
+ * \return A pointer to the first matching node, or NULL if not found.
+ *
+ * \see lib3ds_node_by_name
+ *
+ * \ingroup file
+ */
+Lib3dsNode*
+lib3ds_file_node_by_name(Lib3dsFile *file, const char* name, Lib3dsNodeTypes type)
+{
+ Lib3dsNode *p,*q;
+
+ ASSERT(file);
+ for (p=file->nodes; p!=0; p=p->next) {
+ if ((p->type==type) && (strcmp(p->name, name)==0)) {
+ return(p);
+ }
+ q=lib3ds_node_by_name(p, name, type);
+ if (q) {
+ return(q);
+ }
+ }
+ return(0);
+}
+
+
+/*!
+ * Return a node object by id.
+ *
+ * This function performs a recursive search for the specified node.
+ *
+ * \param file The Lib3dsFile to be searched.
+ * \param node_id The target node id.
+ *
+ * \return A pointer to the first matching node, or NULL if not found.
+ *
+ * \see lib3ds_node_by_id
+ *
+ * \ingroup file
+ */
+Lib3dsNode*
+lib3ds_file_node_by_id(Lib3dsFile *file, Lib3dsWord node_id)
+{
+ Lib3dsNode *p,*q;
+
+ ASSERT(file);
+ for (p=file->nodes; p!=0; p=p->next) {
+ if (p->node_id==node_id) {
+ return(p);
+ }
+ q=lib3ds_node_by_id(p, node_id);
+ if (q) {
+ return(q);
+ }
+ }
+ return(0);
+}
+
+
+/*!
+ * Insert a new node into a Lib3dsFile object.
+ *
+ * If the node's parent_id structure is not LIB3DS_NO_PARENT and the
+ * specified parent is found inside the Lib3dsFile object, then the
+ * node is inserted as a child of that parent. If the parent_id
+ * structure is LIB3DS_NO_PARENT or the specified parent is not found,
+ * then the node is inserted at the top level.
+ *
+ * Node is inserted in alphabetic order by name.
+ *
+ * Finally, if any other top-level nodes in file specify this node as
+ * their parent, they are relocated as a child of this node.
+ *
+ * \param file The Lib3dsFile object to be modified.
+ * \param node The node to be inserted into file
+ *
+ * \ingroup file
+ */
+void
+lib3ds_file_insert_node(Lib3dsFile *file, Lib3dsNode *node)
+{
+ Lib3dsNode *parent,*p,*n;
+
+ ASSERT(node);
+ ASSERT(!node->next);
+ ASSERT(!node->parent);
+
+ parent=0;
+ if (node->parent_id!=LIB3DS_NO_PARENT) {
+ parent=lib3ds_file_node_by_id(file, node->parent_id);
+ }
+ node->parent=parent;
+
+ if (!parent) {
+ for (p=0,n=file->nodes; n!=0; p=n,n=n->next) {
+ if (strcmp(n->name, node->name)>0) {
+ break;
+ }
+ }
+ if (!p) {
+ node->next=file->nodes;
+ file->nodes=node;
+ }
+ else {
+ node->next=p->next;
+ p->next=node;
+ }
+ }
+ else {
+ for (p=0,n=parent->childs; n!=0; p=n,n=n->next) {
+ if (strcmp(n->name, node->name)>0) {
+ break;
+ }
+ }
+ if (!p) {
+ node->next=parent->childs;
+ parent->childs=node;
+ }
+ else {
+ node->next=p->next;
+ p->next=node;
+ }
+ }
+
+ if (node->node_id!=LIB3DS_NO_PARENT) {
+ for (n=file->nodes; n!=0; n=p) {
+ p=n->next;
+ if (n->parent_id==node->node_id) {
+ lib3ds_file_remove_node(file, n);
+ lib3ds_file_insert_node(file, n);
+ }
+ }
+ }
+}
+
+
+/*!
+ * Remove a node from the a Lib3dsFile object.
+ *
+ * \param file The Lib3dsFile object to be modified.
+ * \param node The Lib3dsNode object to be removed from file
+ *
+ * \return LIB3DS_TRUE on success, LIB3DS_FALSE if node is not found in file
+ *
+ * \ingroup file
+ */
+Lib3dsBool
+lib3ds_file_remove_node(Lib3dsFile *file, Lib3dsNode *node)
+{
+ Lib3dsNode *p,*n;
+
+ if (node->parent) {
+ for (p=0,n=node->parent->childs; n; p=n,n=n->next) {
+ if (n==node) {
+ break;
+ }
+ }
+ if (!n) {
+ return(LIB3DS_FALSE);
+ }
+
+ if (!p) {
+ node->parent->childs=n->next;
+ }
+ else {
+ p->next=n->next;
+ }
+ }
+ else {
+ for (p=0,n=file->nodes; n; p=n,n=n->next) {
+ if (n==node) {
+ break;
+ }
+ }
+ if (!n) {
+ return(LIB3DS_FALSE);
+ }
+
+ if (!p) {
+ file->nodes=n->next;
+ }
+ else {
+ p->next=n->next;
+ }
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * Dump all node objects found in a Lib3dsFile object.
+ *
+ * Nodes are dumped recursively.
+ *
+ * \param file Lib3dsFile object to be dumped.
+ *
+ * \see lib3ds_node_dump
+ *
+ * \ingroup file
+ */
+void
+lib3ds_file_dump_nodes(Lib3dsFile *file)
+{
+ Lib3dsNode *p;
+
+ ASSERT(file);
+ for (p=file->nodes; p!=0; p=p->next) {
+ lib3ds_node_dump(p,1);
+ }
+}
+
+
+/*!
+
+\typedef Lib3dsFile
+ \ingroup file
+ \sa _Lib3dsFile
+
+*/
+
+
+
+/* Programming trick to force users to compile their source code against the
+ * correct headers. The symbol lib3ds_version1_3 will be defined iff the users
+ * compile with the current version of <lib3ds/types.h>
+ */
+
+/*
+extern int lib3ds_version1_3;
+static const int *lib3ds_version = &lib3ds_version1_3;
+*/
--- /dev/null
+/* -*- c -*- */
+#ifndef INCLUDED_LIB3DS_FILE_H
+#define INCLUDED_LIB3DS_FILE_H
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: file.h,v 1.19 2005/06/13 11:29:10 madmac Exp $
+ */
+/* The symbol LIB3DS_VERSION contains the current version number
+ which can be used to check the version at compile time.
+ The major, minor and micro version number is encoded as follows:
+ Version x.y.z becomes the decimal number xyyzz. */
+#define LIB3DS_VERSION 10300
+
+#ifndef INCLUDED_LIB3DS_BACKGROUND_H
+#include <lib3ds/background.h>
+#endif
+#ifndef INCLUDED_LIB3DS_ATMOSPHERE_H
+#include <lib3ds/atmosphere.h>
+#endif
+#ifndef INCLUDED_LIB3DS_SHADOW_H
+#include <lib3ds/shadow.h>
+#endif
+#ifndef INCLUDED_LIB3DS_VIEWPORT_H
+#include <lib3ds/viewport.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*!
+ * 3ds file structure
+ * \ingroup file
+ */
+struct _Lib3dsFile {
+ Lib3dsDword mesh_version;
+ Lib3dsWord keyf_revision;
+ char name[12+1];
+ Lib3dsFloat master_scale;
+ Lib3dsVector construction_plane;
+ Lib3dsRgb ambient;
+ Lib3dsShadow shadow;
+ Lib3dsBackground background;
+ Lib3dsAtmosphere atmosphere;
+ Lib3dsViewport viewport;
+ Lib3dsViewport viewport_keyf;
+ Lib3dsIntd frames;
+ Lib3dsIntd segment_from;
+ Lib3dsIntd segment_to;
+ Lib3dsIntd current_frame;
+ Lib3dsMaterial *materials;
+ Lib3dsMesh *meshes;
+ Lib3dsCamera *cameras;
+ Lib3dsLight *lights;
+ Lib3dsNode *nodes;
+};
+
+extern LIB3DSAPI Lib3dsFile* lib3ds_file_load(const char *filename);
+extern LIB3DSAPI Lib3dsBool lib3ds_file_save(Lib3dsFile *file, const char *filename);
+extern LIB3DSAPI Lib3dsFile* lib3ds_file_new();
+extern LIB3DSAPI void lib3ds_file_free(Lib3dsFile *file);
+extern LIB3DSAPI void lib3ds_file_eval(Lib3dsFile *file, Lib3dsFloat t);
+extern LIB3DSAPI Lib3dsBool lib3ds_file_read(Lib3dsFile *file, Lib3dsIo *io);
+extern LIB3DSAPI Lib3dsBool lib3ds_file_write(Lib3dsFile *file, Lib3dsIo *io);
+extern LIB3DSAPI void lib3ds_file_insert_material(Lib3dsFile *file, Lib3dsMaterial *material);
+extern LIB3DSAPI void lib3ds_file_remove_material(Lib3dsFile *file, Lib3dsMaterial *material);
+extern LIB3DSAPI Lib3dsMaterial* lib3ds_file_material_by_name(Lib3dsFile *file, const char *name);
+extern LIB3DSAPI void lib3ds_file_dump_materials(Lib3dsFile *file);
+extern LIB3DSAPI void lib3ds_file_insert_mesh(Lib3dsFile *file, Lib3dsMesh *mesh);
+extern LIB3DSAPI void lib3ds_file_remove_mesh(Lib3dsFile *file, Lib3dsMesh *mesh);
+extern LIB3DSAPI Lib3dsMesh* lib3ds_file_mesh_by_name(Lib3dsFile *file, const char *name);
+extern LIB3DSAPI void lib3ds_file_dump_meshes(Lib3dsFile *file);
+extern LIB3DSAPI void lib3ds_file_dump_instances(Lib3dsFile *file);
+extern LIB3DSAPI void lib3ds_file_insert_camera(Lib3dsFile *file, Lib3dsCamera *camera);
+extern LIB3DSAPI void lib3ds_file_remove_camera(Lib3dsFile *file, Lib3dsCamera *camera);
+extern LIB3DSAPI Lib3dsCamera* lib3ds_file_camera_by_name(Lib3dsFile *file, const char *name);
+extern LIB3DSAPI void lib3ds_file_dump_cameras(Lib3dsFile *file);
+extern LIB3DSAPI void lib3ds_file_insert_light(Lib3dsFile *file, Lib3dsLight *light);
+extern LIB3DSAPI void lib3ds_file_remove_light(Lib3dsFile *file, Lib3dsLight *light);
+extern LIB3DSAPI Lib3dsLight* lib3ds_file_light_by_name(Lib3dsFile *file, const char *name);
+extern LIB3DSAPI void lib3ds_file_dump_lights(Lib3dsFile *file);
+extern LIB3DSAPI Lib3dsNode* lib3ds_file_node_by_name(Lib3dsFile *file, const char* name,
+ Lib3dsNodeTypes type);
+extern LIB3DSAPI Lib3dsNode* lib3ds_file_node_by_id(Lib3dsFile *file, Lib3dsWord node_id);
+extern LIB3DSAPI void lib3ds_file_insert_node(Lib3dsFile *file, Lib3dsNode *node);
+extern LIB3DSAPI Lib3dsBool lib3ds_file_remove_node(Lib3dsFile *file, Lib3dsNode *node);
+extern LIB3DSAPI void lib3ds_file_dump_nodes(Lib3dsFile *file);
+extern LIB3DSAPI void lib3ds_object_bounding_box(Lib3dsFile *file,
+ Lib3dsVector min, Lib3dsVector max);
+extern LIB3DSAPI void lib3ds_file_bounding_box(Lib3dsFile *file,
+ Lib3dsVector min, Lib3dsVector max);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+
--- /dev/null
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: float.c,v 1.4 2001/01/12 10:29:17 jeh Exp $
+ */
+#define LIB3DS_EXPORT
+#include <lib3ds/float.h>
+
+
+/*!
+ * \defgroup float Floating Point Mathematics
+ *
+ * \author J.E. Hoffmann <je-h@gmx.net>
+ */
+
+
+/*!
+ * \ingroup float
+ */
+Lib3dsFloat
+lib3ds_float_cubic(Lib3dsFloat a, Lib3dsFloat p, Lib3dsFloat q, Lib3dsFloat b, Lib3dsFloat t)
+{
+ Lib3dsDouble x,y,z,w;
+
+ x=2*t*t*t - 3*t*t + 1;
+ y=-2*t*t*t + 3*t*t;
+ z=t*t*t - 2*t*t + t;
+ w=t*t*t - t*t;
+ return((Lib3dsFloat)(x*a + y*b + z*p + w*q));
+}
+
--- /dev/null
+/* -*- c -*- */
+#ifndef INCLUDED_LIB3DS_FLOAT_H
+#define INCLUDED_LIB3DS_FLOAT_H
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: float.h,v 1.5 2004/12/31 16:17:15 reed Exp $
+ */
+
+#ifndef INCLUDED_LIB3DS_TYPES_H
+#include <lib3ds/types.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern LIB3DSAPI Lib3dsFloat lib3ds_float_cubic(Lib3dsFloat a, Lib3dsFloat p,
+ Lib3dsFloat q, Lib3dsFloat b, Lib3dsFloat t);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+
--- /dev/null
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: io.c,v 1.3 2001/07/11 13:47:35 jeh Exp $
+ */
+#define LIB3DS_EXPORT
+#include <lib3ds/io.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+/*!
+ * \defgroup io Binary Input/Ouput Abstraction Layer
+ *
+ * \author J.E. Hoffmann <je-h@gmx.net>
+ */
+
+
+struct _Lib3dsIo {
+ void *self;
+ Lib3dsIoErrorFunc error_func;
+ Lib3dsIoSeekFunc seek_func;
+ Lib3dsIoTellFunc tell_func;
+ Lib3dsIoReadFunc read_func;
+ Lib3dsIoWriteFunc write_func;
+};
+
+
+Lib3dsIo*
+lib3ds_io_new(void *self, Lib3dsIoErrorFunc error_func, Lib3dsIoSeekFunc seek_func,
+ Lib3dsIoTellFunc tell_func, Lib3dsIoReadFunc read_func, Lib3dsIoWriteFunc write_func)
+{
+ Lib3dsIo *io = calloc(sizeof(Lib3dsIo),1);
+ ASSERT(io);
+ if (!io) {
+ return 0;
+ }
+
+ io->self = self;
+ io->error_func = error_func;
+ io->seek_func = seek_func;
+ io->tell_func = tell_func;
+ io->read_func = read_func;
+ io->write_func = write_func;
+
+ return io;
+}
+
+
+void
+lib3ds_io_free(Lib3dsIo *io)
+{
+ ASSERT(io);
+ if (!io) {
+ return;
+ }
+ free(io);
+}
+
+
+Lib3dsBool
+lib3ds_io_error(Lib3dsIo *io)
+{
+ ASSERT(io);
+ if (!io || !io->error_func) {
+ return 0;
+ }
+ return (*io->error_func)(io->self);
+}
+
+
+long
+lib3ds_io_seek(Lib3dsIo *io, long offset, Lib3dsIoSeek origin)
+{
+ ASSERT(io);
+ if (!io || !io->seek_func) {
+ return 0;
+ }
+ return (*io->seek_func)(io->self, offset, origin);
+}
+
+
+long
+lib3ds_io_tell(Lib3dsIo *io)
+{
+ ASSERT(io);
+ if (!io || !io->tell_func) {
+ return 0;
+ }
+ return (*io->tell_func)(io->self);
+}
+
+
+int
+lib3ds_io_read(Lib3dsIo *io, Lib3dsByte *buffer, int size)
+{
+ ASSERT(io);
+ if (!io || !io->read_func) {
+ return 0;
+ }
+ return (*io->read_func)(io->self, buffer, size);
+}
+
+
+int
+lib3ds_io_write(Lib3dsIo *io, const Lib3dsByte *buffer, int size)
+{
+ ASSERT(io);
+ if (!io || !io->write_func) {
+ return 0;
+ }
+ return (*io->write_func)(io->self, buffer, size);
+}
+
+
+/*!
+ * \ingroup io
+ *
+ * Read a byte from a file stream.
+ */
+Lib3dsByte
+lib3ds_io_read_byte(Lib3dsIo *io)
+{
+ Lib3dsByte b;
+
+ ASSERT(io);
+ lib3ds_io_read(io, &b, 1);
+ return(b);
+}
+
+
+/**
+ * Read a word from a file stream in little endian format.
+ */
+Lib3dsWord
+lib3ds_io_read_word(Lib3dsIo *io)
+{
+ Lib3dsByte b[2];
+ Lib3dsWord w;
+
+ ASSERT(io);
+ lib3ds_io_read(io, b, 2);
+ w=((Lib3dsWord)b[1] << 8) |
+ ((Lib3dsWord)b[0]);
+ return(w);
+}
+
+
+/*!
+ * \ingroup io
+ *
+ * Read a dword from file a stream in little endian format.
+ */
+Lib3dsDword
+lib3ds_io_read_dword(Lib3dsIo *io)
+{
+ Lib3dsByte b[4];
+ Lib3dsDword d;
+
+ ASSERT(io);
+ lib3ds_io_read(io, b, 4);
+ d=((Lib3dsDword)b[3] << 24) |
+ ((Lib3dsDword)b[2] << 16) |
+ ((Lib3dsDword)b[1] << 8) |
+ ((Lib3dsDword)b[0]);
+ return(d);
+}
+
+
+/*!
+ * \ingroup io
+ *
+ * Read a signed byte from a file stream.
+ */
+Lib3dsIntb
+lib3ds_io_read_intb(Lib3dsIo *io)
+{
+ Lib3dsIntb b;
+
+ ASSERT(io);
+ lib3ds_io_read(io, (Lib3dsByte*)&b, 1);
+ return(b);
+}
+
+
+/*!
+ * \ingroup io
+ *
+ * Read a signed word from a file stream in little endian format.
+ */
+Lib3dsIntw
+lib3ds_io_read_intw(Lib3dsIo *io)
+{
+ Lib3dsByte b[2];
+ Lib3dsWord w;
+
+ ASSERT(io);
+ lib3ds_io_read(io, b, 2);
+ w=((Lib3dsWord)b[1] << 8) |
+ ((Lib3dsWord)b[0]);
+ return((Lib3dsIntw)w);
+}
+
+
+/*!
+ * \ingroup io
+ *
+ * Read a signed dword a from file stream in little endian format.
+ */
+Lib3dsIntd
+lib3ds_io_read_intd(Lib3dsIo *io)
+{
+ Lib3dsByte b[4];
+ Lib3dsDword d;
+
+ ASSERT(io);
+ lib3ds_io_read(io, b, 4);
+ d=((Lib3dsDword)b[3] << 24) |
+ ((Lib3dsDword)b[2] << 16) |
+ ((Lib3dsDword)b[1] << 8) |
+ ((Lib3dsDword)b[0]);
+ return((Lib3dsIntd)d);
+}
+
+
+/*!
+ * \ingroup io
+ *
+ * Read a float from a file stream in little endian format.
+ */
+Lib3dsFloat
+lib3ds_io_read_float(Lib3dsIo *io)
+{
+ Lib3dsByte b[4];
+ Lib3dsDword d;
+
+ ASSERT(io);
+ lib3ds_io_read(io, b, 4);
+ d=((Lib3dsDword)b[3] << 24) |
+ ((Lib3dsDword)b[2] << 16) |
+ ((Lib3dsDword)b[1] << 8) |
+ ((Lib3dsDword)b[0]);
+ return(*((Lib3dsFloat*)&d));
+}
+
+
+/*!
+ * \ingroup io
+ * \ingroup vector
+ *
+ * Read a vector from a file stream in little endian format.
+ *
+ * \param io IO input handle.
+ * \param v The vector to store the data.
+ */
+Lib3dsBool
+lib3ds_io_read_vector(Lib3dsIo *io, Lib3dsVector v)
+{
+ ASSERT(io);
+
+ v[0]=lib3ds_io_read_float(io);
+ v[1]=lib3ds_io_read_float(io);
+ v[2]=lib3ds_io_read_float(io);
+
+ return(!lib3ds_io_error(io));
+}
+
+
+/*!
+ * \ingroup io
+ */
+Lib3dsBool
+lib3ds_io_read_rgb(Lib3dsIo *io, Lib3dsRgb rgb)
+{
+ ASSERT(io);
+
+ rgb[0]=lib3ds_io_read_float(io);
+ rgb[1]=lib3ds_io_read_float(io);
+ rgb[2]=lib3ds_io_read_float(io);
+
+ return(!lib3ds_io_error(io));
+}
+
+
+/*!
+ * \ingroup io
+ *
+ * Read a zero-terminated string from a file stream.
+ *
+ * \param io IO input handle.
+ * \param s The buffer to store the read string.
+ * \param buflen Buffer length.
+ *
+ * \return True on success, False otherwise.
+ */
+Lib3dsBool
+lib3ds_io_read_string(Lib3dsIo *io, char *s, int buflen)
+{
+ char c;
+ int k=0;
+
+ ASSERT(io);
+ for (;;) {
+ if (lib3ds_io_read(io, (Lib3dsByte*)&c, 1)!=1) {
+ return LIB3DS_FALSE;
+ }
+ *s++ = c;
+ if (!c) {
+ break;
+ }
+ ++k;
+ if (k>=buflen) {
+ return(LIB3DS_FALSE);
+ }
+ }
+
+ return(!lib3ds_io_error(io));
+}
+
+
+/*!
+ * \ingroup io
+ *
+ * Writes a byte into a file stream.
+ */
+Lib3dsBool
+lib3ds_io_write_byte(Lib3dsIo *io, Lib3dsByte b)
+{
+ ASSERT(io);
+ if (lib3ds_io_write(io, &b, 1)!=1) {
+ return(LIB3DS_FALSE);
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup io
+ *
+ * Writes a word into a little endian file stream.
+ */
+Lib3dsBool
+lib3ds_io_write_word(Lib3dsIo *io, Lib3dsWord w)
+{
+ Lib3dsByte b[2];
+
+ ASSERT(io);
+ b[1]=((Lib3dsWord)w & 0xFF00) >> 8;
+ b[0]=((Lib3dsWord)w & 0x00FF);
+ if (lib3ds_io_write(io, b, 2)!=2) {
+ return(LIB3DS_FALSE);
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup io
+ *
+ * Writes a dword into a little endian file stream.
+ */
+Lib3dsBool
+lib3ds_io_write_dword(Lib3dsIo *io, Lib3dsDword d)
+{
+ Lib3dsByte b[4];
+
+ ASSERT(io);
+ b[3]=(Lib3dsByte)(((Lib3dsDword)d & 0xFF000000) >> 24);
+ b[2]=(Lib3dsByte)(((Lib3dsDword)d & 0x00FF0000) >> 16);
+ b[1]=(Lib3dsByte)(((Lib3dsDword)d & 0x0000FF00) >> 8);
+ b[0]=(Lib3dsByte)(((Lib3dsDword)d & 0x000000FF));
+ if (lib3ds_io_write(io, b, 4)!=4) {
+ return(LIB3DS_FALSE);
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup io
+ *
+ * Writes a signed byte in a file stream.
+ */
+Lib3dsBool
+lib3ds_io_write_intb(Lib3dsIo *io, Lib3dsIntb b)
+{
+ ASSERT(io);
+ if (lib3ds_io_write(io, (Lib3dsByte*)&b, 1)!=1) {
+ return(LIB3DS_FALSE);
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup io
+ *
+ * Writes a signed word into a little endian file stream.
+ */
+Lib3dsBool
+lib3ds_io_write_intw(Lib3dsIo *io, Lib3dsIntw w)
+{
+ Lib3dsByte b[2];
+
+ ASSERT(io);
+ b[1]=((Lib3dsWord)w & 0xFF00) >> 8;
+ b[0]=((Lib3dsWord)w & 0x00FF);
+ if (lib3ds_io_write(io, b, 2)!=2) {
+ return(LIB3DS_FALSE);
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup io
+ *
+ * Writes a signed dword into a little endian file stream.
+ */
+Lib3dsBool
+lib3ds_io_write_intd(Lib3dsIo *io, Lib3dsIntd d)
+{
+ Lib3dsByte b[4];
+
+ ASSERT(io);
+ b[3]=(Lib3dsByte)(((Lib3dsDword)d & 0xFF000000) >> 24);
+ b[2]=(Lib3dsByte)(((Lib3dsDword)d & 0x00FF0000) >> 16);
+ b[1]=(Lib3dsByte)(((Lib3dsDword)d & 0x0000FF00) >> 8);
+ b[0]=(Lib3dsByte)(((Lib3dsDword)d & 0x000000FF));
+ if (lib3ds_io_write(io, b, 4)!=4) {
+ return(LIB3DS_FALSE);
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup io
+ *
+ * Writes a float into a little endian file stream.
+ */
+Lib3dsBool
+lib3ds_io_write_float(Lib3dsIo *io, Lib3dsFloat l)
+{
+ Lib3dsByte b[4];
+ Lib3dsDword d;
+
+ ASSERT(io);
+ d=*((Lib3dsDword*)&l);
+ b[3]=(Lib3dsByte)(((Lib3dsDword)d & 0xFF000000) >> 24);
+ b[2]=(Lib3dsByte)(((Lib3dsDword)d & 0x00FF0000) >> 16);
+ b[1]=(Lib3dsByte)(((Lib3dsDword)d & 0x0000FF00) >> 8);
+ b[0]=(Lib3dsByte)(((Lib3dsDword)d & 0x000000FF));
+ if (lib3ds_io_write(io, b, 4)!=4) {
+ return(LIB3DS_FALSE);
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup io
+ * \ingroup vector
+ *
+ * Writes a vector into a file stream in little endian format.
+ */
+Lib3dsBool
+lib3ds_io_write_vector(Lib3dsIo *io, Lib3dsVector v)
+{
+ int i;
+ for (i=0; i<3; ++i) {
+ if (!lib3ds_io_write_float(io, v[i])) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup io
+ */
+Lib3dsBool
+lib3ds_io_write_rgb(Lib3dsIo *io, Lib3dsRgb rgb)
+{
+ int i;
+ for (i=0; i<3; ++i) {
+ if (!lib3ds_io_write_float(io, rgb[i])) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup io
+ *
+ * Writes a zero-terminated string into a file stream.
+ */
+Lib3dsBool
+lib3ds_io_write_string(Lib3dsIo *io, const char *s)
+{
+ ASSERT(s);
+ ASSERT(io);
+ lib3ds_io_write(io, (const Lib3dsByte*)s, strlen(s)+1);
+ return(!lib3ds_io_error(io));
+}
--- /dev/null
+/* -*- c -*- */
+#ifndef INCLUDED_LIB3DS_IO_H
+#define INCLUDED_LIB3DS_IO_H
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: io.h,v 1.3 2004/12/31 16:17:15 reed Exp $
+ */
+
+#ifndef INCLUDED_LIB3DS_TYPES_H
+#include <lib3ds/types.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum _Lib3dsIoSeek {
+ LIB3DS_SEEK_SET =0,
+ LIB3DS_SEEK_CUR =1,
+ LIB3DS_SEEK_END =2
+} Lib3dsIoSeek;
+
+typedef Lib3dsBool (*Lib3dsIoErrorFunc)(void *self);
+typedef long (*Lib3dsIoSeekFunc)(void *self, long offset, Lib3dsIoSeek origin);
+typedef long (*Lib3dsIoTellFunc)(void *self);
+typedef int (*Lib3dsIoReadFunc)(void *self, Lib3dsByte *buffer, int size);
+typedef int (*Lib3dsIoWriteFunc)(void *self, const Lib3dsByte *buffer, int size);
+
+extern LIB3DSAPI Lib3dsIo* lib3ds_io_new(void *self, Lib3dsIoErrorFunc error_func,
+ Lib3dsIoSeekFunc seek_func, Lib3dsIoTellFunc tell_func,
+ Lib3dsIoReadFunc read_func, Lib3dsIoWriteFunc write_func);
+extern LIB3DSAPI void lib3ds_io_free(Lib3dsIo *io);
+extern LIB3DSAPI Lib3dsBool lib3ds_io_error(Lib3dsIo *io);
+extern LIB3DSAPI long lib3ds_io_seek(Lib3dsIo *io, long offset, Lib3dsIoSeek origin);
+extern LIB3DSAPI long lib3ds_io_tell(Lib3dsIo *io);
+extern LIB3DSAPI int lib3ds_io_read(Lib3dsIo *io, Lib3dsByte *buffer, int size);
+extern LIB3DSAPI int lib3ds_io_write(Lib3dsIo *io, const Lib3dsByte *buffer, int size);
+
+extern LIB3DSAPI Lib3dsByte lib3ds_io_read_byte(Lib3dsIo *io);
+extern LIB3DSAPI Lib3dsWord lib3ds_io_read_word(Lib3dsIo *io);
+extern LIB3DSAPI Lib3dsDword lib3ds_io_read_dword(Lib3dsIo *io);
+extern LIB3DSAPI Lib3dsIntb lib3ds_io_read_intb(Lib3dsIo *io);
+extern LIB3DSAPI Lib3dsIntw lib3ds_io_read_intw(Lib3dsIo *io);
+extern LIB3DSAPI Lib3dsIntd lib3ds_io_read_intd(Lib3dsIo *io);
+extern LIB3DSAPI Lib3dsFloat lib3ds_io_read_float(Lib3dsIo *io);
+extern LIB3DSAPI Lib3dsBool lib3ds_io_read_vector(Lib3dsIo *io, Lib3dsVector v);
+extern LIB3DSAPI Lib3dsBool lib3ds_io_read_rgb(Lib3dsIo *io, Lib3dsRgb rgb);
+extern LIB3DSAPI Lib3dsBool lib3ds_io_read_string(Lib3dsIo *io, char *s, int buflen);
+
+extern LIB3DSAPI Lib3dsBool lib3ds_io_write_byte(Lib3dsIo *io, Lib3dsByte b);
+extern LIB3DSAPI Lib3dsBool lib3ds_io_write_word(Lib3dsIo *io, Lib3dsWord w);
+extern LIB3DSAPI Lib3dsBool lib3ds_io_write_dword(Lib3dsIo *io, Lib3dsDword d);
+extern LIB3DSAPI Lib3dsBool lib3ds_io_write_intb(Lib3dsIo *io, Lib3dsIntb b);
+extern LIB3DSAPI Lib3dsBool lib3ds_io_write_intw(Lib3dsIo *io, Lib3dsIntw w);
+extern LIB3DSAPI Lib3dsBool lib3ds_io_write_intd(Lib3dsIo *io, Lib3dsIntd d);
+extern LIB3DSAPI Lib3dsBool lib3ds_io_write_float(Lib3dsIo *io, Lib3dsFloat l);
+extern LIB3DSAPI Lib3dsBool lib3ds_io_write_vector(Lib3dsIo *io, Lib3dsVector v);
+extern LIB3DSAPI Lib3dsBool lib3ds_io_write_rgb(Lib3dsIo *io, Lib3dsRgb rgb);
+extern LIB3DSAPI Lib3dsBool lib3ds_io_write_string(Lib3dsIo *io, const char *s);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+
--- /dev/null
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: light.c,v 1.10 2001/07/11 13:47:35 jeh Exp $
+ */
+#define LIB3DS_EXPORT
+#include <lib3ds/light.h>
+#include <lib3ds/chunk.h>
+#include <lib3ds/io.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+#ifdef WITH_DMALLOC
+#include <dmalloc.h>
+#endif
+
+
+/*!
+ * \defgroup light Lights
+ *
+ * \author J.E. Hoffmann <je-h@gmx.net>
+ */
+/*!
+
+\typedef Lib3dsLight
+ \ingroup light
+ \sa _Lib3dsLight
+
+*/
+
+
+
+/*!
+ * \ingroup light
+ */
+Lib3dsLight*
+lib3ds_light_new(const char *name)
+{
+ Lib3dsLight *light;
+
+ ASSERT(name);
+ ASSERT(strlen(name)<64);
+
+ light=(Lib3dsLight*)calloc(sizeof(Lib3dsLight), 1);
+ if (!light) {
+ return(0);
+ }
+ strcpy(light->name, name);
+ return(light);
+}
+
+
+/*!
+ * \ingroup light
+ */
+void
+lib3ds_light_free(Lib3dsLight *light)
+{
+ memset(light, 0, sizeof(Lib3dsLight));
+ free(light);
+}
+
+
+/*!
+ * \ingroup light
+ */
+void
+lib3ds_light_dump(Lib3dsLight *light)
+{
+ ASSERT(light);
+ printf(" name: %s\n", light->name);
+ printf(" spot_light: %s\n", light->spot_light ? "yes" : "no");
+ printf(" see_cone: %s\n", light->see_cone ? "yes" : "no");
+ printf(" color: (%f, %f, %f)\n",
+ light->color[0], light->color[1], light->color[2]);
+ printf(" position (%f, %f, %f)\n",
+ light->position[0], light->position[1], light->position[2]);
+ printf(" spot (%f, %f, %f)\n",
+ light->spot[0], light->spot[1], light->spot[2]);
+ printf(" roll: %f\n", light->roll);
+ printf(" off: %s\n", light->off ? "yes" : "no");
+ printf(" outer_range: %f\n", light->outer_range);
+ printf(" inner_range: %f\n", light->inner_range);
+ printf(" multiplier: %f\n", light->multiplier);
+ printf(" attenuation: %f\n", light->attenuation);
+ printf(" rectangular_spot: %s\n", light->rectangular_spot ? "yes" : "no");
+ printf(" shadowed: %s\n", light->shadowed ? "yes" : "no");
+ printf(" shadow_bias: %f\n", light->shadow_bias);
+ printf(" shadow_filter: %f\n", light->shadow_filter);
+ printf(" shadow_size: %d\n", light->shadow_size);
+ printf(" spot_aspect: %f\n", light->spot_aspect);
+ printf(" use_projector: %s\n", light->use_projector ? "yes" : "no");
+ printf(" projector: %s\n", light->projector);
+ printf(" spot_overshoot: %d\n", (int)light->spot_overshoot);
+ printf(" ray_shadows: %s\n", light->ray_shadows ? "yes" : "no");
+ printf(" ray_bias: %f\n", light->ray_bias);
+ printf(" hot_spot: %f\n", light->hot_spot);
+ printf(" fall_off: %f\n", light->fall_off);
+ printf("\n");
+}
+
+
+/*!
+ * \ingroup light
+ */
+static Lib3dsBool
+spotlight_read(Lib3dsLight *light, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+ Lib3dsWord chunk;
+ int i;
+
+ if (!lib3ds_chunk_read_start(&c, LIB3DS_DL_SPOTLIGHT, io)) {
+ return(LIB3DS_FALSE);
+ }
+ light->spot_light=LIB3DS_TRUE;
+ for (i=0; i<3; ++i) {
+ light->spot[i]=lib3ds_io_read_float(io);
+ }
+ light->hot_spot = lib3ds_io_read_float(io);
+ light->fall_off = lib3ds_io_read_float(io);
+ lib3ds_chunk_read_tell(&c, io);
+
+ while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
+ switch (chunk) {
+ case LIB3DS_DL_SPOT_ROLL:
+ {
+ light->roll=lib3ds_io_read_float(io);
+ }
+ break;
+ case LIB3DS_DL_SHADOWED:
+ {
+ light->shadowed=LIB3DS_TRUE;
+ }
+ break;
+ case LIB3DS_DL_LOCAL_SHADOW2:
+ {
+ light->shadow_bias=lib3ds_io_read_float(io);
+ light->shadow_filter=lib3ds_io_read_float(io);
+ light->shadow_size=lib3ds_io_read_intw(io);
+ }
+ break;
+ case LIB3DS_DL_SEE_CONE:
+ {
+ light->see_cone=LIB3DS_TRUE;
+ }
+ break;
+ case LIB3DS_DL_SPOT_RECTANGULAR:
+ {
+ light->rectangular_spot=LIB3DS_TRUE;
+ }
+ break;
+ case LIB3DS_DL_SPOT_ASPECT:
+ {
+ light->spot_aspect=lib3ds_io_read_float(io);
+ }
+ break;
+ case LIB3DS_DL_SPOT_PROJECTOR:
+ {
+ light->use_projector=LIB3DS_TRUE;
+ if (!lib3ds_io_read_string(io, light->projector, 64)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ case LIB3DS_DL_SPOT_OVERSHOOT:
+ {
+ light->spot_overshoot=LIB3DS_TRUE;
+ }
+ break;
+ case LIB3DS_DL_RAY_BIAS:
+ {
+ light->ray_bias=lib3ds_io_read_float(io);
+ }
+ break;
+ case LIB3DS_DL_RAYSHAD:
+ {
+ light->ray_shadows=LIB3DS_TRUE;
+ }
+ break;
+ default:
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+
+ lib3ds_chunk_read_end(&c, io);
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup light
+ */
+Lib3dsBool
+lib3ds_light_read(Lib3dsLight *light, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+ Lib3dsWord chunk;
+
+ if (!lib3ds_chunk_read_start(&c, LIB3DS_N_DIRECT_LIGHT, io)) {
+ return(LIB3DS_FALSE);
+ }
+ {
+ int i;
+ for (i=0; i<3; ++i) {
+ light->position[i]=lib3ds_io_read_float(io);
+ }
+ }
+ lib3ds_chunk_read_tell(&c, io);
+
+ while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
+ switch (chunk) {
+ case LIB3DS_COLOR_F:
+ {
+ int i;
+ for (i=0; i<3; ++i) {
+ light->color[i]=lib3ds_io_read_float(io);
+ }
+ }
+ break;
+ case LIB3DS_DL_OFF:
+ {
+ light->off=LIB3DS_TRUE;
+ }
+ break;
+ case LIB3DS_DL_OUTER_RANGE:
+ {
+ light->outer_range=lib3ds_io_read_float(io);
+ }
+ break;
+ case LIB3DS_DL_INNER_RANGE:
+ {
+ light->inner_range=lib3ds_io_read_float(io);
+ }
+ break;
+ case LIB3DS_DL_MULTIPLIER:
+ {
+ light->multiplier=lib3ds_io_read_float(io);
+ }
+ break;
+ case LIB3DS_DL_EXCLUDE:
+ {
+ /* FIXME: */
+ lib3ds_chunk_unknown(chunk);
+ }
+ case LIB3DS_DL_ATTENUATE:
+ {
+ light->attenuation=lib3ds_io_read_float(io);
+ }
+ break;
+ case LIB3DS_DL_SPOTLIGHT:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!spotlight_read(light, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ default:
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+
+ lib3ds_chunk_read_end(&c, io);
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup light
+ */
+Lib3dsBool
+lib3ds_light_write(Lib3dsLight *light, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+
+ c.chunk=LIB3DS_N_DIRECT_LIGHT;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_io_write_vector(io, light->position);
+ { /*---- LIB3DS_COLOR_F ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_COLOR_F;
+ c.size=18;
+ lib3ds_chunk_write(&c, io);
+ lib3ds_io_write_rgb(io, light->color);
+ }
+ if (light->off) { /*---- LIB3DS_DL_OFF ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_DL_OFF;
+ c.size=6;
+ lib3ds_chunk_write(&c, io);
+ }
+ { /*---- LIB3DS_DL_OUTER_RANGE ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_DL_OUTER_RANGE;
+ c.size=10;
+ lib3ds_chunk_write(&c, io);
+ lib3ds_io_write_float(io, light->outer_range);
+ }
+ { /*---- LIB3DS_DL_INNER_RANGE ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_DL_INNER_RANGE;
+ c.size=10;
+ lib3ds_chunk_write(&c, io);
+ lib3ds_io_write_float(io, light->inner_range);
+ }
+ { /*---- LIB3DS_DL_MULTIPLIER ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_DL_MULTIPLIER;
+ c.size=10;
+ lib3ds_chunk_write(&c, io);
+ lib3ds_io_write_float(io, light->multiplier);
+ }
+ if (light->attenuation) { /*---- LIB3DS_DL_ATTENUATE ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_DL_ATTENUATE;
+ c.size=6;
+ lib3ds_chunk_write(&c, io);
+ }
+
+ if (light->spot_light) {
+ Lib3dsChunk c;
+
+ c.chunk=LIB3DS_DL_SPOTLIGHT;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_io_write_vector(io, light->spot);
+ lib3ds_io_write_float(io, light->hot_spot);
+ lib3ds_io_write_float(io, light->fall_off);
+
+ { /*---- LIB3DS_DL_SPOT_ROLL ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_DL_SPOT_ROLL;
+ c.size=10;
+ lib3ds_chunk_write(&c, io);
+ lib3ds_io_write_float(io, light->roll);
+ }
+ if (light->shadowed) { /*---- LIB3DS_DL_SHADOWED ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_DL_SHADOWED;
+ c.size=6;
+ lib3ds_chunk_write(&c, io);
+ }
+ if ((fabs(light->shadow_bias)>LIB3DS_EPSILON) ||
+ (fabs(light->shadow_filter)>LIB3DS_EPSILON) ||
+ (light->shadow_size!=0)) { /*---- LIB3DS_DL_LOCAL_SHADOW2 ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_DL_LOCAL_SHADOW2;
+ c.size=16;
+ lib3ds_chunk_write(&c, io);
+ lib3ds_io_write_float(io, light->shadow_bias);
+ lib3ds_io_write_float(io, light->shadow_filter);
+ lib3ds_io_write_intw(io, light->shadow_size);
+ }
+ if (light->see_cone) { /*---- LIB3DS_DL_SEE_CONE ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_DL_SEE_CONE;
+ c.size=6;
+ lib3ds_chunk_write(&c, io);
+ }
+ if (light->rectangular_spot) { /*---- LIB3DS_DL_SPOT_RECTANGULAR ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_DL_SPOT_RECTANGULAR;
+ c.size=6;
+ lib3ds_chunk_write(&c, io);
+ }
+ if (fabs(light->spot_aspect)>LIB3DS_EPSILON) { /*---- LIB3DS_DL_SPOT_ASPECT ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_DL_SPOT_ASPECT;
+ c.size=10;
+ lib3ds_chunk_write(&c, io);
+ lib3ds_io_write_float(io, light->spot_aspect);
+ }
+ if (light->use_projector) { /*---- LIB3DS_DL_SPOT_PROJECTOR ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_DL_SPOT_PROJECTOR;
+ c.size=10;
+ lib3ds_chunk_write(&c, io);
+ lib3ds_io_write_string(io, light->projector);
+ }
+ if (light->spot_overshoot) { /*---- LIB3DS_DL_SPOT_OVERSHOOT ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_DL_SPOT_OVERSHOOT;
+ c.size=6;
+ lib3ds_chunk_write(&c, io);
+ }
+ if (fabs(light->ray_bias)>LIB3DS_EPSILON) { /*---- LIB3DS_DL_RAY_BIAS ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_DL_RAY_BIAS;
+ c.size=10;
+ lib3ds_chunk_write(&c, io);
+ lib3ds_io_write_float(io, light->ray_bias);
+ }
+ if (light->ray_shadows) { /*---- LIB3DS_DL_RAYSHAD ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_DL_RAYSHAD;
+ c.size=6;
+ lib3ds_chunk_write(&c, io);
+ }
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ return(LIB3DS_TRUE);
+}
+
+
--- /dev/null
+/* -*- c -*- */
+#ifndef INCLUDED_LIB3DS_LIGHT_H
+#define INCLUDED_LIB3DS_LIGHT_H
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: light.h,v 1.10 2004/12/31 16:17:15 reed Exp $
+ */
+
+#ifndef INCLUDED_LIB3DS_TYPES_H
+#include <lib3ds/types.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*!
+ * Light
+ * \ingroup light
+ */
+struct _Lib3dsLight {
+ Lib3dsLight *next;
+ char name[64];
+ Lib3dsBool spot_light;
+ Lib3dsBool see_cone;
+ Lib3dsRgb color;
+ Lib3dsVector position;
+ Lib3dsVector spot;
+ Lib3dsFloat roll;
+ Lib3dsBool off;
+ Lib3dsFloat outer_range;
+ Lib3dsFloat inner_range;
+ Lib3dsFloat multiplier;
+ /*const char** excludes;*/
+ Lib3dsFloat attenuation;
+ Lib3dsBool rectangular_spot;
+ Lib3dsBool shadowed;
+ Lib3dsFloat shadow_bias;
+ Lib3dsFloat shadow_filter;
+ Lib3dsIntw shadow_size;
+ Lib3dsFloat spot_aspect;
+ Lib3dsBool use_projector;
+ char projector[64];
+ Lib3dsIntd spot_overshoot;
+ Lib3dsBool ray_shadows;
+ Lib3dsFloat ray_bias;
+ Lib3dsFloat hot_spot;
+ Lib3dsFloat fall_off;
+};
+
+extern LIB3DSAPI Lib3dsLight* lib3ds_light_new(const char *name);
+extern LIB3DSAPI void lib3ds_light_free(Lib3dsLight *mesh);
+extern LIB3DSAPI void lib3ds_light_dump(Lib3dsLight *light);
+extern LIB3DSAPI Lib3dsBool lib3ds_light_read(Lib3dsLight *light, Lib3dsIo *io);
+extern LIB3DSAPI Lib3dsBool lib3ds_light_write(Lib3dsLight *light, Lib3dsIo *io);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+
--- /dev/null
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: material.c,v 1.18 2004/11/20 08:31:31 efalk Exp $
+ */
+#define LIB3DS_EXPORT
+#include <lib3ds/material.h>
+#include <lib3ds/chunk.h>
+#include <lib3ds/io.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+#ifdef WITH_DMALLOC
+#include <dmalloc.h>
+#endif
+
+
+/*!
+ * \defgroup material Materials
+ *
+ * \author J.E. Hoffmann <je-h@gmx.net>
+ */
+
+
+static void
+initialize_texture_map(Lib3dsTextureMap *map)
+{
+ map->flags = 0x10;
+ map->percent = 1.0f;
+ map->scale[0] = 1.0f;
+ map->scale[1] = 1.0f;
+}
+
+
+/*!
+ * Creates and returns a new, empty Lib3dsMaterial object.
+ *
+ * Initial value of the material is a shiny grey.
+ *
+ * \return A pointer to the Lib3dsMaterial structure.
+ * If the structure cannot be allocated, NULL is returned.
+ *
+ * \ingroup material
+ */
+Lib3dsMaterial*
+lib3ds_material_new()
+{
+ Lib3dsMaterial *mat;
+
+ mat = (Lib3dsMaterial*)calloc(sizeof(Lib3dsMaterial), 1);
+ if (!mat) {
+ return(0);
+ }
+
+ mat->ambient[0] = mat->ambient[1] = mat->ambient[2] = 0.588235f;
+ mat->diffuse[0] = mat->diffuse[1] = mat->diffuse[2] = 0.588235f;
+ mat->specular[0] = mat->specular[1] = mat->specular[2] = 0.898039f;
+ mat->shininess = 0.1f;
+ mat->wire_size = 1.0f;
+ mat->shading = 3;
+
+ initialize_texture_map(&mat->texture1_map);
+ initialize_texture_map(&mat->texture1_mask);
+ initialize_texture_map(&mat->texture2_map);
+ initialize_texture_map(&mat->texture2_mask);
+ initialize_texture_map(&mat->opacity_map);
+ initialize_texture_map(&mat->opacity_mask);
+ initialize_texture_map(&mat->bump_map);
+ initialize_texture_map(&mat->bump_mask);
+ initialize_texture_map(&mat->specular_map);
+ initialize_texture_map(&mat->specular_mask);
+ initialize_texture_map(&mat->shininess_map);
+ initialize_texture_map(&mat->shininess_mask);
+ initialize_texture_map(&mat->self_illum_map);
+ initialize_texture_map(&mat->self_illum_mask);
+ initialize_texture_map(&mat->reflection_map);
+ initialize_texture_map(&mat->reflection_mask);
+
+ return(mat);
+}
+
+
+/*!
+ * \ingroup material
+ */
+void
+lib3ds_material_free(Lib3dsMaterial *material)
+{
+ memset(material, 0, sizeof(Lib3dsMaterial));
+ free(material);
+}
+
+
+static Lib3dsBool
+color_read(Lib3dsRgba rgb, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+ Lib3dsWord chunk;
+ Lib3dsBool have_lin=LIB3DS_FALSE;
+
+ if (!lib3ds_chunk_read_start(&c, 0, io)) {
+ return(LIB3DS_FALSE);
+ }
+
+ while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
+ switch (chunk) {
+ case LIB3DS_LIN_COLOR_24:
+ {
+ int i;
+ for (i=0; i<3; ++i) {
+ rgb[i]=1.0f*lib3ds_io_read_byte(io)/255.0f;
+ }
+ rgb[3]=1.0f;
+ }
+ have_lin=LIB3DS_TRUE;
+ break;
+ case LIB3DS_COLOR_24:
+ /* gamma corrected color chunk
+ replaced in 3ds R3 by LIN_COLOR_24 */
+ if (!have_lin) {
+ int i;
+ for (i=0; i<3; ++i) {
+ rgb[i]=1.0f*lib3ds_io_read_byte(io)/255.0f;
+ }
+ rgb[3]=1.0f;
+ }
+ break;
+ default:
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+
+ lib3ds_chunk_read_end(&c, io);
+ return(LIB3DS_TRUE);
+}
+
+
+static Lib3dsBool
+int_percentage_read(Lib3dsFloat *p, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+ Lib3dsWord chunk;
+
+ if (!lib3ds_chunk_read_start(&c, 0, io)) {
+ return(LIB3DS_FALSE);
+ }
+
+ while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
+ switch (chunk) {
+ case LIB3DS_INT_PERCENTAGE:
+ {
+ Lib3dsIntw i=lib3ds_io_read_intw(io);
+ *p=(Lib3dsFloat)(1.0*i/100.0);
+ }
+ break;
+ default:
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+
+ lib3ds_chunk_read_end(&c, io);
+ return(LIB3DS_TRUE);
+}
+
+
+static Lib3dsBool
+texture_map_read(Lib3dsTextureMap *map, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+ Lib3dsWord chunk;
+
+ if (!lib3ds_chunk_read_start(&c, 0, io)) {
+ return(LIB3DS_FALSE);
+ }
+
+ while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
+ switch (chunk) {
+ case LIB3DS_INT_PERCENTAGE:
+ {
+ map->percent=1.0f*lib3ds_io_read_intw(io)/100.0f;
+ }
+ break;
+ case LIB3DS_MAT_MAPNAME:
+ {
+ if (!lib3ds_io_read_string(io, map->name, 64)) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_chunk_dump_info(" NAME=%s", map->name);
+ }
+ break;
+ case LIB3DS_MAT_MAP_TILING:
+ {
+ map->flags=lib3ds_io_read_word(io);
+ }
+ break;
+ case LIB3DS_MAT_MAP_TEXBLUR:
+ {
+ map->blur=lib3ds_io_read_float(io);
+ }
+ break;
+ case LIB3DS_MAT_MAP_USCALE:
+ {
+ map->scale[0]=lib3ds_io_read_float(io);
+ }
+ break;
+ case LIB3DS_MAT_MAP_VSCALE:
+ {
+ map->scale[1]=lib3ds_io_read_float(io);
+ }
+ break;
+ case LIB3DS_MAT_MAP_UOFFSET:
+ {
+ map->offset[0]=lib3ds_io_read_float(io);
+ }
+ break;
+ case LIB3DS_MAT_MAP_VOFFSET:
+ {
+ map->offset[1]=lib3ds_io_read_float(io);
+ }
+ break;
+ case LIB3DS_MAT_MAP_ANG:
+ {
+ map->rotation=lib3ds_io_read_float(io);
+ }
+ break;
+ case LIB3DS_MAT_MAP_COL1:
+ {
+ map->tint_1[0]=1.0f*lib3ds_io_read_byte(io)/255.0f;
+ map->tint_1[1]=1.0f*lib3ds_io_read_byte(io)/255.0f;
+ map->tint_1[2]=1.0f*lib3ds_io_read_byte(io)/255.0f;
+ }
+ break;
+ case LIB3DS_MAT_MAP_COL2:
+ {
+ map->tint_2[0]=1.0f*lib3ds_io_read_byte(io)/255.0f;
+ map->tint_2[1]=1.0f*lib3ds_io_read_byte(io)/255.0f;
+ map->tint_2[2]=1.0f*lib3ds_io_read_byte(io)/255.0f;
+ }
+ break;
+ case LIB3DS_MAT_MAP_RCOL:
+ {
+ map->tint_r[0]=1.0f*lib3ds_io_read_byte(io)/255.0f;
+ map->tint_r[1]=1.0f*lib3ds_io_read_byte(io)/255.0f;
+ map->tint_r[2]=1.0f*lib3ds_io_read_byte(io)/255.0f;
+ }
+ break;
+ case LIB3DS_MAT_MAP_GCOL:
+ {
+ map->tint_g[0]=1.0f*lib3ds_io_read_byte(io)/255.0f;
+ map->tint_g[1]=1.0f*lib3ds_io_read_byte(io)/255.0f;
+ map->tint_g[2]=1.0f*lib3ds_io_read_byte(io)/255.0f;
+ }
+ break;
+ case LIB3DS_MAT_MAP_BCOL:
+ {
+ map->tint_b[0]=1.0f*lib3ds_io_read_byte(io)/255.0f;
+ map->tint_b[1]=1.0f*lib3ds_io_read_byte(io)/255.0f;
+ map->tint_b[2]=1.0f*lib3ds_io_read_byte(io)/255.0f;
+ }
+ break;
+ default:
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+
+ lib3ds_chunk_read_end(&c, io);
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup material
+ */
+static void
+texture_dump(const char *maptype, Lib3dsTextureMap *texture)
+{
+ ASSERT(texture);
+ if (strlen(texture->name)==0) {
+ return;
+ }
+ printf(" %s:\n", maptype);
+ printf(" name: %s\n", texture->name);
+ printf(" flags: %X\n", (unsigned)texture->flags);
+ printf(" percent: %f\n", texture->percent);
+ printf(" blur: %f\n", texture->blur);
+ printf(" scale: (%f, %f)\n", texture->scale[0], texture->scale[1]);
+ printf(" offset: (%f, %f)\n", texture->offset[0], texture->offset[1]);
+ printf(" rotation: %f\n", texture->rotation);
+ printf(" tint_1: (%f, %f, %f)\n",
+ texture->tint_1[0], texture->tint_1[1], texture->tint_1[2]);
+ printf(" tint_2: (%f, %f, %f)\n",
+ texture->tint_2[0], texture->tint_2[1], texture->tint_2[2]);
+ printf(" tint_r: (%f, %f, %f)\n",
+ texture->tint_r[0], texture->tint_r[1], texture->tint_r[2]);
+ printf(" tint_g: (%f, %f, %f)\n",
+ texture->tint_g[0], texture->tint_g[1], texture->tint_g[2]);
+ printf(" tint_b: (%f, %f, %f)\n",
+ texture->tint_b[0], texture->tint_b[1], texture->tint_b[2]);
+}
+
+
+/*!
+ * \ingroup material
+ */
+void
+lib3ds_material_dump(Lib3dsMaterial *material)
+{
+ ASSERT(material);
+ printf(" name: %s\n", material->name);
+ printf(" ambient: (%f, %f, %f)\n",
+ material->ambient[0], material->ambient[1], material->ambient[2]);
+ printf(" diffuse: (%f, %f, %f)\n",
+ material->diffuse[0], material->diffuse[1], material->diffuse[2]);
+ printf(" specular: (%f, %f, %f)\n",
+ material->specular[0], material->specular[1], material->specular[2]);
+ printf(" shininess: %f\n", material->shininess);
+ printf(" shin_strength: %f\n", material->shin_strength);
+ printf(" use_blur: %s\n", material->use_blur ? "yes" : "no");
+ printf(" blur: %f\n", material->blur);
+ printf(" falloff: %f\n", material->falloff);
+ printf(" additive: %s\n", material->additive ? "yes" : "no");
+ printf(" use_falloff: %s\n", material->use_falloff ? "yes" : "no");
+ printf(" self_illum: %s\n", material->self_illum ? "yes" : "no");
+ printf(" self_ilpct: %f\n", material->self_ilpct);
+ printf(" shading: %d\n", material->shading);
+ printf(" soften: %s\n", material->soften ? "yes" : "no");
+ printf(" face_map: %s\n", material->face_map ? "yes" : "no");
+ printf(" two_sided: %s\n", material->two_sided ? "yes" : "no");
+ printf(" map_decal: %s\n", material->map_decal ? "yes" : "no");
+ printf(" use_wire: %s\n", material->use_wire ? "yes" : "no");
+ printf(" use_wire_abs: %s\n", material->use_wire_abs ? "yes" : "no");
+ printf(" wire_size: %f\n", material->wire_size);
+ texture_dump("texture1_map", &material->texture1_map);
+ texture_dump("texture1_mask", &material->texture1_mask);
+ texture_dump("texture2_map", &material->texture2_map);
+ texture_dump("texture2_mask", &material->texture2_mask);
+ texture_dump("opacity_map", &material->opacity_map);
+ texture_dump("opacity_mask", &material->opacity_mask);
+ texture_dump("bump_map", &material->bump_map);
+ texture_dump("bump_mask", &material->bump_mask);
+ texture_dump("specular_map", &material->specular_map);
+ texture_dump("specular_mask", &material->specular_mask);
+ texture_dump("shininess_map", &material->shininess_map);
+ texture_dump("shininess_mask", &material->shininess_mask);
+ texture_dump("self_illum_map", &material->self_illum_map);
+ texture_dump("self_illum_mask", &material->self_illum_mask);
+ texture_dump("reflection_map", &material->reflection_map);
+ texture_dump("reflection_mask", &material->reflection_mask);
+ printf(" autorefl_map:\n");
+ printf(" flags %X\n", (unsigned)material->autorefl_map.flags);
+ printf(" level %d\n", (int)material->autorefl_map.level);
+ printf(" size %d\n", (int)material->autorefl_map.size);
+ printf(" frame_step %d\n", (int)material->autorefl_map.frame_step);
+ printf("\n");
+}
+
+
+/*!
+ * \ingroup material
+ */
+Lib3dsBool
+lib3ds_material_read(Lib3dsMaterial *material, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+ Lib3dsWord chunk;
+
+ ASSERT(material);
+ if (!lib3ds_chunk_read_start(&c, LIB3DS_MAT_ENTRY, io)) {
+ return(LIB3DS_FALSE);
+ }
+
+ while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
+ switch (chunk) {
+ case LIB3DS_MAT_NAME:
+ {
+ if (!lib3ds_io_read_string(io, material->name, 64)) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_chunk_dump_info(" NAME=%s", material->name);
+ }
+ break;
+ case LIB3DS_MAT_AMBIENT:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!color_read(material->ambient, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_MAT_DIFFUSE:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!color_read(material->diffuse, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_MAT_SPECULAR:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!color_read(material->specular, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_MAT_SHININESS:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!int_percentage_read(&material->shininess, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_MAT_SHIN2PCT:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!int_percentage_read(&material->shin_strength, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_MAT_TRANSPARENCY:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!int_percentage_read(&material->transparency, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_MAT_XPFALL:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!int_percentage_read(&material->falloff, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_MAT_SELF_ILPCT:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!int_percentage_read(&material->self_ilpct, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_MAT_USE_XPFALL:
+ {
+ material->use_falloff=LIB3DS_TRUE;
+ }
+ break;
+ case LIB3DS_MAT_REFBLUR:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!int_percentage_read(&material->blur, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_MAT_USE_REFBLUR:
+ {
+ material->use_blur=LIB3DS_TRUE;
+ }
+ break;
+ case LIB3DS_MAT_SHADING:
+ {
+ material->shading=lib3ds_io_read_intw(io);
+ }
+ break;
+ case LIB3DS_MAT_SELF_ILLUM:
+ {
+ material->self_illum=LIB3DS_TRUE;
+ }
+ break;
+ case LIB3DS_MAT_TWO_SIDE:
+ {
+ material->two_sided=LIB3DS_TRUE;
+ }
+ break;
+ case LIB3DS_MAT_DECAL:
+ {
+ material->map_decal=LIB3DS_TRUE;
+ }
+ break;
+ case LIB3DS_MAT_ADDITIVE:
+ {
+ material->additive=LIB3DS_TRUE;
+ }
+ break;
+ case LIB3DS_MAT_FACEMAP:
+ {
+ material->face_map=LIB3DS_TRUE;
+ }
+ break;
+ case LIB3DS_MAT_PHONGSOFT:
+ {
+ material->soften=LIB3DS_TRUE;
+ }
+ break;
+ case LIB3DS_MAT_WIRE:
+ {
+ material->use_wire=LIB3DS_TRUE;
+ }
+ break;
+ case LIB3DS_MAT_WIREABS:
+ {
+ material->use_wire_abs=LIB3DS_TRUE;
+ }
+ break;
+ case LIB3DS_MAT_WIRE_SIZE:
+ {
+ material->wire_size=lib3ds_io_read_float(io);
+ }
+ break;
+ case LIB3DS_MAT_TEXMAP:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!texture_map_read(&material->texture1_map, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_MAT_TEXMASK:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!texture_map_read(&material->texture1_mask, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_MAT_TEX2MAP:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!texture_map_read(&material->texture2_map, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_MAT_TEX2MASK:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!texture_map_read(&material->texture2_mask, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_MAT_OPACMAP:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!texture_map_read(&material->opacity_map, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_MAT_OPACMASK:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!texture_map_read(&material->opacity_mask, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_MAT_BUMPMAP:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!texture_map_read(&material->bump_map, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_MAT_BUMPMASK:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!texture_map_read(&material->bump_mask, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_MAT_SPECMAP:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!texture_map_read(&material->specular_map, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_MAT_SPECMASK:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!texture_map_read(&material->specular_mask, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_MAT_SHINMAP:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!texture_map_read(&material->shininess_map, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_MAT_SHINMASK:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!texture_map_read(&material->shininess_mask, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_MAT_SELFIMAP:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!texture_map_read(&material->self_illum_map, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_MAT_SELFIMASK:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!texture_map_read(&material->self_illum_mask, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_MAT_REFLMAP:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!texture_map_read(&material->reflection_map, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_MAT_REFLMASK:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!texture_map_read(&material->reflection_mask, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_MAT_ACUBIC:
+ {
+ lib3ds_io_read_intb(io);
+ material->autorefl_map.level=lib3ds_io_read_intb(io);
+ material->autorefl_map.flags=lib3ds_io_read_intw(io);
+ material->autorefl_map.size=lib3ds_io_read_intd(io);
+ material->autorefl_map.frame_step=lib3ds_io_read_intd(io);
+ }
+ break;
+ default:
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+
+ lib3ds_chunk_read_end(&c, io);
+ return(LIB3DS_TRUE);
+}
+
+
+static Lib3dsBool
+color_write(Lib3dsRgba rgb, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+
+ c.chunk=LIB3DS_COLOR_24;
+ c.size=9;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*rgb[0]+0.5));
+ lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*rgb[1]+0.5));
+ lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*rgb[2]+0.5));
+
+ c.chunk=LIB3DS_LIN_COLOR_24;
+ c.size=9;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*rgb[0]+0.5));
+ lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*rgb[1]+0.5));
+ lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*rgb[2]+0.5));
+
+ return(LIB3DS_TRUE);
+}
+
+
+static Lib3dsBool
+int_percentage_write(Lib3dsFloat p, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+
+ c.chunk=LIB3DS_INT_PERCENTAGE;
+ c.size=8;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_intw(io, (Lib3dsByte)floor(100.0*p+0.5));
+
+ return(LIB3DS_TRUE);
+}
+
+
+static Lib3dsBool
+texture_map_write(Lib3dsWord chunk, Lib3dsTextureMap *map, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+
+ if (strlen(map->name)==0) {
+ return(LIB3DS_TRUE);
+ }
+ c.chunk=chunk;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+
+ int_percentage_write(map->percent,io);
+
+ { /*---- LIB3DS_MAT_MAPNAME ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_MAPNAME;
+ c.size=6+strlen(map->name)+1;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_string(io, map->name);
+ }
+
+ { /*---- LIB3DS_MAT_MAP_TILING ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_MAP_TILING;
+ c.size=8;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_word(io, (Lib3dsWord)map->flags);
+ }
+
+ { /*---- LIB3DS_MAT_MAP_TEXBLUR ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_MAP_TEXBLUR;
+ c.size=10;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_float(io, map->blur);
+ }
+
+ { /*---- LIB3DS_MAT_MAP_USCALE ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_MAP_USCALE;
+ c.size=10;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_float(io, map->scale[0]);
+ }
+
+ { /*---- LIB3DS_MAT_MAP_VSCALE ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_MAP_VSCALE;
+ c.size=10;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_float(io, map->scale[1]);
+ }
+
+ { /*---- LIB3DS_MAT_MAP_UOFFSET ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_MAP_UOFFSET;
+ c.size=10;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_float(io, map->offset[0]);
+ }
+
+ { /*---- LIB3DS_MAT_MAP_VOFFSET ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_MAP_VOFFSET;
+ c.size=10;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_float(io, map->offset[1]);
+ }
+
+ { /*---- LIB3DS_MAT_MAP_ANG ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_MAP_ANG;
+ c.size=10;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_float(io, map->rotation);
+ }
+
+ { /*---- LIB3DS_MAT_MAP_COL1 ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_MAP_COL1;
+ c.size=9;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_1[0]+0.5));
+ lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_1[1]+0.5));
+ lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_1[2]+0.5));
+ }
+
+ { /*---- LIB3DS_MAT_MAP_COL2 ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_MAP_COL2;
+ c.size=9;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_2[0]+0.5));
+ lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_2[1]+0.5));
+ lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_2[2]+0.5));
+ }
+
+ { /*---- LIB3DS_MAT_MAP_RCOL ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_MAP_RCOL;
+ c.size=9;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_r[0]+0.5));
+ lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_r[1]+0.5));
+ lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_r[2]+0.5));
+ }
+
+ { /*---- LIB3DS_MAT_MAP_GCOL ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_MAP_GCOL;
+ c.size=9;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_g[0]+0.5));
+ lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_g[1]+0.5));
+ lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_g[2]+0.5));
+ }
+
+ { /*---- LIB3DS_MAT_MAP_BCOL ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_MAP_BCOL;
+ c.size=9;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_b[0]+0.5));
+ lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_b[1]+0.5));
+ lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_b[2]+0.5));
+ }
+
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup material
+ */
+Lib3dsBool
+lib3ds_material_write(Lib3dsMaterial *material, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+
+ c.chunk=LIB3DS_MAT_ENTRY;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+
+ { /*---- LIB3DS_MAT_NAME ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_NAME;
+ c.size=6+strlen(material->name)+1;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_string(io, material->name);
+ }
+
+ { /*---- LIB3DS_MAT_AMBIENT ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_AMBIENT;
+ c.size=24;
+ lib3ds_chunk_write(&c,io);
+ color_write(material->ambient,io);
+ }
+
+ { /*---- LIB3DS_MAT_DIFFUSE ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_DIFFUSE;
+ c.size=24;
+ lib3ds_chunk_write(&c,io);
+ color_write(material->diffuse,io);
+ }
+
+ { /*---- LIB3DS_MAT_SPECULAR ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_SPECULAR;
+ c.size=24;
+ lib3ds_chunk_write(&c,io);
+ color_write(material->specular,io);
+ }
+
+ { /*---- LIB3DS_MAT_SHININESS ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_SHININESS;
+ c.size=14;
+ lib3ds_chunk_write(&c,io);
+ int_percentage_write(material->shininess,io);
+ }
+
+ { /*---- LIB3DS_MAT_SHIN2PCT ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_SHIN2PCT;
+ c.size=14;
+ lib3ds_chunk_write(&c,io);
+ int_percentage_write(material->shin_strength,io);
+ }
+
+ { /*---- LIB3DS_MAT_TRANSPARENCY ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_TRANSPARENCY;
+ c.size=14;
+ lib3ds_chunk_write(&c,io);
+ int_percentage_write(material->transparency,io);
+ }
+
+ { /*---- LIB3DS_MAT_XPFALL ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_XPFALL;
+ c.size=14;
+ lib3ds_chunk_write(&c,io);
+ int_percentage_write(material->falloff,io);
+ }
+
+ if (material->use_falloff) { /*---- LIB3DS_MAT_USE_XPFALL ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_USE_XPFALL;
+ c.size=6;
+ lib3ds_chunk_write(&c,io);
+ }
+
+ { /*---- LIB3DS_MAT_SHADING ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_SHADING;
+ c.size=8;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_intw(io, material->shading);
+ }
+
+ { /*---- LIB3DS_MAT_REFBLUR ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_REFBLUR;
+ c.size=14;
+ lib3ds_chunk_write(&c,io);
+ int_percentage_write(material->blur,io);
+ }
+
+ if (material->use_blur) { /*---- LIB3DS_MAT_USE_REFBLUR ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_USE_REFBLUR;
+ c.size=6;
+ lib3ds_chunk_write(&c,io);
+ }
+
+ if (material->self_illum) { /*---- LIB3DS_MAT_SELF_ILLUM ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_SELF_ILLUM;
+ c.size=6;
+ lib3ds_chunk_write(&c,io);
+ }
+
+ if (material->two_sided) { /*---- LIB3DS_MAT_TWO_SIDE ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_TWO_SIDE;
+ c.size=6;
+ lib3ds_chunk_write(&c,io);
+ }
+
+ if (material->map_decal) { /*---- LIB3DS_MAT_DECAL ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_DECAL;
+ c.size=6;
+ lib3ds_chunk_write(&c,io);
+ }
+
+ if (material->additive) { /*---- LIB3DS_MAT_ADDITIVE ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_ADDITIVE;
+ c.size=6;
+ lib3ds_chunk_write(&c,io);
+ }
+
+ if (material->use_wire) { /*---- LIB3DS_MAT_WIRE ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_WIRE;
+ c.size=6;
+ lib3ds_chunk_write(&c,io);
+ }
+
+ if (material->use_wire_abs) { /*---- LIB3DS_MAT_WIREABS ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_WIREABS;
+ c.size=6;
+ lib3ds_chunk_write(&c,io);
+ }
+
+ { /*---- LIB3DS_MAT_WIRE_SIZE ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_WIRE_SIZE;
+ c.size=10;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_float(io, material->wire_size);
+ }
+
+ if (material->face_map) { /*---- LIB3DS_MAT_FACEMAP ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_FACEMAP;
+ c.size=6;
+ lib3ds_chunk_write(&c,io);
+ }
+
+ if (material->soften) { /*---- LIB3DS_MAT_PHONGSOFT ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MAT_PHONGSOFT;
+ c.size=6;
+ lib3ds_chunk_write(&c,io);
+ }
+
+ if (!texture_map_write(LIB3DS_MAT_TEXMAP, &material->texture1_map, io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!texture_map_write(LIB3DS_MAT_TEXMASK, &material->texture1_mask, io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!texture_map_write(LIB3DS_MAT_TEX2MAP, &material->texture2_map, io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!texture_map_write(LIB3DS_MAT_TEX2MASK, &material->texture2_mask, io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!texture_map_write(LIB3DS_MAT_OPACMAP, &material->opacity_map, io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!texture_map_write(LIB3DS_MAT_OPACMASK, &material->opacity_mask, io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!texture_map_write(LIB3DS_MAT_BUMPMAP, &material->bump_map, io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!texture_map_write(LIB3DS_MAT_BUMPMASK, &material->bump_mask, io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!texture_map_write(LIB3DS_MAT_SPECMAP, &material->specular_map, io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!texture_map_write(LIB3DS_MAT_SPECMASK, &material->specular_mask, io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!texture_map_write(LIB3DS_MAT_SHINMAP, &material->shininess_map, io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!texture_map_write(LIB3DS_MAT_SHINMASK, &material->shininess_mask, io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!texture_map_write(LIB3DS_MAT_SELFIMAP, &material->self_illum_map, io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!texture_map_write(LIB3DS_MAT_SELFIMASK, &material->self_illum_mask, io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!texture_map_write(LIB3DS_MAT_REFLMAP, &material->reflection_map, io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!texture_map_write(LIB3DS_MAT_REFLMASK, &material->reflection_mask, io)) {
+ return(LIB3DS_FALSE);
+ }
+
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+
+\typedef Lib3dsMaterial
+ \ingroup material
+ \sa _Lib3dsMaterial
+
+*/
+
--- /dev/null
+/* -*- c -*- */
+#ifndef INCLUDED_LIB3DS_MATERIAL_H
+#define INCLUDED_LIB3DS_MATERIAL_H
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: material.h,v 1.15 2004/12/31 16:17:15 reed Exp $
+ */
+
+#ifndef INCLUDED_LIB3DS_TYPES_H
+#include <lib3ds/types.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*!
+ * \ingroup material
+ */
+typedef enum _Lib3dsTextureMapFlags {
+ LIB3DS_DECALE =0x0001,
+ LIB3DS_MIRROR =0x0002,
+ LIB3DS_NEGATE =0x0004,
+ LIB3DS_NO_TILE =0x0008,
+ LIB3DS_SUMMED_AREA =0x0010,
+ LIB3DS_ALPHA_SOURCE =0x0020,
+ LIB3DS_TINT =0x0040,
+ LIB3DS_IGNORE_ALPHA =0x0080,
+ LIB3DS_RGB_TINT =0x0100
+} Lib3dsTextureMapFlags;
+
+/*!
+ * Mateial texture map
+ * \ingroup material
+ */
+typedef struct _Lib3dsTextureMap {
+ Lib3dsUserData user;
+ char name[64];
+ Lib3dsDword flags;
+ Lib3dsFloat percent;
+ Lib3dsFloat blur;
+ Lib3dsFloat scale[2];
+ Lib3dsFloat offset[2];
+ Lib3dsFloat rotation;
+ Lib3dsRgb tint_1;
+ Lib3dsRgb tint_2;
+ Lib3dsRgb tint_r;
+ Lib3dsRgb tint_g;
+ Lib3dsRgb tint_b;
+} Lib3dsTextureMap;
+
+/*!
+ * \ingroup material
+ */
+typedef enum _Lib3dsAutoReflMapFlags {
+ LIB3DS_USE_REFL_MAP =0x0001,
+ LIB3DS_READ_FIRST_FRAME_ONLY =0x0004,
+ LIB3DS_FLAT_MIRROR =0x0008
+} Lib3dsAutoReflectionMapFlags;
+
+/*!
+ * \ingroup material
+ */
+typedef enum _Lib3dsAutoReflMapAntiAliasLevel {
+ LIB3DS_ANTI_ALIAS_NONE =0,
+ LIB3DS_ANTI_ALIAS_LOW =1,
+ LIB3DS_ANTI_ALIAS_MEDIUM =2,
+ LIB3DS_ANTI_ALIAS_HIGH =3
+} Lib3dsAutoReflMapAntiAliasLevel;
+
+/*!
+ * Auto reflection map settings
+ * \ingroup material
+ */
+typedef struct _Lib3dsAutoReflMap {
+ Lib3dsDword flags;
+ Lib3dsIntd level;
+ Lib3dsIntd size;
+ Lib3dsIntd frame_step;
+} Lib3dsAutoReflMap;
+
+/*!
+ * \ingroup material
+ */
+typedef enum _Lib3dsMaterialShading {
+ LIB3DS_WIRE_FRAME =0,
+ LIB3DS_FLAT =1,
+ LIB3DS_GOURAUD =2,
+ LIB3DS_PHONG =3,
+ LIB3DS_METAL =4
+} Lib3dsMaterialShading;
+
+/*!
+ * Material
+ * \ingroup material
+ */
+struct _Lib3dsMaterial {
+ Lib3dsUserData user; /*! Arbitrary user data */
+ Lib3dsMaterial *next;
+ char name[64]; /*! Material name */
+ Lib3dsRgba ambient; /*! Material ambient reflectivity */
+ Lib3dsRgba diffuse; /*! Material diffuse reflectivity */
+ Lib3dsRgba specular; /*! Material specular reflectivity */
+ Lib3dsFloat shininess; /*! Material specular exponent */
+ Lib3dsFloat shin_strength;
+ Lib3dsBool use_blur;
+ Lib3dsFloat blur;
+ Lib3dsFloat transparency;
+ Lib3dsFloat falloff;
+ Lib3dsBool additive;
+ Lib3dsFloat self_ilpct;
+ Lib3dsBool use_falloff;
+ Lib3dsBool self_illum;
+ Lib3dsIntw shading;
+ Lib3dsBool soften;
+ Lib3dsBool face_map;
+ Lib3dsBool two_sided; /*! Material visible from back */
+ Lib3dsBool map_decal;
+ Lib3dsBool use_wire;
+ Lib3dsBool use_wire_abs;
+ Lib3dsFloat wire_size;
+ Lib3dsTextureMap texture1_map;
+ Lib3dsTextureMap texture1_mask;
+ Lib3dsTextureMap texture2_map;
+ Lib3dsTextureMap texture2_mask;
+ Lib3dsTextureMap opacity_map;
+ Lib3dsTextureMap opacity_mask;
+ Lib3dsTextureMap bump_map;
+ Lib3dsTextureMap bump_mask;
+ Lib3dsTextureMap specular_map;
+ Lib3dsTextureMap specular_mask;
+ Lib3dsTextureMap shininess_map;
+ Lib3dsTextureMap shininess_mask;
+ Lib3dsTextureMap self_illum_map;
+ Lib3dsTextureMap self_illum_mask;
+ Lib3dsTextureMap reflection_map;
+ Lib3dsTextureMap reflection_mask;
+ Lib3dsAutoReflMap autorefl_map;
+};
+
+extern LIB3DSAPI Lib3dsMaterial* lib3ds_material_new();
+extern LIB3DSAPI void lib3ds_material_free(Lib3dsMaterial *material);
+extern LIB3DSAPI void lib3ds_material_dump(Lib3dsMaterial *material);
+extern LIB3DSAPI Lib3dsBool lib3ds_material_read(Lib3dsMaterial *material, Lib3dsIo *io);
+extern LIB3DSAPI Lib3dsBool lib3ds_material_write(Lib3dsMaterial *material, Lib3dsIo *io);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+
+
--- /dev/null
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: matrix.c,v 1.10 2004/11/16 07:41:44 efalk Exp $
+ */
+#define LIB3DS_EXPORT
+#include <lib3ds/matrix.h>
+#include <lib3ds/quat.h>
+#include <lib3ds/vector.h>
+#include <string.h>
+#include <math.h>
+
+
+/*!
+ * \defgroup matrix Matrix Mathematics
+ *
+ * \author J.E. Hoffmann <je-h@gmx.net>
+ */
+/*!
+ * \typedef Lib3dsMatrix
+ * \ingroup matrix
+ */
+
+
+/*!
+ * Clear a matrix to all zeros.
+ *
+ * \param m Matrix to be cleared.
+ *
+ * \ingroup matrix
+ */
+void
+lib3ds_matrix_zero(Lib3dsMatrix m)
+{
+ int i,j;
+
+ for (i=0; i<4; i++) {
+ for (j=0; j<4; j++) m[i][j]=0.0f;
+ }
+}
+
+
+/*!
+ * Set a matrix to identity.
+ *
+ * \param m Matrix to be set.
+ *
+ * \ingroup matrix
+ */
+void
+lib3ds_matrix_identity(Lib3dsMatrix m)
+{
+ int i,j;
+
+ for (i=0; i<4; i++) {
+ for (j=0; j<4; j++) m[i][j]=0.0;
+ }
+ for (i=0; i<4; i++) m[i][i]=1.0;
+}
+
+
+/*!
+ * Copy a matrix.
+ *
+ * \ingroup matrix
+ */
+void
+lib3ds_matrix_copy(Lib3dsMatrix dest, Lib3dsMatrix src)
+{
+ memcpy(dest, src, sizeof(Lib3dsMatrix));
+}
+
+
+/*!
+ * Negate a matrix -- all elements negated.
+ *
+ * \ingroup matrix
+ */
+void
+lib3ds_matrix_neg(Lib3dsMatrix m)
+{
+ int i,j;
+
+ for (j=0; j<4; j++) {
+ for (i=0; i<4; i++) {
+ m[j][i]=-m[j][i];
+ }
+ }
+}
+
+
+/*!
+ * Set all matrix elements to their absolute value.
+ *
+ * \ingroup matrix
+ */
+void
+lib3ds_matrix_abs(Lib3dsMatrix m)
+{
+ int i,j;
+
+ for (j=0; j<4; j++) {
+ for (i=0; i<4; i++) {
+ m[j][i]=(Lib3dsFloat)fabs(m[j][i]);
+ }
+ }
+}
+
+
+/*!
+ * Transpose a matrix in place.
+ *
+ * \ingroup matrix
+ */
+void
+lib3ds_matrix_transpose(Lib3dsMatrix m)
+{
+ int i,j;
+ Lib3dsFloat swp;
+
+ for (j=0; j<4; j++) {
+ for (i=j+1; i<4; i++) {
+ swp=m[j][i];
+ m[j][i]=m[i][j];
+ m[i][j]=swp;
+ }
+ }
+}
+
+
+/*!
+ * Add two matrices.
+ *
+ * \ingroup matrix
+ */
+void
+lib3ds_matrix_add(Lib3dsMatrix m, Lib3dsMatrix a, Lib3dsMatrix b)
+{
+ int i,j;
+
+ for (j=0; j<4; j++) {
+ for (i=0; i<4; i++) {
+ m[j][i]=a[j][i]+b[j][i];
+ }
+ }
+}
+
+
+/*!
+ * Subtract two matrices.
+ *
+ * \param m Result.
+ * \param a Addend.
+ * \param b Minuend.
+ *
+ * \ingroup matrix
+ */
+void
+lib3ds_matrix_sub(Lib3dsMatrix m, Lib3dsMatrix a, Lib3dsMatrix b)
+{
+ int i,j;
+
+ for (j=0; j<4; j++) {
+ for (i=0; i<4; i++) {
+ m[j][i]=a[j][i]-b[j][i];
+ }
+ }
+}
+
+
+/*!
+ * Multiply two matrices.
+ *
+ * \param m Result.
+ * \param a Left matrix.
+ * \param b Right matrix.
+ *
+ * \ingroup matrix
+ */
+void
+lib3ds_matrix_mul(Lib3dsMatrix m, Lib3dsMatrix a, Lib3dsMatrix b)
+{
+ int i,j,k;
+ Lib3dsFloat ab;
+
+ for (j=0; j<4; j++) {
+ for (i=0; i<4; i++) {
+ ab=0.0f;
+ for (k=0; k<4; k++) ab+=a[k][i]*b[j][k];
+ m[j][i]=ab;
+ }
+ }
+}
+
+
+/*!
+ * Multiply a matrix by a scalar.
+ *
+ * \param m Matrix to be set.
+ * \param k Scalar.
+ *
+ * \ingroup matrix
+ */
+void
+lib3ds_matrix_scalar(Lib3dsMatrix m, Lib3dsFloat k)
+{
+ int i,j;
+
+ for (j=0; j<4; j++) {
+ for (i=0; i<4; i++) {
+ m[j][i]*=k;
+ }
+ }
+}
+
+
+static Lib3dsFloat
+det2x2(
+ Lib3dsFloat a, Lib3dsFloat b,
+ Lib3dsFloat c, Lib3dsFloat d)
+{
+ return((a)*(d)-(b)*(c));
+}
+
+
+static Lib3dsFloat
+det3x3(
+ Lib3dsFloat a1, Lib3dsFloat a2, Lib3dsFloat a3,
+ Lib3dsFloat b1, Lib3dsFloat b2, Lib3dsFloat b3,
+ Lib3dsFloat c1, Lib3dsFloat c2, Lib3dsFloat c3)
+{
+ return(
+ a1*det2x2(b2,b3,c2,c3)-
+ b1*det2x2(a2,a3,c2,c3)+
+ c1*det2x2(a2,a3,b2,b3)
+ );
+}
+
+
+/*!
+ * Find determinant of a matrix.
+ *
+ * \ingroup matrix
+ */
+Lib3dsFloat
+lib3ds_matrix_det(Lib3dsMatrix m)
+{
+ Lib3dsFloat a1,a2,a3,a4,b1,b2,b3,b4,c1,c2,c3,c4,d1,d2,d3,d4;
+
+ a1 = m[0][0];
+ b1 = m[1][0];
+ c1 = m[2][0];
+ d1 = m[3][0];
+ a2 = m[0][1];
+ b2 = m[1][1];
+ c2 = m[2][1];
+ d2 = m[3][1];
+ a3 = m[0][2];
+ b3 = m[1][2];
+ c3 = m[2][2];
+ d3 = m[3][2];
+ a4 = m[0][3];
+ b4 = m[1][3];
+ c4 = m[2][3];
+ d4 = m[3][3];
+ return(
+ a1 * det3x3(b2, b3, b4, c2, c3, c4, d2, d3, d4)-
+ b1 * det3x3(a2, a3, a4, c2, c3, c4, d2, d3, d4)+
+ c1 * det3x3(a2, a3, a4, b2, b3, b4, d2, d3, d4)-
+ d1 * det3x3(a2, a3, a4, b2, b3, b4, c2, c3, c4)
+ );
+}
+
+
+/*!
+ * Find the adjoint of a matrix.
+ *
+ * \ingroup matrix
+ */
+void
+lib3ds_matrix_adjoint(Lib3dsMatrix m)
+{
+ Lib3dsFloat a1,a2,a3,a4,b1,b2,b3,b4,c1,c2,c3,c4,d1,d2,d3,d4;
+
+ a1 = m[0][0];
+ b1 = m[1][0];
+ c1 = m[2][0];
+ d1 = m[3][0];
+ a2 = m[0][1];
+ b2 = m[1][1];
+ c2 = m[2][1];
+ d2 = m[3][1];
+ a3 = m[0][2];
+ b3 = m[1][2];
+ c3 = m[2][2];
+ d3 = m[3][2];
+ a4 = m[0][3];
+ b4 = m[1][3];
+ c4 = m[2][3];
+ d4 = m[3][3];
+ m[0][0]= det3x3 (b2, b3, b4, c2, c3, c4, d2, d3, d4);
+ m[0][1]= -det3x3 (a2, a3, a4, c2, c3, c4, d2, d3, d4);
+ m[0][2]= det3x3 (a2, a3, a4, b2, b3, b4, d2, d3, d4);
+ m[0][3]= -det3x3 (a2, a3, a4, b2, b3, b4, c2, c3, c4);
+ m[1][0]= -det3x3 (b1, b3, b4, c1, c3, c4, d1, d3, d4);
+ m[1][1]= det3x3 (a1, a3, a4, c1, c3, c4, d1, d3, d4);
+ m[1][2]= -det3x3 (a1, a3, a4, b1, b3, b4, d1, d3, d4);
+ m[1][3]= det3x3 (a1, a3, a4, b1, b3, b4, c1, c3, c4);
+ m[2][0]= det3x3 (b1, b2, b4, c1, c2, c4, d1, d2, d4);
+ m[2][1]= -det3x3 (a1, a2, a4, c1, c2, c4, d1, d2, d4);
+ m[2][2]= det3x3 (a1, a2, a4, b1, b2, b4, d1, d2, d4);
+ m[2][3]= -det3x3 (a1, a2, a4, b1, b2, b4, c1, c2, c4);
+ m[3][0]= -det3x3 (b1, b2, b3, c1, c2, c3, d1, d2, d3);
+ m[3][1]= det3x3 (a1, a2, a3, c1, c2, c3, d1, d2, d3);
+ m[3][2]= -det3x3 (a1, a2, a3, b1, b2, b3, d1, d2, d3);
+ m[3][3]= det3x3 (a1, a2, a3, b1, b2, b3, c1, c2, c3);
+}
+
+
+/*!
+ * Invert a matrix in place.
+ *
+ * \param m Matrix to invert.
+ *
+ * \return LIB3DS_TRUE on success, LIB3DS_FALSE on failure.
+ * \ingroup matrix
+ *
+ * GGemsII, K.Wu, Fast Matrix Inversion
+ */
+Lib3dsBool
+lib3ds_matrix_inv(Lib3dsMatrix m)
+{
+ int i,j,k;
+ int pvt_i[4], pvt_j[4]; /* Locations of pivot elements */
+ Lib3dsFloat pvt_val; /* Value of current pivot element */
+ Lib3dsFloat hold; /* Temporary storage */
+ Lib3dsFloat determinat;
+
+ determinat = 1.0f;
+ for (k=0; k<4; k++) {
+ /* Locate k'th pivot element */
+ pvt_val=m[k][k]; /* Initialize for search */
+ pvt_i[k]=k;
+ pvt_j[k]=k;
+ for (i=k; i<4; i++) {
+ for (j=k; j<4; j++) {
+ if (fabs(m[i][j]) > fabs(pvt_val)) {
+ pvt_i[k]=i;
+ pvt_j[k]=j;
+ pvt_val=m[i][j];
+ }
+ }
+ }
+
+ /* Product of pivots, gives determinant when finished */
+ determinat*=pvt_val;
+ if (fabs(determinat)<LIB3DS_EPSILON) {
+ return(LIB3DS_FALSE); /* Matrix is singular (zero determinant) */
+ }
+
+ /* "Interchange" rows (with sign change stuff) */
+ i=pvt_i[k];
+ if (i!=k) { /* If rows are different */
+ for (j=0; j<4; j++) {
+ hold=-m[k][j];
+ m[k][j]=m[i][j];
+ m[i][j]=hold;
+ }
+ }
+
+ /* "Interchange" columns */
+ j=pvt_j[k];
+ if (j!=k) { /* If columns are different */
+ for (i=0; i<4; i++) {
+ hold=-m[i][k];
+ m[i][k]=m[i][j];
+ m[i][j]=hold;
+ }
+ }
+
+ /* Divide column by minus pivot value */
+ for (i=0; i<4; i++) {
+ if (i!=k) m[i][k]/=( -pvt_val) ;
+ }
+
+ /* Reduce the matrix */
+ for (i=0; i<4; i++) {
+ hold = m[i][k];
+ for (j=0; j<4; j++) {
+ if (i!=k && j!=k) m[i][j]+=hold*m[k][j];
+ }
+ }
+
+ /* Divide row by pivot */
+ for (j=0; j<4; j++) {
+ if (j!=k) m[k][j]/=pvt_val;
+ }
+
+ /* Replace pivot by reciprocal (at last we can touch it). */
+ m[k][k] = 1.0f/pvt_val;
+ }
+
+ /* That was most of the work, one final pass of row/column interchange */
+ /* to finish */
+ for (k=4-2; k>=0; k--) { /* Don't need to work with 1 by 1 corner*/
+ i=pvt_j[k]; /* Rows to swap correspond to pivot COLUMN */
+ if (i!=k) { /* If rows are different */
+ for(j=0; j<4; j++) {
+ hold = m[k][j];
+ m[k][j]=-m[i][j];
+ m[i][j]=hold;
+ }
+ }
+
+ j=pvt_i[k]; /* Columns to swap correspond to pivot ROW */
+ if (j!=k) /* If columns are different */
+ for (i=0; i<4; i++) {
+ hold=m[i][k];
+ m[i][k]=-m[i][j];
+ m[i][j]=hold;
+ }
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * Apply a translation to a matrix.
+ *
+ * \ingroup matrix
+ */
+void
+lib3ds_matrix_translate_xyz(Lib3dsMatrix m, Lib3dsFloat x, Lib3dsFloat y, Lib3dsFloat z)
+{
+ int i;
+
+ for (i=0; i<3; i++) {
+ m[3][i]+= m[0][i]*x + m[1][i]*y + m[2][i]*z;
+ }
+}
+
+
+/*!
+ * Apply a translation to a matrix.
+ *
+ * \ingroup matrix
+ */
+void
+lib3ds_matrix_translate(Lib3dsMatrix m, Lib3dsVector t)
+{
+ int i;
+
+ for (i=0; i<3; i++) {
+ m[3][i]+= m[0][i]*t[0] + m[1][i]*t[1] + m[2][i]*t[2];
+ }
+}
+
+
+/*!
+ * Apply scale factors to a matrix.
+ *
+ * \ingroup matrix
+ */
+void
+lib3ds_matrix_scale_xyz(Lib3dsMatrix m, Lib3dsFloat x, Lib3dsFloat y, Lib3dsFloat z)
+{
+ int i;
+
+ for (i=0; i<4; i++) {
+ m[0][i]*=x;
+ m[1][i]*=y;
+ m[2][i]*=z;
+ }
+}
+
+
+/*!
+ * Apply scale factors to a matrix.
+ *
+ * \ingroup matrix
+ */
+void
+lib3ds_matrix_scale(Lib3dsMatrix m, Lib3dsVector s)
+{
+ int i;
+
+ for (i=0; i<4; i++) {
+ m[0][i]*=s[0];
+ m[1][i]*=s[1];
+ m[2][i]*=s[2];
+ }
+}
+
+
+/*!
+ * Apply a rotation about the x axis to a matrix.
+ *
+ * \ingroup matrix
+ */
+void
+lib3ds_matrix_rotate_x(Lib3dsMatrix m, Lib3dsFloat phi)
+{
+ Lib3dsFloat SinPhi,CosPhi;
+ Lib3dsFloat a1[4],a2[4];
+
+ SinPhi=(Lib3dsFloat)sin(phi);
+ CosPhi=(Lib3dsFloat)cos(phi);
+ memcpy(a1,m[1],4*sizeof(Lib3dsFloat));
+ memcpy(a2,m[2],4*sizeof(Lib3dsFloat));
+ m[1][0]=CosPhi*a1[0]+SinPhi*a2[0];
+ m[1][1]=CosPhi*a1[1]+SinPhi*a2[1];
+ m[1][2]=CosPhi*a1[2]+SinPhi*a2[2];
+ m[1][3]=CosPhi*a1[3]+SinPhi*a2[3];
+ m[2][0]=-SinPhi*a1[0]+CosPhi*a2[0];
+ m[2][1]=-SinPhi*a1[1]+CosPhi*a2[1];
+ m[2][2]=-SinPhi*a1[2]+CosPhi*a2[2];
+ m[2][3]=-SinPhi*a1[3]+CosPhi*a2[3];
+}
+
+
+/*!
+ * Apply a rotation about the y axis to a matrix.
+ *
+ * \ingroup matrix
+ */
+void
+lib3ds_matrix_rotate_y(Lib3dsMatrix m, Lib3dsFloat phi)
+{
+ Lib3dsFloat SinPhi,CosPhi;
+ Lib3dsFloat a0[4],a2[4];
+
+ SinPhi=(Lib3dsFloat)sin(phi);
+ CosPhi=(Lib3dsFloat)cos(phi);
+ memcpy(a0,m[0],4*sizeof(Lib3dsFloat));
+ memcpy(a2,m[2],4*sizeof(Lib3dsFloat));
+ m[0][0]=CosPhi*a0[0]-SinPhi*a2[0];
+ m[0][1]=CosPhi*a0[1]-SinPhi*a2[1];
+ m[0][2]=CosPhi*a0[2]-SinPhi*a2[2];
+ m[0][3]=CosPhi*a0[3]-SinPhi*a2[3];
+ m[2][0]=SinPhi*a0[0]+CosPhi*a2[0];
+ m[2][1]=SinPhi*a0[1]+CosPhi*a2[1];
+ m[2][2]=SinPhi*a0[2]+CosPhi*a2[2];
+ m[2][3]=SinPhi*a0[3]+CosPhi*a2[3];
+}
+
+
+/*!
+ * Apply a rotation about the z axis to a matrix.
+ *
+ * \ingroup matrix
+ */
+void
+lib3ds_matrix_rotate_z(Lib3dsMatrix m, Lib3dsFloat phi)
+{
+ Lib3dsFloat SinPhi,CosPhi;
+ Lib3dsFloat a0[4],a1[4];
+
+ SinPhi=(Lib3dsFloat)sin(phi);
+ CosPhi=(Lib3dsFloat)cos(phi);
+ memcpy(a0,m[0],4*sizeof(Lib3dsFloat));
+ memcpy(a1,m[1],4*sizeof(Lib3dsFloat));
+ m[0][0]=CosPhi*a0[0]+SinPhi*a1[0];
+ m[0][1]=CosPhi*a0[1]+SinPhi*a1[1];
+ m[0][2]=CosPhi*a0[2]+SinPhi*a1[2];
+ m[0][3]=CosPhi*a0[3]+SinPhi*a1[3];
+ m[1][0]=-SinPhi*a0[0]+CosPhi*a1[0];
+ m[1][1]=-SinPhi*a0[1]+CosPhi*a1[1];
+ m[1][2]=-SinPhi*a0[2]+CosPhi*a1[2];
+ m[1][3]=-SinPhi*a0[3]+CosPhi*a1[3];
+}
+
+
+/*!
+ * Apply a rotation about an arbitrary axis to a matrix.
+ *
+ * \ingroup matrix
+ */
+void
+lib3ds_matrix_rotate(Lib3dsMatrix m, Lib3dsQuat q)
+{
+ Lib3dsFloat s,xs,ys,zs,wx,wy,wz,xx,xy,xz,yy,yz,zz,l;
+ Lib3dsMatrix a,b;
+
+ lib3ds_matrix_copy(a, m);
+
+ l=q[0]*q[0] + q[1]*q[1] + q[2]*q[2] + q[3]*q[3];
+ if (fabs(l)<LIB3DS_EPSILON) {
+ s=1.0f;
+ }
+ else {
+ s=2.0f/l;
+ }
+
+ xs = q[0] * s; ys = q[1] * s; zs = q[2] * s;
+ wx = q[3] * xs; wy = q[3] * ys; wz = q[3] * zs;
+ xx = q[0] * xs; xy = q[0] * ys; xz = q[0] * zs;
+ yy = q[1] * ys; yz = q[1] * zs; zz = q[2] * zs;
+
+ b[0][0]=1.0f - (yy +zz);
+ b[1][0]=xy - wz;
+ b[2][0]=xz + wy;
+ b[0][1]=xy + wz;
+ b[1][1]=1.0f - (xx +zz);
+ b[2][1]=yz - wx;
+ b[0][2]=xz - wy;
+ b[1][2]=yz + wx;
+ b[2][2]=1.0f - (xx + yy);
+ b[3][0]=b[3][1]=b[3][2]=b[0][3]=b[1][3]=b[2][3]=0.0f;
+ b[3][3]=1.0f;
+
+ lib3ds_matrix_mul(m,a,b);
+}
+
+
+/*!
+ * Apply a rotation about an arbitrary axis to a matrix.
+ *
+ * \ingroup matrix
+ */
+void
+lib3ds_matrix_rotate_axis(Lib3dsMatrix m, Lib3dsVector axis, Lib3dsFloat angle)
+{
+ Lib3dsQuat q;
+
+ lib3ds_quat_axis_angle(q,axis,angle);
+ lib3ds_matrix_rotate(m,q);
+}
+
+
+/*!
+ * Compute a camera matrix based on position, target and roll.
+ *
+ * Generates a translate/rotate matrix that maps world coordinates
+ * to camera coordinates. Resulting matrix does not include perspective
+ * transform.
+ *
+ * \param matrix Destination matrix.
+ * \param pos Camera position
+ * \param tgt Camera target
+ * \param roll Roll angle
+ *
+ * \ingroup matrix
+ */
+void
+lib3ds_matrix_camera(Lib3dsMatrix matrix, Lib3dsVector pos,
+ Lib3dsVector tgt, Lib3dsFloat roll)
+{
+ Lib3dsMatrix M,R;
+ Lib3dsVector x, y, z;
+
+ lib3ds_vector_sub(y, tgt, pos);
+ lib3ds_vector_normalize(y);
+
+ if (y[0] != 0. || y[1] != 0) {
+ z[0] = 0;
+ z[1] = 0;
+ z[2] = 1.0;
+ }
+ else { /* Special case: looking straight up or down z axis */
+ z[0] = -1.0;
+ z[1] = 0;
+ z[2] = 0;
+ }
+
+ lib3ds_vector_cross(x, y, z);
+ lib3ds_vector_cross(z, x, y);
+ lib3ds_vector_normalize(x);
+ lib3ds_vector_normalize(z);
+
+ lib3ds_matrix_identity(M);
+ M[0][0] = x[0];
+ M[1][0] = x[1];
+ M[2][0] = x[2];
+ M[0][1] = y[0];
+ M[1][1] = y[1];
+ M[2][1] = y[2];
+ M[0][2] = z[0];
+ M[1][2] = z[1];
+ M[2][2] = z[2];
+
+ lib3ds_matrix_identity(R);
+ lib3ds_matrix_rotate_y(R, roll);
+ lib3ds_matrix_mul(matrix, R,M);
+ lib3ds_matrix_translate_xyz(matrix, -pos[0],-pos[1],-pos[2]);
+}
+
+
+/*!
+ * \ingroup matrix
+ */
+void
+lib3ds_matrix_dump(Lib3dsMatrix matrix)
+{
+ int i,j;
+
+ for (i=0; i<4; ++i) {
+ for (j=0; j<4; ++j) {
+ printf("%f ", matrix[j][i]);
+ }
+ printf("\n");
+ }
+}
+
+
+
+
+
--- /dev/null
+/* -*- c -*- */
+#ifndef INCLUDED_LIB3DS_MATRIX_H
+#define INCLUDED_LIB3DS_MATRIX_H
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: matrix.h,v 1.5 2004/12/31 16:17:15 reed Exp $
+ */
+
+#ifndef INCLUDED_LIB3DS_TYPES_H
+#include <lib3ds/types.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern LIB3DSAPI void lib3ds_matrix_zero(Lib3dsMatrix m);
+extern LIB3DSAPI void lib3ds_matrix_identity(Lib3dsMatrix m);
+extern LIB3DSAPI void lib3ds_matrix_copy(Lib3dsMatrix dest, Lib3dsMatrix src);
+extern LIB3DSAPI void lib3ds_matrix_neg(Lib3dsMatrix m);
+extern LIB3DSAPI void lib3ds_matrix_abs(Lib3dsMatrix m);
+extern LIB3DSAPI void lib3ds_matrix_transpose(Lib3dsMatrix m);
+extern LIB3DSAPI void lib3ds_matrix_add(Lib3dsMatrix m, Lib3dsMatrix a, Lib3dsMatrix b);
+extern LIB3DSAPI void lib3ds_matrix_sub(Lib3dsMatrix m, Lib3dsMatrix a, Lib3dsMatrix b);
+extern LIB3DSAPI void lib3ds_matrix_mul(Lib3dsMatrix m, Lib3dsMatrix a, Lib3dsMatrix b);
+extern LIB3DSAPI void lib3ds_matrix_scalar(Lib3dsMatrix m, Lib3dsFloat k);
+extern LIB3DSAPI Lib3dsFloat lib3ds_matrix_det(Lib3dsMatrix m);
+extern LIB3DSAPI void lib3ds_matrix_adjoint(Lib3dsMatrix m);
+extern LIB3DSAPI Lib3dsBool lib3ds_matrix_inv(Lib3dsMatrix m);
+void lib3ds_matrix_translate_xyz(Lib3dsMatrix m, Lib3dsFloat x,
+ Lib3dsFloat y, Lib3dsFloat z);
+extern LIB3DSAPI void lib3ds_matrix_translate(Lib3dsMatrix m, Lib3dsVector t);
+extern LIB3DSAPI void lib3ds_matrix_scale_xyz(Lib3dsMatrix m, Lib3dsFloat x,
+ Lib3dsFloat y, Lib3dsFloat z);
+extern LIB3DSAPI void lib3ds_matrix_scale(Lib3dsMatrix m, Lib3dsVector s);
+extern LIB3DSAPI void lib3ds_matrix_rotate_x(Lib3dsMatrix m, Lib3dsFloat phi);
+extern LIB3DSAPI void lib3ds_matrix_rotate_y(Lib3dsMatrix m, Lib3dsFloat phi);
+extern LIB3DSAPI void lib3ds_matrix_rotate_z(Lib3dsMatrix m, Lib3dsFloat phi);
+extern LIB3DSAPI void lib3ds_matrix_rotate(Lib3dsMatrix m, Lib3dsQuat q);
+extern LIB3DSAPI void lib3ds_matrix_rotate_axis(Lib3dsMatrix m,
+ Lib3dsVector axis, Lib3dsFloat angle);
+extern LIB3DSAPI void lib3ds_matrix_camera(Lib3dsMatrix matrix, Lib3dsVector pos,
+ Lib3dsVector tgt, Lib3dsFloat roll);
+extern LIB3DSAPI void lib3ds_matrix_dump(Lib3dsMatrix matrix);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+
--- /dev/null
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: mesh.c,v 1.22 2004/11/20 08:33:56 efalk Exp $
+ */
+#define LIB3DS_EXPORT
+#include <lib3ds/mesh.h>
+#include <lib3ds/io.h>
+#include <lib3ds/chunk.h>
+#include <lib3ds/vector.h>
+#include <lib3ds/matrix.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#ifdef WITH_DMALLOC
+#include <dmalloc.h>
+#endif
+
+
+/*!
+ * \defgroup mesh Meshes
+ *
+ * \author J.E. Hoffmann <je-h@gmx.net>
+ */
+
+
+static Lib3dsBool
+face_array_read(Lib3dsMesh *mesh, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+ Lib3dsWord chunk;
+ int i;
+ int faces;
+
+ if (!lib3ds_chunk_read_start(&c, LIB3DS_FACE_ARRAY, io)) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_mesh_free_face_list(mesh);
+
+ faces=lib3ds_io_read_word(io);
+ if (faces) {
+ if (!lib3ds_mesh_new_face_list(mesh, faces)) {
+ LIB3DS_ERROR_LOG;
+ return(LIB3DS_FALSE);
+ }
+ for (i=0; i<faces; ++i) {
+ strcpy(mesh->faceL[i].material, "");
+ mesh->faceL[i].points[0]=lib3ds_io_read_word(io);
+ mesh->faceL[i].points[1]=lib3ds_io_read_word(io);
+ mesh->faceL[i].points[2]=lib3ds_io_read_word(io);
+ mesh->faceL[i].flags=lib3ds_io_read_word(io);
+ }
+ lib3ds_chunk_read_tell(&c, io);
+
+ while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
+ switch (chunk) {
+ case LIB3DS_SMOOTH_GROUP:
+ {
+ unsigned i;
+
+ for (i=0; i<mesh->faces; ++i) {
+ mesh->faceL[i].smoothing=lib3ds_io_read_dword(io);
+ }
+ }
+ break;
+ case LIB3DS_MSH_MAT_GROUP:
+ {
+ char name[64];
+ unsigned faces;
+ unsigned i;
+ unsigned index;
+
+ if (!lib3ds_io_read_string(io, name, 64)) {
+ return(LIB3DS_FALSE);
+ }
+ faces=lib3ds_io_read_word(io);
+ for (i=0; i<faces; ++i) {
+ index=lib3ds_io_read_word(io);
+ ASSERT(index<mesh->faces);
+ strcpy(mesh->faceL[index].material, name);
+ }
+ }
+ break;
+ case LIB3DS_MSH_BOXMAP:
+ {
+ char name[64];
+
+ if (!lib3ds_io_read_string(io, name, 64)) {
+ return(LIB3DS_FALSE);
+ }
+ strcpy(mesh->box_map.front, name);
+ if (!lib3ds_io_read_string(io, name, 64)) {
+ return(LIB3DS_FALSE);
+ }
+ strcpy(mesh->box_map.back, name);
+ if (!lib3ds_io_read_string(io, name, 64)) {
+ return(LIB3DS_FALSE);
+ }
+ strcpy(mesh->box_map.left, name);
+ if (!lib3ds_io_read_string(io, name, 64)) {
+ return(LIB3DS_FALSE);
+ }
+ strcpy(mesh->box_map.right, name);
+ if (!lib3ds_io_read_string(io, name, 64)) {
+ return(LIB3DS_FALSE);
+ }
+ strcpy(mesh->box_map.top, name);
+ if (!lib3ds_io_read_string(io, name, 64)) {
+ return(LIB3DS_FALSE);
+ }
+ strcpy(mesh->box_map.bottom, name);
+ }
+ break;
+ default:
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+
+ }
+ lib3ds_chunk_read_end(&c, io);
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * Create and return a new empty mesh object.
+ *
+ * Mesh is initialized with the name and an identity matrix; all
+ * other fields are zero.
+ *
+ * See Lib3dsFaceFlag for definitions of per-face flags.
+ *
+ * \param name Mesh name. Must not be NULL. Must be < 64 characters.
+ *
+ * \return mesh object or NULL on error.
+ *
+ * \ingroup mesh
+ */
+Lib3dsMesh*
+lib3ds_mesh_new(const char *name)
+{
+ Lib3dsMesh *mesh;
+
+ ASSERT(name);
+ ASSERT(strlen(name)<64);
+
+ mesh=(Lib3dsMesh*)calloc(sizeof(Lib3dsMesh), 1);
+ if (!mesh) {
+ return(0);
+ }
+ strcpy(mesh->name, name);
+ lib3ds_matrix_identity(mesh->matrix);
+ mesh->map_data.maptype=LIB3DS_MAP_NONE;
+ return(mesh);
+}
+
+
+/*!
+ * Free a mesh object and all of its resources.
+ *
+ * \param mesh Mesh object to be freed.
+ *
+ * \ingroup mesh
+ */
+void
+lib3ds_mesh_free(Lib3dsMesh *mesh)
+{
+ lib3ds_mesh_free_point_list(mesh);
+ lib3ds_mesh_free_flag_list(mesh);
+ lib3ds_mesh_free_texel_list(mesh);
+ lib3ds_mesh_free_face_list(mesh);
+ memset(mesh, 0, sizeof(Lib3dsMesh));
+ free(mesh);
+}
+
+
+/*!
+ * Allocate point list in mesh object.
+ *
+ * This function frees the current point list, if any, and allocates
+ * a new one large enough to hold the specified number of points.
+ *
+ * \param mesh Mesh object for which points are to be allocated.
+ * \param points Number of points in the new point list.
+ *
+ * \return LIB3DS_TRUE on success, LIB3DS_FALSE on failure.
+ *
+ * \ingroup mesh
+ */
+Lib3dsBool
+lib3ds_mesh_new_point_list(Lib3dsMesh *mesh, Lib3dsDword points)
+{
+ ASSERT(mesh);
+ if (mesh->pointL) {
+ ASSERT(mesh->points);
+ lib3ds_mesh_free_point_list(mesh);
+ }
+ ASSERT(!mesh->pointL && !mesh->points);
+ mesh->points=0;
+ mesh->pointL=calloc(sizeof(Lib3dsPoint)*points,1);
+ if (!mesh->pointL) {
+ LIB3DS_ERROR_LOG;
+ return(LIB3DS_FALSE);
+ }
+ mesh->points=points;
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * Free point list in mesh object.
+ *
+ * The current point list is freed and set to NULL. mesh->points is
+ * set to zero.
+ *
+ * \param mesh Mesh object to be modified.
+ *
+ * \ingroup mesh
+ */
+void
+lib3ds_mesh_free_point_list(Lib3dsMesh *mesh)
+{
+ ASSERT(mesh);
+ if (mesh->pointL) {
+ ASSERT(mesh->points);
+ free(mesh->pointL);
+ mesh->pointL=0;
+ mesh->points=0;
+ }
+ else {
+ ASSERT(!mesh->points);
+ }
+}
+
+
+/*!
+ * Allocate flag list in mesh object.
+ *
+ * This function frees the current flag list, if any, and allocates
+ * a new one large enough to hold the specified number of flags.
+ * All flags are initialized to 0
+ *
+ * \param mesh Mesh object for which points are to be allocated.
+ * \param flags Number of flags in the new flag list.
+ *
+ * \return LIB3DS_TRUE on success, LIB3DS_FALSE on failure.
+ *
+ * \ingroup mesh
+ */
+Lib3dsBool
+lib3ds_mesh_new_flag_list(Lib3dsMesh *mesh, Lib3dsDword flags)
+{
+ ASSERT(mesh);
+ if (mesh->flagL) {
+ ASSERT(mesh->flags);
+ lib3ds_mesh_free_flag_list(mesh);
+ }
+ ASSERT(!mesh->flagL && !mesh->flags);
+ mesh->flags=0;
+ mesh->flagL=calloc(sizeof(Lib3dsWord)*flags,1);
+ if (!mesh->flagL) {
+ LIB3DS_ERROR_LOG;
+ return(LIB3DS_FALSE);
+ }
+ mesh->flags=flags;
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * Free flag list in mesh object.
+ *
+ * The current flag list is freed and set to NULL. mesh->flags is
+ * set to zero.
+ *
+ * \param mesh Mesh object to be modified.
+ *
+ * \ingroup mesh
+ */
+void
+lib3ds_mesh_free_flag_list(Lib3dsMesh *mesh)
+{
+ ASSERT(mesh);
+ if (mesh->flagL) {
+ ASSERT(mesh->flags);
+ free(mesh->flagL);
+ mesh->flagL=0;
+ mesh->flags=0;
+ }
+ else {
+ ASSERT(!mesh->flags);
+ }
+}
+
+
+/*!
+ * Allocate texel list in mesh object.
+ *
+ * This function frees the current texel list, if any, and allocates
+ * a new one large enough to hold the specified number of texels.
+ *
+ * \param mesh Mesh object for which points are to be allocated.
+ * \param texels Number of texels in the new texel list.
+ *
+ * \return LIB3DS_TRUE on success, LIB3DS_FALSE on failure.
+ *
+ * \ingroup mesh
+ */
+Lib3dsBool
+lib3ds_mesh_new_texel_list(Lib3dsMesh *mesh, Lib3dsDword texels)
+{
+ ASSERT(mesh);
+ if (mesh->texelL) {
+ ASSERT(mesh->texels);
+ lib3ds_mesh_free_texel_list(mesh);
+ }
+ ASSERT(!mesh->texelL && !mesh->texels);
+ mesh->texels=0;
+ mesh->texelL=calloc(sizeof(Lib3dsTexel)*texels,1);
+ if (!mesh->texelL) {
+ LIB3DS_ERROR_LOG;
+ return(LIB3DS_FALSE);
+ }
+ mesh->texels=texels;
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * Free texel list in mesh object.
+ *
+ * The current texel list is freed and set to NULL. mesh->texels is
+ * set to zero.
+ *
+ * \param mesh Mesh object to be modified.
+ *
+ * \ingroup mesh
+ */
+void
+lib3ds_mesh_free_texel_list(Lib3dsMesh *mesh)
+{
+ ASSERT(mesh);
+ if (mesh->texelL) {
+ ASSERT(mesh->texels);
+ free(mesh->texelL);
+ mesh->texelL=0;
+ mesh->texels=0;
+ }
+ else {
+ ASSERT(!mesh->texels);
+ }
+}
+
+
+/*!
+ * Allocate face list in mesh object.
+ *
+ * This function frees the current face list, if any, and allocates
+ * a new one large enough to hold the specified number of faces.
+ *
+ * \param mesh Mesh object for which points are to be allocated.
+ * \param faces Number of faces in the new face list.
+ *
+ * \return LIB3DS_TRUE on success, LIB3DS_FALSE on failure.
+ *
+ * \ingroup mesh
+ */
+Lib3dsBool
+lib3ds_mesh_new_face_list(Lib3dsMesh *mesh, Lib3dsDword faces)
+{
+ ASSERT(mesh);
+ if (mesh->faceL) {
+ ASSERT(mesh->faces);
+ lib3ds_mesh_free_face_list(mesh);
+ }
+ ASSERT(!mesh->faceL && !mesh->faces);
+ mesh->faces=0;
+ mesh->faceL=calloc(sizeof(Lib3dsFace)*faces,1);
+ if (!mesh->faceL) {
+ LIB3DS_ERROR_LOG;
+ return(LIB3DS_FALSE);
+ }
+ mesh->faces=faces;
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * Free face list in mesh object.
+ *
+ * The current face list is freed and set to NULL. mesh->faces is
+ * set to zero.
+ *
+ * \param mesh Mesh object to be modified.
+ *
+ * \ingroup mesh
+ */
+void
+lib3ds_mesh_free_face_list(Lib3dsMesh *mesh)
+{
+ ASSERT(mesh);
+ if (mesh->faceL) {
+ ASSERT(mesh->faces);
+ free(mesh->faceL);
+ mesh->faceL=0;
+ mesh->faces=0;
+ }
+ else {
+ ASSERT(!mesh->faces);
+ }
+}
+
+
+typedef struct _Lib3dsFaces Lib3dsFaces;
+
+struct _Lib3dsFaces {
+ Lib3dsFaces *next;
+ Lib3dsFace *face;
+};
+
+
+
+
+/*!
+ * Find the bounding box of a mesh object.
+ *
+ * \param mesh The mesh object
+ * \param min Returned bounding box
+ * \param max Returned bounding box
+ *
+ * \ingroup mesh
+ */
+void
+lib3ds_mesh_bounding_box(Lib3dsMesh *mesh, Lib3dsVector min, Lib3dsVector max)
+{
+ unsigned i,j;
+ Lib3dsFloat v;
+
+ if (!mesh->points) {
+ lib3ds_vector_zero(min);
+ lib3ds_vector_zero(max);
+ return;
+ }
+
+ lib3ds_vector_copy(min, mesh->pointL[0].pos);
+ lib3ds_vector_copy(max, mesh->pointL[0].pos);
+ for (i=1; i<mesh->points; ++i) {
+ for (j=0; j<3; ++j) {
+ v=mesh->pointL[i].pos[j];
+ if (v<min[j]) {
+ min[j]=v;
+ }
+ if (v>max[j]) {
+ max[j]=v;
+ }
+ }
+ };
+}
+
+
+/*!
+ * Calculates the vertex normals corresponding to the smoothing group
+ * settings for each face of a mesh.
+ *
+ * \param mesh A pointer to the mesh to calculate the normals for.
+ * \param normalL A pointer to a buffer to store the calculated
+ * normals. The buffer must have the size:
+ * 3*sizeof(Lib3dsVector)*mesh->faces.
+ *
+ * To allocate the normal buffer do for example the following:
+ * \code
+ * Lib3dsVector *normalL = malloc(3*sizeof(Lib3dsVector)*mesh->faces);
+ * \endcode
+ *
+ * To access the normal of the i-th vertex of the j-th face do the
+ * following:
+ * \code
+ * normalL[3*j+i]
+ * \endcode
+ *
+ * \ingroup mesh
+ */
+void
+lib3ds_mesh_calculate_normals(Lib3dsMesh *mesh, Lib3dsVector *normalL)
+{
+ Lib3dsFaces **fl;
+ Lib3dsFaces *fa;
+ unsigned i,j,k;
+
+ if (!mesh->faces) {
+ return;
+ }
+
+ fl=calloc(sizeof(Lib3dsFaces*),mesh->points);
+ ASSERT(fl);
+ fa=calloc(sizeof(Lib3dsFaces),3*mesh->faces);
+ ASSERT(fa);
+ k=0;
+ for (i=0; i<mesh->faces; ++i) {
+ Lib3dsFace *f=&mesh->faceL[i];
+ for (j=0; j<3; ++j) {
+ Lib3dsFaces* l=&fa[k++];
+ ASSERT(f->points[j]<mesh->points);
+ l->face=f;
+ l->next=fl[f->points[j]];
+ fl[f->points[j]]=l;
+ }
+ }
+
+ for (i=0; i<mesh->faces; ++i) {
+ Lib3dsFace *f=&mesh->faceL[i];
+ for (j=0; j<3; ++j) {
+ /* FIXME: static array needs at least check!! */
+ Lib3dsVector n,N[128];
+ Lib3dsFaces *p;
+ int k,l;
+ int found;
+
+ ASSERT(f->points[j]<mesh->points);
+
+ if (f->smoothing) {
+ lib3ds_vector_zero(n);
+ k=0;
+ for (p=fl[f->points[j]]; p; p=p->next) {
+ found=0;
+ for (l=0; l<k; ++l) {
+ if( l >= 128 )
+ printf("array N overflow: i=%d, j=%d, k=%d\n", i,j,k);
+ if (fabs(lib3ds_vector_dot(N[l], p->face->normal)-1.0)<1e-5) {
+ found=1;
+ break;
+ }
+ }
+ if (!found) {
+ if (f->smoothing & p->face->smoothing) {
+ lib3ds_vector_add(n,n, p->face->normal);
+ lib3ds_vector_copy(N[k], p->face->normal);
+ ++k;
+ }
+ }
+ }
+ }
+ else {
+ lib3ds_vector_copy(n, f->normal);
+ }
+ lib3ds_vector_normalize(n);
+
+ lib3ds_vector_copy(normalL[3*i+j], n);
+ }
+ }
+
+ free(fa);
+ free(fl);
+}
+
+
+/*!
+ * This function prints data associated with the specified mesh such as
+ * vertex and point lists.
+ *
+ * \param mesh Points to a mesh that you wish to view the data for.
+ *
+ * \return None
+ *
+ * \warning WIN32: Should only be used in a console window not in a GUI.
+ *
+ * \ingroup mesh
+ */
+void
+lib3ds_mesh_dump(Lib3dsMesh *mesh)
+{
+ unsigned i;
+ Lib3dsVector p;
+
+ ASSERT(mesh);
+ printf(" %s vertices=%ld faces=%ld\n",
+ mesh->name,
+ mesh->points,
+ mesh->faces
+ );
+ printf(" matrix:\n");
+ lib3ds_matrix_dump(mesh->matrix);
+ printf(" point list:\n");
+ for (i=0; i<mesh->points; ++i) {
+ lib3ds_vector_copy(p, mesh->pointL[i].pos);
+ printf (" %8f %8f %8f\n", p[0], p[1], p[2]);
+ }
+ printf(" facelist:\n");
+ for (i=0; i<mesh->faces; ++i) {
+ printf (" %4d %4d %4d smoothing:%X flags:%X material:\"%s\"\n",
+ mesh->faceL[i].points[0],
+ mesh->faceL[i].points[1],
+ mesh->faceL[i].points[2],
+ (unsigned)mesh->faceL[i].smoothing,
+ mesh->faceL[i].flags,
+ mesh->faceL[i].material
+ );
+ }
+}
+
+
+/*!
+ * \ingroup mesh
+ */
+Lib3dsBool
+lib3ds_mesh_read(Lib3dsMesh *mesh, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+ Lib3dsWord chunk;
+
+ if (!lib3ds_chunk_read_start(&c, LIB3DS_N_TRI_OBJECT, io)) {
+ return(LIB3DS_FALSE);
+ }
+
+ while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
+ switch (chunk) {
+ case LIB3DS_MESH_MATRIX:
+ {
+ int i,j;
+
+ lib3ds_matrix_identity(mesh->matrix);
+ for (i=0; i<4; i++) {
+ for (j=0; j<3; j++) {
+ mesh->matrix[i][j]=lib3ds_io_read_float(io);
+ }
+ }
+ }
+ break;
+ case LIB3DS_MESH_COLOR:
+ {
+ mesh->color=lib3ds_io_read_byte(io);
+ }
+ break;
+ case LIB3DS_POINT_ARRAY:
+ {
+ unsigned i,j;
+ unsigned points;
+
+ lib3ds_mesh_free_point_list(mesh);
+ points=lib3ds_io_read_word(io);
+ if (points) {
+ if (!lib3ds_mesh_new_point_list(mesh, points)) {
+ LIB3DS_ERROR_LOG;
+ return(LIB3DS_FALSE);
+ }
+ for (i=0; i<mesh->points; ++i) {
+ for (j=0; j<3; ++j) {
+ mesh->pointL[i].pos[j]=lib3ds_io_read_float(io);
+ }
+ }
+ ASSERT((!mesh->flags) || (mesh->points==mesh->flags));
+ ASSERT((!mesh->texels) || (mesh->points==mesh->texels));
+ }
+ }
+ break;
+ case LIB3DS_POINT_FLAG_ARRAY:
+ {
+ unsigned i;
+ unsigned flags;
+
+ lib3ds_mesh_free_flag_list(mesh);
+ flags=lib3ds_io_read_word(io);
+ if (flags) {
+ if (!lib3ds_mesh_new_flag_list(mesh, flags)) {
+ LIB3DS_ERROR_LOG;
+ return(LIB3DS_FALSE);
+ }
+ for (i=0; i<mesh->flags; ++i) {
+ mesh->flagL[i]=lib3ds_io_read_word(io);
+ }
+ ASSERT((!mesh->points) || (mesh->flags==mesh->points));
+ ASSERT((!mesh->texels) || (mesh->flags==mesh->texels));
+ }
+ }
+ break;
+ case LIB3DS_FACE_ARRAY:
+ {
+ lib3ds_chunk_read_reset(&c, io);
+ if (!face_array_read(mesh, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_MESH_TEXTURE_INFO:
+ {
+ int i,j;
+
+ for (i=0; i<2; ++i) {
+ mesh->map_data.tile[i]=lib3ds_io_read_float(io);
+ }
+ for (i=0; i<3; ++i) {
+ mesh->map_data.pos[i]=lib3ds_io_read_float(io);
+ }
+ mesh->map_data.scale=lib3ds_io_read_float(io);
+
+ lib3ds_matrix_identity(mesh->map_data.matrix);
+ for (i=0; i<4; i++) {
+ for (j=0; j<3; j++) {
+ mesh->map_data.matrix[i][j]=lib3ds_io_read_float(io);
+ }
+ }
+ for (i=0; i<2; ++i) {
+ mesh->map_data.planar_size[i]=lib3ds_io_read_float(io);
+ }
+ mesh->map_data.cylinder_height=lib3ds_io_read_float(io);
+ }
+ break;
+ case LIB3DS_TEX_VERTS:
+ {
+ unsigned i;
+ unsigned texels;
+
+ lib3ds_mesh_free_texel_list(mesh);
+ texels=lib3ds_io_read_word(io);
+ if (texels) {
+ if (!lib3ds_mesh_new_texel_list(mesh, texels)) {
+ LIB3DS_ERROR_LOG;
+ return(LIB3DS_FALSE);
+ }
+ for (i=0; i<mesh->texels; ++i) {
+ mesh->texelL[i][0]=lib3ds_io_read_float(io);
+ mesh->texelL[i][1]=lib3ds_io_read_float(io);
+ }
+ ASSERT((!mesh->points) || (mesh->texels==mesh->points));
+ ASSERT((!mesh->flags) || (mesh->texels==mesh->flags));
+ }
+ }
+ break;
+ default:
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+ {
+ unsigned j;
+
+ for (j=0; j<mesh->faces; ++j) {
+ ASSERT(mesh->faceL[j].points[0]<mesh->points);
+ ASSERT(mesh->faceL[j].points[1]<mesh->points);
+ ASSERT(mesh->faceL[j].points[2]<mesh->points);
+ lib3ds_vector_normal(
+ mesh->faceL[j].normal,
+ mesh->pointL[mesh->faceL[j].points[0]].pos,
+ mesh->pointL[mesh->faceL[j].points[1]].pos,
+ mesh->pointL[mesh->faceL[j].points[2]].pos
+ );
+ }
+ }
+
+ lib3ds_chunk_read_end(&c, io);
+ return(LIB3DS_TRUE);
+}
+
+
+static Lib3dsBool
+point_array_write(Lib3dsMesh *mesh, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+ unsigned i;
+
+ if (!mesh->points || !mesh->pointL) {
+ return(LIB3DS_TRUE);
+ }
+ ASSERT(mesh->points<0x10000);
+ c.chunk=LIB3DS_POINT_ARRAY;
+ c.size=8+12*mesh->points;
+ lib3ds_chunk_write(&c, io);
+
+ lib3ds_io_write_word(io, (Lib3dsWord)mesh->points);
+ for (i=0; i<mesh->points; ++i) {
+ lib3ds_io_write_vector(io, mesh->pointL[i].pos);
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+static Lib3dsBool
+flag_array_write(Lib3dsMesh *mesh, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+ unsigned i;
+
+ if (!mesh->flags || !mesh->flagL) {
+ return(LIB3DS_TRUE);
+ }
+ ASSERT(mesh->flags<0x10000);
+ c.chunk=LIB3DS_POINT_FLAG_ARRAY;
+ c.size=8+2*mesh->flags;
+ lib3ds_chunk_write(&c, io);
+
+ lib3ds_io_write_word(io, (Lib3dsWord)mesh->flags);
+ for (i=0; i<mesh->flags; ++i) {
+ lib3ds_io_write_word(io, mesh->flagL[i]);
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+static Lib3dsBool
+face_array_write(Lib3dsMesh *mesh, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+
+ if (!mesh->faces || !mesh->faceL) {
+ return(LIB3DS_TRUE);
+ }
+ ASSERT(mesh->faces<0x10000);
+ c.chunk=LIB3DS_FACE_ARRAY;
+ if (!lib3ds_chunk_write_start(&c, io)) {
+ return(LIB3DS_FALSE);
+ }
+ {
+ unsigned i;
+
+ lib3ds_io_write_word(io, (Lib3dsWord)mesh->faces);
+ for (i=0; i<mesh->faces; ++i) {
+ lib3ds_io_write_word(io, mesh->faceL[i].points[0]);
+ lib3ds_io_write_word(io, mesh->faceL[i].points[1]);
+ lib3ds_io_write_word(io, mesh->faceL[i].points[2]);
+ lib3ds_io_write_word(io, mesh->faceL[i].flags);
+ }
+ }
+
+ { /*---- MSH_MAT_GROUP ----*/
+ Lib3dsChunk c;
+ unsigned i,j;
+ Lib3dsWord num;
+ char *matf=calloc(sizeof(char), mesh->faces);
+ if (!matf) {
+ return(LIB3DS_FALSE);
+ }
+
+ for (i=0; i<mesh->faces; ++i) {
+ if (!matf[i] && strlen(mesh->faceL[i].material)) {
+ matf[i]=1;
+ num=1;
+
+ for (j=i+1; j<mesh->faces; ++j) {
+ if (strcmp(mesh->faceL[i].material, mesh->faceL[j].material)==0) ++num;
+ }
+
+ c.chunk=LIB3DS_MSH_MAT_GROUP;
+ c.size=6+ strlen(mesh->faceL[i].material)+1 +2+2*num;
+ lib3ds_chunk_write(&c, io);
+ lib3ds_io_write_string(io, mesh->faceL[i].material);
+ lib3ds_io_write_word(io, num);
+ lib3ds_io_write_word(io, (Lib3dsWord)i);
+
+ for (j=i+1; j<mesh->faces; ++j) {
+ if (strcmp(mesh->faceL[i].material, mesh->faceL[j].material)==0) {
+ lib3ds_io_write_word(io, (Lib3dsWord)j);
+ matf[j]=1;
+ }
+ }
+ }
+ }
+ free(matf);
+ }
+
+ { /*---- SMOOTH_GROUP ----*/
+ Lib3dsChunk c;
+ unsigned i;
+
+ c.chunk=LIB3DS_SMOOTH_GROUP;
+ c.size=6+4*mesh->faces;
+ lib3ds_chunk_write(&c, io);
+
+ for (i=0; i<mesh->faces; ++i) {
+ lib3ds_io_write_dword(io, mesh->faceL[i].smoothing);
+ }
+ }
+
+ { /*---- MSH_BOXMAP ----*/
+ Lib3dsChunk c;
+
+ if (strlen(mesh->box_map.front) ||
+ strlen(mesh->box_map.back) ||
+ strlen(mesh->box_map.left) ||
+ strlen(mesh->box_map.right) ||
+ strlen(mesh->box_map.top) ||
+ strlen(mesh->box_map.bottom)) {
+
+ c.chunk=LIB3DS_MSH_BOXMAP;
+ if (!lib3ds_chunk_write_start(&c, io)) {
+ return(LIB3DS_FALSE);
+ }
+
+ lib3ds_io_write_string(io, mesh->box_map.front);
+ lib3ds_io_write_string(io, mesh->box_map.back);
+ lib3ds_io_write_string(io, mesh->box_map.left);
+ lib3ds_io_write_string(io, mesh->box_map.right);
+ lib3ds_io_write_string(io, mesh->box_map.top);
+ lib3ds_io_write_string(io, mesh->box_map.bottom);
+
+ if (!lib3ds_chunk_write_end(&c, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ }
+
+ if (!lib3ds_chunk_write_end(&c, io)) {
+ return(LIB3DS_FALSE);
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+static Lib3dsBool
+texel_array_write(Lib3dsMesh *mesh, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+ unsigned i;
+
+ if (!mesh->texels || !mesh->texelL) {
+ return(LIB3DS_TRUE);
+ }
+ ASSERT(mesh->texels<0x10000);
+ c.chunk=LIB3DS_TEX_VERTS;
+ c.size=8+8*mesh->texels;
+ lib3ds_chunk_write(&c, io);
+
+ lib3ds_io_write_word(io, (Lib3dsWord)mesh->texels);
+ for (i=0; i<mesh->texels; ++i) {
+ lib3ds_io_write_float(io, mesh->texelL[i][0]);
+ lib3ds_io_write_float(io, mesh->texelL[i][1]);
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup mesh
+ */
+Lib3dsBool
+lib3ds_mesh_write(Lib3dsMesh *mesh, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+
+ c.chunk=LIB3DS_N_TRI_OBJECT;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!point_array_write(mesh, io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!texel_array_write(mesh, io)) {
+ return(LIB3DS_FALSE);
+ }
+
+ if (mesh->map_data.maptype!=LIB3DS_MAP_NONE) { /*---- LIB3DS_MESH_TEXTURE_INFO ----*/
+ Lib3dsChunk c;
+ int i,j;
+
+ c.chunk=LIB3DS_MESH_TEXTURE_INFO;
+ c.size=92;
+ if (!lib3ds_chunk_write(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+
+ lib3ds_io_write_word(io, mesh->map_data.maptype);
+
+ for (i=0; i<2; ++i) {
+ lib3ds_io_write_float(io, mesh->map_data.tile[i]);
+ }
+ for (i=0; i<3; ++i) {
+ lib3ds_io_write_float(io, mesh->map_data.pos[i]);
+ }
+ lib3ds_io_write_float(io, mesh->map_data.scale);
+
+ for (i=0; i<4; i++) {
+ for (j=0; j<3; j++) {
+ lib3ds_io_write_float(io, mesh->map_data.matrix[i][j]);
+ }
+ }
+ for (i=0; i<2; ++i) {
+ lib3ds_io_write_float(io, mesh->map_data.planar_size[i]);
+ }
+ lib3ds_io_write_float(io, mesh->map_data.cylinder_height);
+ }
+
+ if (!flag_array_write(mesh, io)) {
+ return(LIB3DS_FALSE);
+ }
+ { /*---- LIB3DS_MESH_MATRIX ----*/
+ Lib3dsChunk c;
+ int i,j;
+
+ c.chunk=LIB3DS_MESH_MATRIX;
+ c.size=54;
+ if (!lib3ds_chunk_write(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ for (i=0; i<4; i++) {
+ for (j=0; j<3; j++) {
+ lib3ds_io_write_float(io, mesh->matrix[i][j]);
+ }
+ }
+ }
+
+ if (mesh->color) { /*---- LIB3DS_MESH_COLOR ----*/
+ Lib3dsChunk c;
+
+ c.chunk=LIB3DS_MESH_COLOR;
+ c.size=7;
+ if (!lib3ds_chunk_write(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_io_write_byte(io, mesh->color);
+ }
+ if (!face_array_write(mesh, io)) {
+ return(LIB3DS_FALSE);
+ }
+
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+
+\typedef Lib3dsFace
+ \ingroup mesh
+ \sa _Lib3dsFace
+
+*/
+/*!
+
+\typedef Lib3dsBoxMap
+ \ingroup mesh
+ \sa _Lib3dsBoxMap
+
+*/
+/*!
+
+\typedef Lib3dsMapData
+ \ingroup mesh
+ \sa _Lib3dsMapData
+
+*/
+/*!
+
+\typedef Lib3dsMesh
+ \ingroup mesh
+ \sa _Lib3dsMesh
+
+*/
--- /dev/null
+/* -*- c -*- */
+#ifndef INCLUDED_LIB3DS_MESH_H
+#define INCLUDED_LIB3DS_MESH_H
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: mesh.h,v 1.16 2004/12/31 16:17:15 reed Exp $
+ */
+
+#ifndef INCLUDED_LIB3DS_TYPES_H
+#include <lib3ds/types.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*!
+ * Triangular mesh point
+ * \ingroup mesh
+ */
+typedef struct _Lib3dsPoint {
+ Lib3dsVector pos;
+} Lib3dsPoint;
+
+/*!
+ * Triangular mesh face
+ * \ingroup mesh
+ * \sa Lib3dsFaceFlag
+ */
+struct _Lib3dsFace {
+ Lib3dsUserData user; /*! Arbitrary user data */
+ char material[64]; /*! Material name */
+ Lib3dsWord points[3]; /*! Indices into mesh points list */
+ Lib3dsWord flags; /*! See Lib3dsFaceFlag, below */
+ Lib3dsDword smoothing; /*! Bitmask; each bit identifies a group */
+ Lib3dsVector normal;
+};
+
+
+/*! Meaning of _Lib3dsFace::flags. ABC are points of the current face (A: is
+1st vertex, B is 2nd vertex, C is 3rd vertex */
+typedef enum {
+ LIB3DS_FACE_FLAG_VIS_AC = 0x1, /*!< Bit 0: Edge visibility AC */
+ LIB3DS_FACE_FLAG_VIS_BC = 0x2, /*!< Bit 1: Edge visibility BC */
+ LIB3DS_FACE_FLAG_VIS_AB = 0x4, /*!< Bit 2: Edge visibility AB */
+ LIB3DS_FACE_FLAG_WRAP_U = 0x8, /*!< Bit 3: Face is at tex U wrap seam */
+ LIB3DS_FACE_FLAG_WRAP_V = 0x10, /*!< Bit 4: Face is at tex V wrap seam */
+ LIB3DS_FACE_FLAG_UNK7 = 0x80, /* Bit 5-8: Unused ? */
+ LIB3DS_FACE_FLAG_UNK10 = 0x400, /* Bit 9-10: Random ? */
+ /* Bit 11-12: Unused ? */
+ LIB3DS_FACE_FLAG_SELECT_3 = (1<<13), /*!< Bit 13: Selection of the face in selection 3*/
+ LIB3DS_FACE_FLAG_SELECT_2 = (1<<14), /*!< Bit 14: Selection of the face in selection 2*/
+ LIB3DS_FACE_FLAG_SELECT_1 = (1<<15) /*!< Bit 15: Selection of the face in selection 1*/
+} Lib3dsFaceFlag;
+
+/*!
+ * Triangular mesh box mapping settings
+ * \ingroup mesh
+ */
+struct _Lib3dsBoxMap {
+ char front[64];
+ char back[64];
+ char left[64];
+ char right[64];
+ char top[64];
+ char bottom[64];
+};
+
+/*!
+ * Lib3dsMapData maptype
+ * \ingroup tracks
+ */
+typedef enum {
+ LIB3DS_MAP_NONE =0xFFFF,
+ LIB3DS_MAP_PLANAR =0,
+ LIB3DS_MAP_CYLINDRICAL =1,
+ LIB3DS_MAP_SPHERICAL =2
+} Lib3dsMapType;
+
+/*!
+ * Triangular mesh texture mapping data
+ * \ingroup mesh
+ */
+struct _Lib3dsMapData {
+ Lib3dsWord maptype;
+ Lib3dsVector pos;
+ Lib3dsMatrix matrix;
+ Lib3dsFloat scale;
+ Lib3dsFloat tile[2];
+ Lib3dsFloat planar_size[2];
+ Lib3dsFloat cylinder_height;
+};
+
+/*!
+ * Triangular mesh object
+ * \ingroup mesh
+ */
+struct _Lib3dsMesh {
+ Lib3dsUserData user; /*! Arbitrary user data */
+ Lib3dsMesh *next;
+ char name[64]; /*! Mesh name */
+ Lib3dsByte color;
+ Lib3dsMatrix matrix; /*! Transformation matrix for mesh data */
+ Lib3dsDword points; /*! Number of points in point list */
+ Lib3dsPoint *pointL; /*! Point list */
+ Lib3dsDword flags; /*! Number of flags in per-point flags list */
+ Lib3dsWord *flagL; /*! Per-point flags list */
+ Lib3dsDword texels; /*! Number of U-V texel coordinates */
+ Lib3dsTexel *texelL; /*! U-V texel coordinates */
+ Lib3dsDword faces; /*! Number of faces in face list */
+ Lib3dsFace *faceL; /*! Face list */
+ Lib3dsBoxMap box_map;
+ Lib3dsMapData map_data;
+};
+
+extern LIB3DSAPI Lib3dsMesh* lib3ds_mesh_new(const char *name);
+extern LIB3DSAPI void lib3ds_mesh_free(Lib3dsMesh *mesh);
+extern LIB3DSAPI Lib3dsBool lib3ds_mesh_new_point_list(Lib3dsMesh *mesh, Lib3dsDword points);
+extern LIB3DSAPI void lib3ds_mesh_free_point_list(Lib3dsMesh *mesh);
+extern LIB3DSAPI Lib3dsBool lib3ds_mesh_new_flag_list(Lib3dsMesh *mesh, Lib3dsDword flags);
+extern LIB3DSAPI void lib3ds_mesh_free_flag_list(Lib3dsMesh *mesh);
+extern LIB3DSAPI Lib3dsBool lib3ds_mesh_new_texel_list(Lib3dsMesh *mesh, Lib3dsDword texels);
+extern LIB3DSAPI void lib3ds_mesh_free_texel_list(Lib3dsMesh *mesh);
+extern LIB3DSAPI Lib3dsBool lib3ds_mesh_new_face_list(Lib3dsMesh *mesh, Lib3dsDword flags);
+extern LIB3DSAPI void lib3ds_mesh_free_face_list(Lib3dsMesh *mesh);
+extern LIB3DSAPI void lib3ds_mesh_bounding_box(Lib3dsMesh *mesh, Lib3dsVector min, Lib3dsVector max);
+extern LIB3DSAPI void lib3ds_mesh_calculate_normals(Lib3dsMesh *mesh, Lib3dsVector *normalL);
+extern LIB3DSAPI void lib3ds_mesh_dump(Lib3dsMesh *mesh);
+extern LIB3DSAPI Lib3dsBool lib3ds_mesh_read(Lib3dsMesh *mesh, Lib3dsIo *io);
+extern LIB3DSAPI Lib3dsBool lib3ds_mesh_write(Lib3dsMesh *mesh, Lib3dsIo *io);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+
--- /dev/null
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: node.c,v 1.13 2004/11/16 07:41:44 efalk Exp $
+ */
+#define LIB3DS_EXPORT
+#include <lib3ds/node.h>
+#include <lib3ds/file.h>
+#include <lib3ds/io.h>
+#include <lib3ds/chunk.h>
+#include <lib3ds/matrix.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#ifdef WITH_DMALLOC
+#include <dmalloc.h>
+#endif
+
+
+/*!
+ * \defgroup node Animation Nodes
+ *
+ * \author J.E. Hoffmann <je-h@gmx.net>
+ */
+
+
+/*!
+ * Create and return a new ambient node.
+ *
+ * The node is returned with an identity matrix. All other fields
+ * are zero.
+ *
+ * \return Lib3dsNode
+ *
+ * \ingroup node
+ */
+Lib3dsNode*
+lib3ds_node_new_ambient()
+{
+ Lib3dsNode *node=(Lib3dsNode*)calloc(sizeof(Lib3dsNode), 1);
+ node->type=LIB3DS_AMBIENT_NODE;
+ lib3ds_matrix_identity(node->matrix);
+ return(node);
+}
+
+
+/*!
+ * Create and return a new object node.
+ *
+ * The node is returned with an identity matrix. All other fields
+ * are zero.
+ *
+ * \return Lib3dsNode
+ *
+ * \ingroup node
+ */
+Lib3dsNode*
+lib3ds_node_new_object()
+{
+ Lib3dsNode *node=(Lib3dsNode*)calloc(sizeof(Lib3dsNode), 1);
+ node->type=LIB3DS_OBJECT_NODE;
+ lib3ds_matrix_identity(node->matrix);
+ return(node);
+}
+
+
+/*!
+ * Create and return a new camera node.
+ *
+ * The node is returned with an identity matrix. All other fields
+ * are zero.
+ *
+ * \return Lib3dsNode
+ *
+ * \ingroup node
+ */
+Lib3dsNode*
+lib3ds_node_new_camera()
+{
+ Lib3dsNode *node=(Lib3dsNode*)calloc(sizeof(Lib3dsNode), 1);
+ node->type=LIB3DS_CAMERA_NODE;
+ lib3ds_matrix_identity(node->matrix);
+ return(node);
+}
+
+
+/*!
+ * Create and return a new target node.
+ *
+ * The node is returned with an identity matrix. All other fields
+ * are zero.
+ *
+ * \return Lib3dsNode
+ *
+ * \ingroup node
+ */
+Lib3dsNode*
+lib3ds_node_new_target()
+{
+ Lib3dsNode *node=(Lib3dsNode*)calloc(sizeof(Lib3dsNode), 1);
+ node->type=LIB3DS_TARGET_NODE;
+ lib3ds_matrix_identity(node->matrix);
+ return(node);
+}
+
+
+/*!
+ * Create and return a new light node.
+ *
+ * The node is returned with an identity matrix. All other fields
+ * are zero.
+ *
+ * \return Lib3dsNode
+ *
+ * \ingroup node
+ */
+Lib3dsNode*
+lib3ds_node_new_light()
+{
+ Lib3dsNode *node=(Lib3dsNode*)calloc(sizeof(Lib3dsNode), 1);
+ node->type=LIB3DS_LIGHT_NODE;
+ lib3ds_matrix_identity(node->matrix);
+ return(node);
+}
+
+
+/*!
+ * Create and return a new spot node.
+ *
+ * The node is returned with an identity matrix. All other fields
+ * are zero.
+ *
+ * \return Lib3dsNode
+ *
+ * \ingroup node
+ */
+Lib3dsNode*
+lib3ds_node_new_spot()
+{
+ Lib3dsNode *node=(Lib3dsNode*)calloc(sizeof(Lib3dsNode), 1);
+ node->type=LIB3DS_SPOT_NODE;
+ lib3ds_matrix_identity(node->matrix);
+ return(node);
+}
+
+
+static void
+free_node_and_childs(Lib3dsNode *node)
+{
+ ASSERT(node);
+ switch (node->type) {
+ case LIB3DS_UNKNOWN_NODE:
+ break;
+ case LIB3DS_AMBIENT_NODE:
+ {
+ Lib3dsAmbientData *n=&node->data.ambient;
+ lib3ds_lin3_track_free_keys(&n->col_track);
+ }
+ break;
+ case LIB3DS_OBJECT_NODE:
+ {
+ Lib3dsObjectData *n=&node->data.object;
+
+ lib3ds_lin3_track_free_keys(&n->pos_track);
+ lib3ds_quat_track_free_keys(&n->rot_track);
+ lib3ds_lin3_track_free_keys(&n->scl_track);
+ lib3ds_bool_track_free_keys(&n->hide_track);
+ lib3ds_morph_track_free_keys(&n->morph_track);
+ }
+ break;
+ case LIB3DS_CAMERA_NODE:
+ {
+ Lib3dsCameraData *n=&node->data.camera;
+ lib3ds_lin3_track_free_keys(&n->pos_track);
+ lib3ds_lin1_track_free_keys(&n->fov_track);
+ lib3ds_lin1_track_free_keys(&n->roll_track);
+ }
+ break;
+ case LIB3DS_TARGET_NODE:
+ {
+ Lib3dsTargetData *n=&node->data.target;
+ lib3ds_lin3_track_free_keys(&n->pos_track);
+ }
+ break;
+ case LIB3DS_LIGHT_NODE:
+ {
+ Lib3dsLightData *n=&node->data.light;
+ lib3ds_lin3_track_free_keys(&n->pos_track);
+ lib3ds_lin3_track_free_keys(&n->col_track);
+ lib3ds_lin1_track_free_keys(&n->hotspot_track);
+ lib3ds_lin1_track_free_keys(&n->falloff_track);
+ lib3ds_lin1_track_free_keys(&n->roll_track);
+ }
+ break;
+ case LIB3DS_SPOT_NODE:
+ {
+ Lib3dsSpotData *n=&node->data.spot;
+ lib3ds_lin3_track_free_keys(&n->pos_track);
+ }
+ break;
+ }
+ {
+ Lib3dsNode *p,*q;
+ for (p=node->childs; p; p=q) {
+ q=p->next;
+ free_node_and_childs(p);
+ }
+ }
+ node->type=LIB3DS_UNKNOWN_NODE;
+ free(node);
+}
+
+
+/*!
+ * Free a node and all of its resources.
+ *
+ * \param node Lib3dsNode object to be freed.
+ *
+ * \ingroup node
+ */
+void
+lib3ds_node_free(Lib3dsNode *node)
+{
+ ASSERT(node);
+ free_node_and_childs(node);
+}
+
+
+/*!
+ * Evaluate an animation node.
+ *
+ * Recursively sets node and its children to their appropriate values
+ * for this point in the animation.
+ *
+ * \param node Node to be evaluated.
+ * \param t time value, between 0. and file->frames
+ *
+ * \ingroup node
+ */
+void
+lib3ds_node_eval(Lib3dsNode *node, Lib3dsFloat t)
+{
+ ASSERT(node);
+ switch (node->type) {
+ case LIB3DS_UNKNOWN_NODE:
+ {
+ ASSERT(LIB3DS_FALSE);
+ }
+ break;
+ case LIB3DS_AMBIENT_NODE:
+ {
+ Lib3dsAmbientData *n=&node->data.ambient;
+ if (node->parent) {
+ lib3ds_matrix_copy(node->matrix, node->parent->matrix);
+ }
+ else {
+ lib3ds_matrix_identity(node->matrix);
+ }
+ lib3ds_lin3_track_eval(&n->col_track, n->col, t);
+ }
+ break;
+ case LIB3DS_OBJECT_NODE:
+ {
+ Lib3dsMatrix M;
+ Lib3dsObjectData *n=&node->data.object;
+
+ lib3ds_lin3_track_eval(&n->pos_track, n->pos, t);
+ lib3ds_quat_track_eval(&n->rot_track, n->rot, t);
+ lib3ds_lin3_track_eval(&n->scl_track, n->scl, t);
+ lib3ds_bool_track_eval(&n->hide_track, &n->hide, t);
+ lib3ds_morph_track_eval(&n->morph_track, n->morph, t);
+
+ lib3ds_matrix_identity(M);
+ lib3ds_matrix_translate(M, n->pos);
+ lib3ds_matrix_rotate(M, n->rot);
+ lib3ds_matrix_scale(M, n->scl);
+
+ if (node->parent) {
+ lib3ds_matrix_mul(node->matrix, node->parent->matrix, M);
+ }
+ else {
+ lib3ds_matrix_copy(node->matrix, M);
+ }
+ }
+ break;
+ case LIB3DS_CAMERA_NODE:
+ {
+ Lib3dsCameraData *n=&node->data.camera;
+ lib3ds_lin3_track_eval(&n->pos_track, n->pos, t);
+ lib3ds_lin1_track_eval(&n->fov_track, &n->fov, t);
+ lib3ds_lin1_track_eval(&n->roll_track, &n->roll, t);
+ if (node->parent) {
+ lib3ds_matrix_copy(node->matrix, node->parent->matrix);
+ }
+ else {
+ lib3ds_matrix_identity(node->matrix);
+ }
+ lib3ds_matrix_translate(node->matrix, n->pos);
+ }
+ break;
+ case LIB3DS_TARGET_NODE:
+ {
+ Lib3dsTargetData *n=&node->data.target;
+ lib3ds_lin3_track_eval(&n->pos_track, n->pos, t);
+ if (node->parent) {
+ lib3ds_matrix_copy(node->matrix, node->parent->matrix);
+ }
+ else {
+ lib3ds_matrix_identity(node->matrix);
+ }
+ lib3ds_matrix_translate(node->matrix, n->pos);
+ }
+ break;
+ case LIB3DS_LIGHT_NODE:
+ {
+ Lib3dsLightData *n=&node->data.light;
+ lib3ds_lin3_track_eval(&n->pos_track, n->pos, t);
+ lib3ds_lin3_track_eval(&n->col_track, n->col, t);
+ lib3ds_lin1_track_eval(&n->hotspot_track, &n->hotspot, t);
+ lib3ds_lin1_track_eval(&n->falloff_track, &n->falloff, t);
+ lib3ds_lin1_track_eval(&n->roll_track, &n->roll, t);
+ if (node->parent) {
+ lib3ds_matrix_copy(node->matrix, node->parent->matrix);
+ }
+ else {
+ lib3ds_matrix_identity(node->matrix);
+ }
+ lib3ds_matrix_translate(node->matrix, n->pos);
+ }
+ break;
+ case LIB3DS_SPOT_NODE:
+ {
+ Lib3dsSpotData *n=&node->data.spot;
+ lib3ds_lin3_track_eval(&n->pos_track, n->pos, t);
+ if (node->parent) {
+ lib3ds_matrix_copy(node->matrix, node->parent->matrix);
+ }
+ else {
+ lib3ds_matrix_identity(node->matrix);
+ }
+ lib3ds_matrix_translate(node->matrix, n->pos);
+ }
+ break;
+ }
+ {
+ Lib3dsNode *p;
+
+ for (p=node->childs; p!=0; p=p->next) {
+ lib3ds_node_eval(p, t);
+ }
+ }
+}
+
+
+/*!
+ * Return a node object by name and type.
+ *
+ * This function performs a recursive search for the specified node.
+ * Both name and type must match.
+ *
+ * \param node The parent node for the search
+ * \param name The target node name.
+ * \param type The target node type
+ *
+ * \return A pointer to the first matching node, or NULL if not found.
+ *
+ * \ingroup node
+ */
+Lib3dsNode*
+lib3ds_node_by_name(Lib3dsNode *node, const char* name, Lib3dsNodeTypes type)
+{
+ Lib3dsNode *p,*q;
+
+ for (p=node->childs; p!=0; p=p->next) {
+ if ((p->type==type) && (strcmp(p->name, name)==0)) {
+ return(p);
+ }
+ q=lib3ds_node_by_name(p, name, type);
+ if (q) {
+ return(q);
+ }
+ }
+ return(0);
+}
+
+
+/*!
+ * Return a node object by id.
+ *
+ * This function performs a recursive search for the specified node.
+ *
+ * \param node The parent node for the search
+ * \param node_id The target node id.
+ *
+ * \return A pointer to the first matching node, or NULL if not found.
+ *
+ * \ingroup node
+ */
+Lib3dsNode*
+lib3ds_node_by_id(Lib3dsNode *node, Lib3dsWord node_id)
+{
+ Lib3dsNode *p,*q;
+
+ for (p=node->childs; p!=0; p=p->next) {
+ if (p->node_id==node_id) {
+ return(p);
+ }
+ q=lib3ds_node_by_id(p, node_id);
+ if (q) {
+ return(q);
+ }
+ }
+ return(0);
+}
+
+
+static const char* node_names_table[]= {
+ "***Unknown***",
+ "Ambient",
+ "Object",
+ "Camera",
+ "Target",
+ "Light",
+ "Spot"
+};
+
+
+/*!
+ * Dump node and all descendants recursively.
+ *
+ * \param node The top-level node to be dumped.
+ * \param level current recursion depth
+ *
+ * \ingroup node
+ */
+void
+lib3ds_node_dump(Lib3dsNode *node, Lib3dsIntd level)
+{
+ Lib3dsNode *p;
+ char l[128];
+
+ ASSERT(node);
+ memset(l, ' ', 2*level);
+ l[2*level]=0;
+
+ if (node->type==LIB3DS_OBJECT_NODE) {
+ printf("%s%s [%s] (%s)\n",
+ l,
+ node->name,
+ node->data.object.instance,
+ node_names_table[node->type]
+ );
+ }
+ else {
+ printf("%s%s (%s)\n",
+ l,
+ node->name,
+ node_names_table[node->type]
+ );
+ }
+
+ for (p=node->childs; p!=0; p=p->next) {
+ lib3ds_node_dump(p, level+1);
+ }
+}
+
+
+/*!
+ * \ingroup node
+ */
+Lib3dsBool
+lib3ds_node_read(Lib3dsNode *node, Lib3dsFile *file, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+ Lib3dsWord chunk;
+
+ ASSERT(node);
+ if (!lib3ds_chunk_read_start(&c, 0, io)) {
+ return(LIB3DS_FALSE);
+ }
+ switch (c.chunk) {
+ case LIB3DS_AMBIENT_NODE_TAG:
+ case LIB3DS_OBJECT_NODE_TAG:
+ case LIB3DS_CAMERA_NODE_TAG:
+ case LIB3DS_TARGET_NODE_TAG:
+ case LIB3DS_LIGHT_NODE_TAG:
+ case LIB3DS_SPOTLIGHT_NODE_TAG:
+ case LIB3DS_L_TARGET_NODE_TAG:
+ break;
+ default:
+ return(LIB3DS_FALSE);
+ }
+
+ while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
+ switch (chunk) {
+ case LIB3DS_NODE_ID:
+ {
+ node->node_id=lib3ds_io_read_word(io);
+ lib3ds_chunk_dump_info(" ID = %d", (short)node->node_id);
+ }
+ break;
+ case LIB3DS_NODE_HDR:
+ {
+ if (!lib3ds_io_read_string(io, node->name, 64)) {
+ return(LIB3DS_FALSE);
+ }
+ node->flags1=lib3ds_io_read_word(io);
+ node->flags2=lib3ds_io_read_word(io);
+ node->parent_id=lib3ds_io_read_word(io);
+ lib3ds_chunk_dump_info(" NAME =%s", node->name);
+ lib3ds_chunk_dump_info(" PARENT=%d", (short)node->parent_id);
+ }
+ break;
+ case LIB3DS_PIVOT:
+ {
+ if (node->type==LIB3DS_OBJECT_NODE) {
+ int i;
+ for (i=0; i<3; ++i) {
+ node->data.object.pivot[i]=lib3ds_io_read_float(io);
+ }
+ }
+ else {
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+ break;
+ case LIB3DS_INSTANCE_NAME:
+ {
+ if (node->type==LIB3DS_OBJECT_NODE) {
+ if (!lib3ds_io_read_string(io, node->data.object.instance, 64)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ else {
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+ break;
+ case LIB3DS_BOUNDBOX:
+ {
+ if (node->type==LIB3DS_OBJECT_NODE) {
+ int i;
+ for (i=0; i<3; ++i) {
+ node->data.object.bbox_min[i]=lib3ds_io_read_float(io);
+ }
+ for (i=0; i<3; ++i) {
+ node->data.object.bbox_max[i]=lib3ds_io_read_float(io);
+ }
+ }
+ else {
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+ break;
+ case LIB3DS_COL_TRACK_TAG:
+ {
+ Lib3dsBool result=LIB3DS_TRUE;
+
+ switch (node->type) {
+ case LIB3DS_AMBIENT_NODE:
+ result=lib3ds_lin3_track_read(&node->data.ambient.col_track, io);
+ break;
+ case LIB3DS_LIGHT_NODE:
+ result=lib3ds_lin3_track_read(&node->data.light.col_track, io);
+ break;
+ default:
+ lib3ds_chunk_unknown(chunk);
+ }
+ if (!result) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_POS_TRACK_TAG:
+ {
+ Lib3dsBool result=LIB3DS_TRUE;
+
+ switch (node->type) {
+ case LIB3DS_OBJECT_NODE:
+ result=lib3ds_lin3_track_read(&node->data.object.pos_track, io);
+ break;
+ case LIB3DS_CAMERA_NODE:
+ result=lib3ds_lin3_track_read(&node->data.camera.pos_track, io);
+ break;
+ case LIB3DS_TARGET_NODE:
+ result=lib3ds_lin3_track_read(&node->data.target.pos_track, io);
+ break;
+ case LIB3DS_LIGHT_NODE:
+ result=lib3ds_lin3_track_read(&node->data.light.pos_track, io);
+ break;
+ case LIB3DS_SPOT_NODE:
+ result=lib3ds_lin3_track_read(&node->data.spot.pos_track, io);
+ break;
+ default:
+ lib3ds_chunk_unknown(chunk);
+ }
+ if (!result) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_ROT_TRACK_TAG:
+ {
+ if (node->type==LIB3DS_OBJECT_NODE) {
+ if (!lib3ds_quat_track_read(&node->data.object.rot_track, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ else {
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+ break;
+ case LIB3DS_SCL_TRACK_TAG:
+ {
+ if (node->type==LIB3DS_OBJECT_NODE) {
+ if (!lib3ds_lin3_track_read(&node->data.object.scl_track, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ else {
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+ break;
+ case LIB3DS_FOV_TRACK_TAG:
+ {
+ if (node->type==LIB3DS_CAMERA_NODE) {
+ if (!lib3ds_lin1_track_read(&node->data.camera.fov_track, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ else {
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+ break;
+ case LIB3DS_HOT_TRACK_TAG:
+ {
+ if (node->type==LIB3DS_LIGHT_NODE) {
+ if (!lib3ds_lin1_track_read(&node->data.light.hotspot_track, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ else {
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+ break;
+ case LIB3DS_FALL_TRACK_TAG:
+ {
+ if (node->type==LIB3DS_LIGHT_NODE) {
+ if (!lib3ds_lin1_track_read(&node->data.light.falloff_track, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ else {
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+ break;
+ case LIB3DS_ROLL_TRACK_TAG:
+ {
+ Lib3dsBool result=LIB3DS_TRUE;
+
+ switch (node->type) {
+ case LIB3DS_CAMERA_NODE:
+ result=lib3ds_lin1_track_read(&node->data.camera.roll_track, io);
+ break;
+ case LIB3DS_LIGHT_NODE:
+ result=lib3ds_lin1_track_read(&node->data.light.roll_track, io);
+ break;
+ default:
+ lib3ds_chunk_unknown(chunk);
+ }
+ if (!result) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_HIDE_TRACK_TAG:
+ {
+ if (node->type==LIB3DS_OBJECT_NODE) {
+ if (!lib3ds_bool_track_read(&node->data.object.hide_track, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ else {
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+ break;
+ case LIB3DS_MORPH_SMOOTH:
+ {
+ if (node->type==LIB3DS_OBJECT_NODE) {
+ node->data.object.morph_smooth=lib3ds_io_read_float(io);
+ }
+ else {
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+ break;
+ case LIB3DS_MORPH_TRACK_TAG:
+ {
+ if (node->type==LIB3DS_OBJECT_NODE) {
+ if (!lib3ds_morph_track_read(&node->data.object.morph_track, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ else {
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+ break;
+ default:
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+
+ lib3ds_chunk_read_end(&c, io);
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup node
+ */
+Lib3dsBool
+lib3ds_node_write(Lib3dsNode *node, Lib3dsFile *file, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+
+ switch (node->type) {
+ case LIB3DS_AMBIENT_NODE:
+ c.chunk=LIB3DS_AMBIENT_NODE_TAG;
+ break;
+ case LIB3DS_OBJECT_NODE:
+ c.chunk=LIB3DS_OBJECT_NODE_TAG;
+ break;
+ case LIB3DS_CAMERA_NODE:
+ c.chunk=LIB3DS_CAMERA_NODE_TAG;
+ break;
+ case LIB3DS_TARGET_NODE:
+ c.chunk=LIB3DS_TARGET_NODE_TAG;
+ break;
+ case LIB3DS_LIGHT_NODE:
+ if (lib3ds_file_node_by_name(file, node->name, LIB3DS_SPOT_NODE)) {
+ c.chunk=LIB3DS_SPOTLIGHT_NODE_TAG;
+ }
+ else {
+ c.chunk=LIB3DS_LIGHT_NODE_TAG;
+ }
+ break;
+ case LIB3DS_SPOT_NODE:
+ c.chunk=LIB3DS_L_TARGET_NODE_TAG;
+ break;
+ default:
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+
+ { /*---- LIB3DS_NODE_ID ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_NODE_ID;
+ c.size=8;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_intw(io, node->node_id);
+ }
+
+ { /*---- LIB3DS_NODE_HDR ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_NODE_HDR;
+ c.size=6+ 1+strlen(node->name) +2+2+2;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_string(io, node->name);
+ lib3ds_io_write_word(io, node->flags1);
+ lib3ds_io_write_word(io, node->flags2);
+ lib3ds_io_write_word(io, node->parent_id);
+ }
+
+ switch (c.chunk) {
+ case LIB3DS_AMBIENT_NODE_TAG:
+ { /*---- LIB3DS_COL_TRACK_TAG ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_COL_TRACK_TAG;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_lin3_track_write(&node->data.ambient.col_track,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_OBJECT_NODE_TAG:
+ { /*---- LIB3DS_PIVOT ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_PIVOT;
+ c.size=18;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_vector(io, node->data.object.pivot);
+ }
+ { /*---- LIB3DS_INSTANCE_NAME ----*/
+ Lib3dsChunk c;
+ const char *name;
+ if (strlen(node->data.object.instance)) {
+ name=node->data.object.instance;
+
+ c.chunk=LIB3DS_INSTANCE_NAME;
+ c.size=6+1+strlen(name);
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_string(io, name);
+ }
+ }
+ {
+ int i;
+ for (i=0; i<3; ++i) {
+ if ((fabs(node->data.object.bbox_min[i])>LIB3DS_EPSILON) ||
+ (fabs(node->data.object.bbox_max[i])>LIB3DS_EPSILON)) {
+ break;
+ }
+ }
+
+ if (i<3) { /*---- LIB3DS_BOUNDBOX ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_BOUNDBOX;
+ c.size=30;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_vector(io, node->data.object.bbox_min);
+ lib3ds_io_write_vector(io, node->data.object.bbox_max);
+ }
+ }
+ { /*---- LIB3DS_POS_TRACK_TAG ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_POS_TRACK_TAG;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_lin3_track_write(&node->data.object.pos_track,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ { /*---- LIB3DS_ROT_TRACK_TAG ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_ROT_TRACK_TAG;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_quat_track_write(&node->data.object.rot_track,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ { /*---- LIB3DS_SCL_TRACK_TAG ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_SCL_TRACK_TAG;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_lin3_track_write(&node->data.object.scl_track,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ if (node->data.object.hide_track.keyL) { /*---- LIB3DS_HIDE_TRACK_TAG ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_HIDE_TRACK_TAG;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_bool_track_write(&node->data.object.hide_track,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ if (fabs(node->data.object.morph_smooth)>LIB3DS_EPSILON){ /*---- LIB3DS_MORPH_SMOOTH ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_MORPH_SMOOTH;
+ c.size=10;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_float(io, node->data.object.morph_smooth);
+ }
+ break;
+ case LIB3DS_CAMERA_NODE_TAG:
+ { /*---- LIB3DS_POS_TRACK_TAG ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_POS_TRACK_TAG;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_lin3_track_write(&node->data.camera.pos_track,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ { /*---- LIB3DS_FOV_TRACK_TAG ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_FOV_TRACK_TAG;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_lin1_track_write(&node->data.camera.fov_track,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ { /*---- LIB3DS_ROLL_TRACK_TAG ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_ROLL_TRACK_TAG;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_lin1_track_write(&node->data.camera.roll_track,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_TARGET_NODE_TAG:
+ { /*---- LIB3DS_POS_TRACK_TAG ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_POS_TRACK_TAG;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_lin3_track_write(&node->data.target.pos_track,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_LIGHT_NODE_TAG:
+ { /*---- LIB3DS_POS_TRACK_TAG ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_POS_TRACK_TAG;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_lin3_track_write(&node->data.light.pos_track,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ { /*---- LIB3DS_COL_TRACK_TAG ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_COL_TRACK_TAG;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_lin3_track_write(&node->data.light.col_track,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_SPOTLIGHT_NODE_TAG:
+ { /*---- LIB3DS_POS_TRACK_TAG ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_POS_TRACK_TAG;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_lin3_track_write(&node->data.light.pos_track,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ { /*---- LIB3DS_COL_TRACK_TAG ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_COL_TRACK_TAG;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_lin3_track_write(&node->data.light.col_track,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ { /*---- LIB3DS_HOT_TRACK_TAG ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_HOT_TRACK_TAG;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_lin1_track_write(&node->data.light.hotspot_track,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ { /*---- LIB3DS_FALL_TRACK_TAG ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_FALL_TRACK_TAG;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_lin1_track_write(&node->data.light.falloff_track,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ { /*---- LIB3DS_ROLL_TRACK_TAG ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_ROLL_TRACK_TAG;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_lin1_track_write(&node->data.light.roll_track,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ case LIB3DS_L_TARGET_NODE_TAG:
+ { /*---- LIB3DS_POS_TRACK_TAG ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_POS_TRACK_TAG;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_lin3_track_write(&node->data.spot.pos_track,io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ break;
+ default:
+ return(LIB3DS_FALSE);
+ }
+
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+
+\typedef Lib3dsNodeTypes
+ \ingroup node
+
+*/
+/*!
+
+\enum _Lib3dsNodeTypes
+ \ingroup node
+
+*/
+/*!
+
+\typedef Lib3dsBoolKey
+ \ingroup node
+ \sa _Lib3dsBoolKey
+
+*/
+/*!
+
+\typedef Lib3dsBoolTrack
+ \ingroup node
+ \sa _Lib3dsBoolTrack
+
+*/
+/*!
+
+\typedef Lib3dsLin1Key
+ \ingroup node
+ \sa _Lib3dsLin1Key
+
+*/
+/*!
+
+\typedef Lib3dsLin1Track
+ \ingroup node
+ \sa _Lib3dsLin1Track
+
+*/
+/*!
+
+\typedef Lib3dsLin3Key
+ \ingroup node
+ \sa _Lib3dsLin3Key
+
+*/
+/*!
+
+\typedef Lib3dsLin3Track
+ \ingroup node
+ \sa _Lib3dsLin3Track
+
+*/
+/*!
+
+\typedef Lib3dsQuatKey
+ \ingroup node
+ \sa _Lib3dsQuatKey
+
+*/
+/*!
+
+\typedef Lib3dsQuatTrack
+ \ingroup node
+ \sa _Lib3dsLin3Key
+
+*/
+/*!
+
+\typedef Lib3dsMorphKey
+ \ingroup node
+ \sa _Lib3dsMorphKey
+
+*/
+/*!
+
+\typedef Lib3dsMorphTrack
+ \ingroup node
+ \sa _Lib3dsMorphTrack
+
+*/
+
+
--- /dev/null
+/* -*- c -*- */
+#ifndef INCLUDED_LIB3DS_NODE_H
+#define INCLUDED_LIB3DS_NODE_H
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: node.h,v 1.9 2004/12/31 16:17:15 reed Exp $
+ */
+
+#ifndef INCLUDED_LIB3DS_TRACKS_H
+#include <lib3ds/tracks.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*!
+ * Scene graph ambient color node data
+ * \ingroup node
+ */
+typedef struct _Lib3dsAmbientData {
+ Lib3dsRgb col;
+ Lib3dsLin3Track col_track;
+} Lib3dsAmbientData;
+
+/*!
+ * Scene graph object instance node data
+ * \ingroup node
+ */
+typedef struct _Lib3dsObjectData {
+ Lib3dsVector pivot;
+ char instance[64];
+ Lib3dsVector bbox_min;
+ Lib3dsVector bbox_max;
+ Lib3dsVector pos;
+ Lib3dsLin3Track pos_track;
+ Lib3dsQuat rot;
+ Lib3dsQuatTrack rot_track;
+ Lib3dsVector scl;
+ Lib3dsLin3Track scl_track;
+ Lib3dsFloat morph_smooth;
+ char morph[64];
+ Lib3dsMorphTrack morph_track;
+ Lib3dsBool hide;
+ Lib3dsBoolTrack hide_track;
+} Lib3dsObjectData;
+
+/*!
+ * Scene graph camera node data
+ * \ingroup node
+ */
+typedef struct _Lib3dsCameraData {
+ Lib3dsVector pos;
+ Lib3dsLin3Track pos_track;
+ Lib3dsFloat fov;
+ Lib3dsLin1Track fov_track;
+ Lib3dsFloat roll;
+ Lib3dsLin1Track roll_track;
+} Lib3dsCameraData;
+
+/*!
+ * Scene graph camera target node data
+ * \ingroup node
+ */
+typedef struct _Lib3dsTargetData {
+ Lib3dsVector pos;
+ Lib3dsLin3Track pos_track;
+} Lib3dsTargetData;
+
+/*!
+ * Scene graph light node data
+ * \ingroup node
+ */
+typedef struct _Lib3dsLightData {
+ Lib3dsVector pos;
+ Lib3dsLin3Track pos_track;
+ Lib3dsRgb col;
+ Lib3dsLin3Track col_track;
+ Lib3dsFloat hotspot;
+ Lib3dsLin1Track hotspot_track;
+ Lib3dsFloat falloff;
+ Lib3dsLin1Track falloff_track;
+ Lib3dsFloat roll;
+ Lib3dsLin1Track roll_track;
+} Lib3dsLightData;
+
+/*!
+ * Scene graph spotlight target node data
+ * \ingroup node
+ */
+typedef struct _Lib3dsSpotData {
+ Lib3dsVector pos;
+ Lib3dsLin3Track pos_track;
+} Lib3dsSpotData;
+
+/*!
+ * Scene graph node data union
+ * \ingroup node
+ */
+typedef union _Lib3dsNodeData {
+ Lib3dsAmbientData ambient;
+ Lib3dsObjectData object;
+ Lib3dsCameraData camera;
+ Lib3dsTargetData target;
+ Lib3dsLightData light;
+ Lib3dsSpotData spot;
+} Lib3dsNodeData;
+
+/*!
+ * \ingroup node
+ */
+#define LIB3DS_NO_PARENT 65535
+
+/*!
+ * Scene graph node
+ * \ingroup node
+ */
+struct _Lib3dsNode {
+ Lib3dsUserData user;
+ Lib3dsNode *next;\
+ Lib3dsNode *childs;\
+ Lib3dsNode *parent;\
+ Lib3dsNodeTypes type;\
+ Lib3dsWord node_id;\
+ char name[64];\
+ Lib3dsWord flags1;\
+ Lib3dsWord flags2;\
+ Lib3dsWord parent_id;
+ Lib3dsMatrix matrix;
+ Lib3dsNodeData data;
+};
+
+/*!
+ * Node flags
+ * \ingroup node
+ */
+typedef enum {
+ LIB3DS_HIDDEN = 0x800
+} Lib3dsNodeFlags1;
+
+/*!
+ * Node flags
+ * \ingroup node
+ */
+typedef enum {
+ LIB3DS_SHOW_PATH = 0x1,
+ LIB3DS_SMOOTHING = 0x2,
+ LIB3DS_MOTION_BLUR = 0x10,
+ LIB3DS_MORPH_MATERIALS = 0x40
+} Lib3dsNodeFlags2;
+
+extern LIB3DSAPI Lib3dsNode* lib3ds_node_new_ambient();
+extern LIB3DSAPI Lib3dsNode* lib3ds_node_new_object();
+extern LIB3DSAPI Lib3dsNode* lib3ds_node_new_camera();
+extern LIB3DSAPI Lib3dsNode* lib3ds_node_new_target();
+extern LIB3DSAPI Lib3dsNode* lib3ds_node_new_light();
+extern LIB3DSAPI Lib3dsNode* lib3ds_node_new_spot();
+extern LIB3DSAPI void lib3ds_node_free(Lib3dsNode *node);
+extern LIB3DSAPI void lib3ds_node_eval(Lib3dsNode *node, Lib3dsFloat t);
+extern LIB3DSAPI Lib3dsNode* lib3ds_node_by_name(Lib3dsNode *node, const char* name,
+ Lib3dsNodeTypes type);
+extern LIB3DSAPI Lib3dsNode* lib3ds_node_by_id(Lib3dsNode *node, Lib3dsWord node_id);
+extern LIB3DSAPI void lib3ds_node_dump(Lib3dsNode *node, Lib3dsIntd level);
+extern LIB3DSAPI Lib3dsBool lib3ds_node_read(Lib3dsNode *node, Lib3dsFile *file, Lib3dsIo *io);
+extern LIB3DSAPI Lib3dsBool lib3ds_node_write(Lib3dsNode *node, Lib3dsFile *file, Lib3dsIo *io);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+
--- /dev/null
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: quat.c,v 1.6 2004/11/20 08:31:31 efalk Exp $
+ */
+#define LIB3DS_EXPORT
+#include <lib3ds/quat.h>
+#include <math.h>
+
+
+/*!
+ * \defgroup quat Quaternion Mathematics
+ *
+ * \author J.E. Hoffmann <je-h@gmx.net>
+ */
+/*!
+ * \typedef Lib3dsQuat
+ * \ingroup quat
+ */
+
+
+/*!
+ * Clear a quaternion.
+ * \ingroup quat
+ */
+void
+lib3ds_quat_zero(Lib3dsQuat c)
+{
+ c[0]=c[1]=c[2]=c[3]=0.0f;
+}
+
+
+/*!
+ * Set a quaternion to Identity
+ * \ingroup quat
+ */
+void
+lib3ds_quat_identity(Lib3dsQuat c)
+{
+ c[0]=c[1]=c[2]=0.0f;
+ c[3]=1.0f;
+}
+
+
+/*!
+ * Copy a quaternion.
+ * \ingroup quat
+ */
+void
+lib3ds_quat_copy(Lib3dsQuat dest, Lib3dsQuat src)
+{
+ int i;
+ for (i=0; i<4; ++i) {
+ dest[i]=src[i];
+ }
+}
+
+
+/*!
+ * Compute a quaternion from axis and angle.
+ *
+ * \param c Computed quaternion
+ * \param axis Rotation axis
+ * \param angle Angle of rotation, radians.
+ *
+ * \ingroup quat
+ */
+void
+lib3ds_quat_axis_angle(Lib3dsQuat c, Lib3dsVector axis, Lib3dsFloat angle)
+{
+ Lib3dsDouble omega,s;
+ Lib3dsDouble l;
+
+ l=sqrt(axis[0]*axis[0] + axis[1]*axis[1] + axis[2]*axis[2]);
+ if (l<LIB3DS_EPSILON) {
+ c[0]=c[1]=c[2]=0.0f;
+ c[3]=1.0f;
+ }
+ else {
+ omega=-0.5*angle;
+ s=sin(omega)/l;
+ c[0]=(Lib3dsFloat)s*axis[0];
+ c[1]=(Lib3dsFloat)s*axis[1];
+ c[2]=(Lib3dsFloat)s*axis[2];
+ c[3]=(Lib3dsFloat)cos(omega);
+ }
+}
+
+
+/*!
+ * Negate a quaternion
+ *
+ * \ingroup quat
+ */
+void
+lib3ds_quat_neg(Lib3dsQuat c)
+{
+ int i;
+ for (i=0; i<4; ++i) {
+ c[i]=-c[i];
+ }
+}
+
+
+/*!
+ * Compute the absolute value of a quaternion
+ *
+ * \ingroup quat
+ */
+void
+lib3ds_quat_abs(Lib3dsQuat c)
+{
+ int i;
+ for (i=0; i<4; ++i) {
+ c[i]=(Lib3dsFloat)fabs(c[i]);
+ }
+}
+
+
+/*!
+ * Compute the conjugate of a quaternion
+ *
+ * \ingroup quat
+ */
+void
+lib3ds_quat_cnj(Lib3dsQuat c)
+{
+ int i;
+ for (i=0; i<3; ++i) {
+ c[i]=-c[i];
+ }
+}
+
+
+/*!
+ * Multiply two quaternions.
+ *
+ * \param c Result
+ * \param a,b Inputs
+ * \ingroup quat
+ */
+void
+lib3ds_quat_mul(Lib3dsQuat c, Lib3dsQuat a, Lib3dsQuat b)
+{
+ c[0]=a[3]*b[0] + a[0]*b[3] + a[1]*b[2] - a[2]*b[1];
+ c[1]=a[3]*b[1] + a[1]*b[3] + a[2]*b[0] - a[0]*b[2];
+ c[2]=a[3]*b[2] + a[2]*b[3] + a[0]*b[1] - a[1]*b[0];
+ c[3]=a[3]*b[3] - a[0]*b[0] - a[1]*b[1] - a[2]*b[2];
+}
+
+
+/*!
+ * Multiply a quaternion by a scalar.
+ *
+ * \ingroup quat
+ */
+void
+lib3ds_quat_scalar(Lib3dsQuat c, Lib3dsFloat k)
+{
+ int i;
+ for (i=0; i<4; ++i) {
+ c[i]*=k;
+ }
+}
+
+
+/*!
+ * Normalize a quaternion.
+ *
+ * \ingroup quat
+ */
+void
+lib3ds_quat_normalize(Lib3dsQuat c)
+{
+ Lib3dsDouble l,m;
+
+ l=sqrt(c[0]*c[0] + c[1]*c[1] + c[2]*c[2] + c[3]*c[3]);
+ if (fabs(l)<LIB3DS_EPSILON) {
+ c[0]=c[1]=c[2]=0.0f;
+ c[3]=1.0f;
+ }
+ else {
+ int i;
+ m=1.0f/l;
+ for (i=0; i<4; ++i) {
+ c[i]=(Lib3dsFloat)(c[i]*m);
+ }
+ }
+}
+
+
+/*!
+ * Compute the inverse of a quaternion.
+ *
+ * \ingroup quat
+ */
+void
+lib3ds_quat_inv(Lib3dsQuat c)
+{
+ Lib3dsDouble l,m;
+
+ l=sqrt(c[0]*c[0] + c[1]*c[1] + c[2]*c[2] + c[3]*c[3]);
+ if (fabs(l)<LIB3DS_EPSILON) {
+ c[0]=c[1]=c[2]=0.0f;
+ c[3]=1.0f;
+ }
+ else {
+ m=1.0f/l;
+ c[0]=(Lib3dsFloat)(-c[0]*m);
+ c[1]=(Lib3dsFloat)(-c[1]*m);
+ c[2]=(Lib3dsFloat)(-c[2]*m);
+ c[3]=(Lib3dsFloat)(c[3]*m);
+ }
+}
+
+
+/*!
+ * Compute the dot-product of a quaternion.
+ *
+ * \ingroup quat
+ */
+Lib3dsFloat
+lib3ds_quat_dot(Lib3dsQuat a, Lib3dsQuat b)
+{
+ return(a[0]*b[0] + a[1]*b[1] + a[2]*b[2] + a[3]*b[3]);
+}
+
+
+/*!
+ * \ingroup quat
+ */
+Lib3dsFloat
+lib3ds_quat_squared(Lib3dsQuat c)
+{
+ return(c[0]*c[0] + c[1]*c[1] + c[2]*c[2] + c[3]*c[3]);
+}
+
+
+/*!
+ * \ingroup quat
+ */
+Lib3dsFloat
+lib3ds_quat_length(Lib3dsQuat c)
+{
+ return((Lib3dsFloat)sqrt(c[0]*c[0] + c[1]*c[1] + c[2]*c[2] + c[3]*c[3]));
+}
+
+
+/*!
+ * \ingroup quat
+ */
+void
+lib3ds_quat_ln(Lib3dsQuat c)
+{
+ Lib3dsDouble om,s,t;
+
+ s=sqrt(c[0]*c[0] + c[1]*c[1] + c[2]*c[2]);
+ om=atan2(s,c[3]);
+ if (fabs(s)<LIB3DS_EPSILON) {
+ t=0.0f;
+ }
+ else {
+ t=om/s;
+ }
+ {
+ int i;
+ for (i=0; i<3; ++i) {
+ c[i]=(Lib3dsFloat)(c[i]*t);
+ }
+ c[3]=0.0f;
+ }
+}
+
+
+/*!
+ * \ingroup quat
+ */
+void
+lib3ds_quat_ln_dif(Lib3dsQuat c, Lib3dsQuat a, Lib3dsQuat b)
+{
+ Lib3dsQuat invp;
+
+ lib3ds_quat_copy(invp, a);
+ lib3ds_quat_inv(invp);
+ lib3ds_quat_mul(c, invp, b);
+ lib3ds_quat_ln(c);
+}
+
+
+/*!
+ * \ingroup quat
+ */
+void
+lib3ds_quat_exp(Lib3dsQuat c)
+{
+ Lib3dsDouble om,sinom;
+
+ om=sqrt(c[0]*c[0] + c[1]*c[1] + c[2]*c[2]);
+ if (fabs(om)<LIB3DS_EPSILON) {
+ sinom=1.0f;
+ }
+ else {
+ sinom=sin(om)/om;
+ }
+ {
+ int i;
+ for (i=0; i<3; ++i) {
+ c[i]=(Lib3dsFloat)(c[i]*sinom);
+ }
+ c[3]=(Lib3dsFloat)cos(om);
+ }
+}
+
+
+/*!
+ * \ingroup quat
+ */
+void
+lib3ds_quat_slerp(Lib3dsQuat c, Lib3dsQuat a, Lib3dsQuat b, Lib3dsFloat t)
+{
+ Lib3dsDouble l;
+ Lib3dsDouble om,sinom;
+ Lib3dsDouble sp,sq;
+ Lib3dsQuat q;
+
+ l=a[0]*b[0] + a[1]*b[1] + a[2]*b[2] + a[3]*b[3];
+ if ((1.0+l)>LIB3DS_EPSILON) {
+ if (fabs(l)>1.0f) l/=fabs(l);
+ om=acos(l);
+ sinom=sin(om);
+ if (fabs(sinom)>LIB3DS_EPSILON) {
+ sp=sin((1.0f-t)*om)/sinom;
+ sq=sin(t*om)/sinom;
+ }
+ else {
+ sp=1.0f-t;
+ sq=t;
+ }
+ c[0]=(Lib3dsFloat)(sp*a[0] + sq*b[0]);
+ c[1]=(Lib3dsFloat)(sp*a[1] + sq*b[1]);
+ c[2]=(Lib3dsFloat)(sp*a[2] + sq*b[2]);
+ c[3]=(Lib3dsFloat)(sp*a[3] + sq*b[3]);
+ }
+ else {
+ q[0]=-a[1];
+ q[1]=a[0];
+ q[2]=-a[3];
+ q[3]=a[2];
+ sp=sin((1.0-t)*LIB3DS_HALFPI);
+ sq=sin(t*LIB3DS_HALFPI);
+ c[0]=(Lib3dsFloat)(sp*a[0] + sq*q[0]);
+ c[1]=(Lib3dsFloat)(sp*a[1] + sq*q[1]);
+ c[2]=(Lib3dsFloat)(sp*a[2] + sq*q[2]);
+ c[3]=(Lib3dsFloat)(sp*a[3] + sq*q[3]);
+ }
+}
+
+
+/*!
+ * \ingroup quat
+ */
+void
+lib3ds_quat_squad(Lib3dsQuat c, Lib3dsQuat a, Lib3dsQuat p, Lib3dsQuat q,
+ Lib3dsQuat b, Lib3dsFloat t)
+{
+ Lib3dsQuat ab;
+ Lib3dsQuat pq;
+
+ lib3ds_quat_slerp(ab,a,b,t);
+ lib3ds_quat_slerp(pq,p,q,t);
+ lib3ds_quat_slerp(c,ab,pq,2*t*(1-t));
+}
+
+
+/*!
+ * \ingroup quat
+ */
+void
+lib3ds_quat_tangent(Lib3dsQuat c, Lib3dsQuat p, Lib3dsQuat q, Lib3dsQuat n)
+{
+ Lib3dsQuat dn,dp,x;
+ int i;
+
+ lib3ds_quat_ln_dif(dn, q, n);
+ lib3ds_quat_ln_dif(dp, q, p);
+
+ for (i=0; i<4; i++) {
+ x[i]=-1.0f/4.0f*(dn[i]+dp[i]);
+ }
+ lib3ds_quat_exp(x);
+ lib3ds_quat_mul(c,q,x);
+}
+
+
+/*!
+ * \ingroup quat
+ */
+void
+lib3ds_quat_dump(Lib3dsQuat q)
+{
+ printf("%f %f %f %f\n", q[0], q[1], q[2], q[3]);
+}
+
--- /dev/null
+/* -*- c -*- */
+#ifndef INCLUDED_LIB3DS_QUAT_H
+#define INCLUDED_LIB3DS_QUAT_H
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: quat.h,v 1.6 2004/12/31 16:17:15 reed Exp $
+ */
+
+#ifndef INCLUDED_LIB3DS_TYPES_H
+#include <lib3ds/types.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern LIB3DSAPI void lib3ds_quat_zero(Lib3dsQuat c);
+extern LIB3DSAPI void lib3ds_quat_identity(Lib3dsQuat c);
+extern LIB3DSAPI void lib3ds_quat_copy(Lib3dsQuat dest, Lib3dsQuat src);
+extern LIB3DSAPI void lib3ds_quat_axis_angle(Lib3dsQuat c, Lib3dsVector axis, Lib3dsFloat angle);
+extern LIB3DSAPI void lib3ds_quat_neg(Lib3dsQuat c);
+extern LIB3DSAPI void lib3ds_quat_abs(Lib3dsQuat c);
+extern LIB3DSAPI void lib3ds_quat_cnj(Lib3dsQuat c);
+extern LIB3DSAPI void lib3ds_quat_mul(Lib3dsQuat c, Lib3dsQuat a, Lib3dsQuat b);
+extern LIB3DSAPI void lib3ds_quat_scalar(Lib3dsQuat c, Lib3dsFloat k);
+extern LIB3DSAPI void lib3ds_quat_normalize(Lib3dsQuat c);
+extern LIB3DSAPI void lib3ds_quat_inv(Lib3dsQuat c);
+extern LIB3DSAPI Lib3dsFloat lib3ds_quat_dot(Lib3dsQuat a, Lib3dsQuat b);
+extern LIB3DSAPI Lib3dsFloat lib3ds_quat_squared(Lib3dsQuat c);
+extern LIB3DSAPI Lib3dsFloat lib3ds_quat_length(Lib3dsQuat c);
+extern LIB3DSAPI void lib3ds_quat_ln(Lib3dsQuat c);
+extern LIB3DSAPI void lib3ds_quat_ln_dif(Lib3dsQuat c, Lib3dsQuat a, Lib3dsQuat b);
+extern LIB3DSAPI void lib3ds_quat_exp(Lib3dsQuat c);
+extern LIB3DSAPI void lib3ds_quat_slerp(Lib3dsQuat c, Lib3dsQuat a, Lib3dsQuat b, Lib3dsFloat t);
+extern LIB3DSAPI void lib3ds_quat_squad(Lib3dsQuat c, Lib3dsQuat a, Lib3dsQuat p, Lib3dsQuat q,
+ Lib3dsQuat b, Lib3dsFloat t);
+extern LIB3DSAPI void lib3ds_quat_tangent(Lib3dsQuat c, Lib3dsQuat p, Lib3dsQuat q, Lib3dsQuat n);
+extern LIB3DSAPI void lib3ds_quat_dump(Lib3dsQuat q);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+
--- /dev/null
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: shadow.c,v 1.8 2001/07/07 19:05:30 jeh Exp $
+ */
+#define LIB3DS_EXPORT
+#include <lib3ds/shadow.h>
+#include <lib3ds/chunk.h>
+#include <lib3ds/io.h>
+#include <math.h>
+
+
+/*!
+ * \defgroup shadow Shadow Map Settings
+ *
+ * \author J.E. Hoffmann <je-h@gmx.net>
+ */
+
+
+/*!
+ * \ingroup shadow
+ */
+Lib3dsBool
+lib3ds_shadow_read(Lib3dsShadow *shadow, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+
+ if (!lib3ds_chunk_read(&c, io)) {
+ return(LIB3DS_FALSE);
+ }
+
+ switch (c.chunk) {
+ case LIB3DS_SHADOW_MAP_SIZE:
+ {
+ shadow->map_size=lib3ds_io_read_intw(io);
+ }
+ break;
+ case LIB3DS_LO_SHADOW_BIAS:
+ {
+ shadow->lo_bias=lib3ds_io_read_float(io);
+ }
+ break;
+ case LIB3DS_HI_SHADOW_BIAS:
+ {
+ shadow->hi_bias=lib3ds_io_read_float(io);
+ }
+ break;
+ case LIB3DS_SHADOW_SAMPLES:
+ {
+ shadow->samples=lib3ds_io_read_intw(io);
+ }
+ break;
+ case LIB3DS_SHADOW_RANGE:
+ {
+ shadow->range=lib3ds_io_read_intd(io);
+ }
+ break;
+ case LIB3DS_SHADOW_FILTER:
+ {
+ shadow->filter=lib3ds_io_read_float(io);
+ }
+ break;
+ case LIB3DS_RAY_BIAS:
+ {
+ shadow->ray_bias=lib3ds_io_read_float(io);
+ }
+ break;
+ }
+
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup shadow
+ */
+Lib3dsBool
+lib3ds_shadow_write(Lib3dsShadow *shadow, Lib3dsIo *io)
+{
+ if (fabs(shadow->lo_bias)>LIB3DS_EPSILON) { /*---- LIB3DS_LO_SHADOW_BIAS ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_LO_SHADOW_BIAS;
+ c.size=10;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_float(io, shadow->lo_bias);
+ }
+
+ if (fabs(shadow->hi_bias)>LIB3DS_EPSILON) { /*---- LIB3DS_HI_SHADOW_BIAS ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_HI_SHADOW_BIAS;
+ c.size=10;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_float(io, shadow->hi_bias);
+ }
+
+ if (shadow->map_size) { /*---- LIB3DS_SHADOW_MAP_SIZE ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_SHADOW_MAP_SIZE;
+ c.size=8;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_intw(io, shadow->map_size);
+ }
+
+ if (shadow->samples) { /*---- LIB3DS_SHADOW_SAMPLES ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_SHADOW_SAMPLES;
+ c.size=8;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_intw(io, shadow->samples);
+ }
+
+ if (shadow->range) { /*---- LIB3DS_SHADOW_RANGE ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_SHADOW_RANGE;
+ c.size=10;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_intd(io, shadow->range);
+ }
+
+ if (fabs(shadow->filter)>LIB3DS_EPSILON) { /*---- LIB3DS_SHADOW_FILTER ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_SHADOW_FILTER;
+ c.size=10;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_float(io, shadow->filter);
+ }
+ if (fabs(shadow->ray_bias)>LIB3DS_EPSILON) { /*---- LIB3DS_RAY_BIAS ----*/
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_RAY_BIAS;
+ c.size=10;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_float(io, shadow->ray_bias);
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+
+\typedef Lib3dsShadow
+ \ingroup shadow
+ \sa _Lib3dsShadow
+
+*/
--- /dev/null
+/* -*- c -*- */
+#ifndef INCLUDED_LIB3DS_SHADOW_H
+#define INCLUDED_LIB3DS_SHADOW_H
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: shadow.h,v 1.9 2004/12/31 16:17:15 reed Exp $
+ */
+
+#ifndef INCLUDED_LIB3DS_TYPES_H
+#include <lib3ds/types.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*!
+ * Shadow map settings
+ * \ingroup shadow
+ */
+struct _Lib3dsShadow {
+ Lib3dsIntw map_size;
+ Lib3dsFloat lo_bias;
+ Lib3dsFloat hi_bias;
+ Lib3dsIntw samples;
+ Lib3dsIntd range;
+ Lib3dsFloat filter;
+ Lib3dsFloat ray_bias;
+};
+
+extern LIB3DSAPI Lib3dsBool lib3ds_shadow_read(Lib3dsShadow *shadow, Lib3dsIo *io);
+extern LIB3DSAPI Lib3dsBool lib3ds_shadow_write(Lib3dsShadow *shadow, Lib3dsIo *io);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+
+
+
+
--- /dev/null
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: tcb.c,v 1.9 2001/07/07 19:05:30 jeh Exp $
+ */
+#define LIB3DS_EXPORT
+#include <lib3ds/tcb.h>
+#include <lib3ds/io.h>
+#include <math.h>
+
+
+/*!
+ * \defgroup tcb Tension/Continuity/Bias Splines
+ *
+ * \author J.E. Hoffmann <je-h@gmx.net>
+ */
+
+
+/*!
+ * \ingroup tcb
+ */
+void
+lib3ds_tcb(Lib3dsTcb *p, Lib3dsTcb *pc, Lib3dsTcb *c, Lib3dsTcb *nc, Lib3dsTcb *n,
+ Lib3dsFloat *ksm, Lib3dsFloat *ksp, Lib3dsFloat *kdm, Lib3dsFloat *kdp)
+{
+ Lib3dsFloat tm,cm,cp,bm,bp,tmcm,tmcp,cc;
+ Lib3dsFloat dt,fp,fn;
+
+ if (!pc) {
+ pc=c;
+ }
+ if (!nc) {
+ nc=c;
+ }
+
+ fp=fn=1.0f;
+ if (p&&n) {
+ dt=0.5f*(Lib3dsFloat)(pc->frame-p->frame+n->frame-nc->frame);
+ fp=((Lib3dsFloat)(pc->frame-p->frame))/dt;
+ fn=((Lib3dsFloat)(n->frame-nc->frame))/dt;
+ cc=(Lib3dsFloat)fabs(c->cont);
+ fp=fp+cc-cc*fp;
+ fn=fn+cc-cc*fn;
+ }
+
+ cm=1.0f-c->cont;
+ tm=0.5f*(1.0f-c->tens);
+ cp=2.0f-cm;
+ bm=1.0f-c->bias;
+ bp=2.0f-bm;
+ tmcm=tm*cm;
+ tmcp=tm*cp;
+ *ksm=tmcm*bp*fp;
+ *ksp=tmcp*bm*fp;
+ *kdm=tmcp*bp*fn;
+ *kdp=tmcm*bm*fn;
+}
+
+
+/*!
+ * \ingroup tcb
+ */
+Lib3dsBool
+lib3ds_tcb_read(Lib3dsTcb *tcb, Lib3dsIo *io)
+{
+ Lib3dsWord flags;
+
+ tcb->frame=lib3ds_io_read_intd(io);
+ tcb->flags=flags=lib3ds_io_read_word(io);
+ if (flags&LIB3DS_USE_TENSION) {
+ tcb->tens=lib3ds_io_read_float(io);
+ }
+ if (flags&LIB3DS_USE_CONTINUITY) {
+ tcb->cont=lib3ds_io_read_float(io);
+ }
+ if (flags&LIB3DS_USE_BIAS) {
+ tcb->bias=lib3ds_io_read_float(io);
+ }
+ if (flags&LIB3DS_USE_EASE_TO) {
+ tcb->ease_to=lib3ds_io_read_float(io);
+ }
+ if (flags&LIB3DS_USE_EASE_FROM) {
+ tcb->ease_from=lib3ds_io_read_float(io);
+ }
+ if (lib3ds_io_error(io)) {
+ return(LIB3DS_FALSE);
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup tcb
+ */
+Lib3dsBool
+lib3ds_tcb_write(Lib3dsTcb *tcb, Lib3dsIo *io)
+{
+ lib3ds_io_write_intd(io, tcb->frame);
+ lib3ds_io_write_word(io, tcb->flags);
+ if (tcb->flags&LIB3DS_USE_TENSION) {
+ lib3ds_io_write_float(io, tcb->tens);
+ }
+ if (tcb->flags&LIB3DS_USE_CONTINUITY) {
+ lib3ds_io_write_float(io, tcb->cont);
+ }
+ if (tcb->flags&LIB3DS_USE_BIAS) {
+ lib3ds_io_write_float(io, tcb->bias);
+ }
+ if (tcb->flags&LIB3DS_USE_EASE_TO) {
+ lib3ds_io_write_float(io, tcb->ease_to);
+ }
+ if (tcb->flags&LIB3DS_USE_EASE_FROM) {
+ lib3ds_io_write_float(io, tcb->ease_from);
+ }
+ if (lib3ds_io_error(io)) {
+ return(LIB3DS_FALSE);
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+
+
--- /dev/null
+/* -*- c -*- */
+#ifndef INCLUDED_LIB3DS_TCB_H
+#define INCLUDED_LIB3DS_TCB_H
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: tcb.h,v 1.9 2004/12/31 16:17:15 reed Exp $
+ */
+
+#ifndef INCLUDED_LIB3DS_TYPES_H
+#include <lib3ds/types.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum _Lib3dsTcbFlags{
+ LIB3DS_USE_TENSION =0x0001,
+ LIB3DS_USE_CONTINUITY =0x0002,
+ LIB3DS_USE_BIAS =0x0004,
+ LIB3DS_USE_EASE_TO =0x0008,
+ LIB3DS_USE_EASE_FROM =0x0010
+} Lib3dsTcbFlags;
+
+typedef struct _Lib3dsTcb {
+ Lib3dsIntd frame;
+ Lib3dsWord flags;
+ Lib3dsFloat tens;
+ Lib3dsFloat cont;
+ Lib3dsFloat bias;
+ Lib3dsFloat ease_to;
+ Lib3dsFloat ease_from;
+} Lib3dsTcb;
+
+extern LIB3DSAPI void lib3ds_tcb(Lib3dsTcb *p, Lib3dsTcb *pc, Lib3dsTcb *c,
+ Lib3dsTcb *nc, Lib3dsTcb *n, Lib3dsFloat *ksm, Lib3dsFloat *ksp,
+ Lib3dsFloat *kdm, Lib3dsFloat *kdp);
+extern LIB3DSAPI Lib3dsBool lib3ds_tcb_read(Lib3dsTcb *tcb, Lib3dsIo *io);
+extern LIB3DSAPI Lib3dsBool lib3ds_tcb_write(Lib3dsTcb *tcb, Lib3dsIo *io);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+
--- /dev/null
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: tracks.c,v 1.14 2004/11/20 09:00:38 efalk Exp $
+ */
+#define LIB3DS_EXPORT
+#include <lib3ds/tracks.h>
+#include <lib3ds/io.h>
+#include <lib3ds/chunk.h>
+#include <lib3ds/float.h>
+#include <lib3ds/vector.h>
+#include <lib3ds/quat.h>
+#include <lib3ds/node.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#ifdef WITH_DMALLOC
+#include <dmalloc.h>
+#endif
+
+
+/*!
+ * \defgroup tracks Keyframing Tracks
+ *
+ * \author J.E. Hoffmann <je-h@gmx.net>
+ */
+
+
+/*!
+ * \ingroup tracks
+ */
+Lib3dsBoolKey*
+lib3ds_bool_key_new()
+{
+ Lib3dsBoolKey* k;
+ k=(Lib3dsBoolKey*)calloc(sizeof(Lib3dsBoolKey), 1);
+ return(k);
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+void
+lib3ds_bool_key_free(Lib3dsBoolKey *key)
+{
+ ASSERT(key);
+ free(key);
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+void
+lib3ds_bool_track_free_keys(Lib3dsBoolTrack *track)
+{
+ Lib3dsBoolKey *p,*q;
+
+ ASSERT(track);
+ for (p=track->keyL; p; p=q) {
+ q=p->next;
+ lib3ds_bool_key_free(p);
+ }
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+void
+lib3ds_bool_track_insert(Lib3dsBoolTrack *track, Lib3dsBoolKey *key)
+{
+ ASSERT(track);
+ ASSERT(key);
+ ASSERT(!key->next);
+
+ if (!track->keyL) {
+ track->keyL=key;
+ key->next=0;
+ }
+ else {
+ Lib3dsBoolKey *k,*p;
+
+ for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
+ if (k->tcb.frame>key->tcb.frame) {
+ break;
+ }
+ }
+ if (!p) {
+ key->next=track->keyL;
+ track->keyL=key;
+ }
+ else {
+ key->next=k;
+ p->next=key;
+ }
+
+ if (k && (key->tcb.frame==k->tcb.frame)) {
+ key->next=k->next;
+ lib3ds_bool_key_free(k);
+ }
+ }
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+void
+lib3ds_bool_track_remove(Lib3dsBoolTrack *track, Lib3dsIntd frame)
+{
+ Lib3dsBoolKey *k,*p;
+
+ ASSERT(track);
+ if (!track->keyL) {
+ return;
+ }
+ for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
+ if (k->tcb.frame==frame) {
+ if (!p) {
+ track->keyL=track->keyL->next;
+ }
+ else {
+ p->next=k->next;
+ }
+ lib3ds_bool_key_free(k);
+ break;
+ }
+ }
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+void
+lib3ds_bool_track_eval(Lib3dsBoolTrack *track, Lib3dsBool *p, Lib3dsFloat t)
+{
+ Lib3dsBoolKey *k;
+ Lib3dsBool result;
+
+ ASSERT(p);
+ if (!track->keyL) {
+ *p=LIB3DS_FALSE;
+ return;
+ }
+ if (!track->keyL->next) {
+ *p = LIB3DS_TRUE;
+ return;
+ }
+
+ result=LIB3DS_FALSE;
+ k=track->keyL;
+ while ((t<(Lib3dsFloat)k->tcb.frame) && (t>=(Lib3dsFloat)k->next->tcb.frame)) {
+ if (result) {
+ result=LIB3DS_FALSE;
+ }
+ else {
+ result=LIB3DS_TRUE;
+ }
+ if (!k->next) {
+ if (track->flags&LIB3DS_REPEAT) {
+ t-=(Lib3dsFloat)k->tcb.frame;
+ k=track->keyL;
+ }
+ else {
+ break;
+ }
+ }
+ else {
+ k=k->next;
+ }
+ }
+ *p=result;
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+Lib3dsBool
+lib3ds_bool_track_read(Lib3dsBoolTrack *track, Lib3dsIo *io)
+{
+ int keys;
+ int i;
+ Lib3dsBoolKey *k;
+
+ track->flags=lib3ds_io_read_word(io);
+ lib3ds_io_read_dword(io);
+ lib3ds_io_read_dword(io);
+ keys=lib3ds_io_read_intd(io);
+
+ for (i=0; i<keys; ++i) {
+ k=lib3ds_bool_key_new();
+ if (!lib3ds_tcb_read(&k->tcb, io)) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_bool_track_insert(track, k);
+ }
+
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+Lib3dsBool
+lib3ds_bool_track_write(Lib3dsBoolTrack *track, Lib3dsIo *io)
+{
+ Lib3dsBoolKey *k;
+ Lib3dsDword num=0;
+ for (k=track->keyL; k; k=k->next) {
+ ++num;
+ }
+ lib3ds_io_write_word(io, (Lib3dsWord)track->flags);
+ lib3ds_io_write_dword(io, 0);
+ lib3ds_io_write_dword(io, 0);
+ lib3ds_io_write_dword(io, num);
+
+ for (k=track->keyL; k; k=k->next) {
+ if (!lib3ds_tcb_write(&k->tcb,io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+Lib3dsLin1Key*
+lib3ds_lin1_key_new()
+{
+ Lib3dsLin1Key* k;
+ k=(Lib3dsLin1Key*)calloc(sizeof(Lib3dsLin1Key), 1);
+ return(k);
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+void
+lib3ds_lin1_key_free(Lib3dsLin1Key *key)
+{
+ ASSERT(key);
+ free(key);
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+void
+lib3ds_lin1_track_free_keys(Lib3dsLin1Track *track)
+{
+ Lib3dsLin1Key *p,*q;
+
+ ASSERT(track);
+ for (p=track->keyL; p; p=q) {
+ q=p->next;
+ lib3ds_lin1_key_free(p);
+ }
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+void
+lib3ds_lin1_key_setup(Lib3dsLin1Key *p, Lib3dsLin1Key *cp, Lib3dsLin1Key *c,
+ Lib3dsLin1Key *cn, Lib3dsLin1Key *n)
+{
+ Lib3dsFloat np,nn;
+ Lib3dsFloat ksm,ksp,kdm,kdp;
+
+ ASSERT(c);
+ if (!cp) {
+ cp=c;
+ }
+ if (!cn) {
+ cn=c;
+ }
+ if (!p && !n) {
+ c->ds=0;
+ c->dd=0;
+ return;
+ }
+
+ if (n && p) {
+ lib3ds_tcb(&p->tcb, &cp->tcb, &c->tcb, &cn->tcb, &n->tcb, &ksm, &ksp, &kdm, &kdp);
+ np = c->value - p->value;
+ nn = n->value - c->value;
+
+ c->ds=ksm*np + ksp*nn;
+ c->dd=kdm*np + kdp*nn;
+ }
+ else {
+ if (p) {
+ np = c->value - p->value;
+ c->ds = np;
+ c->dd = np;
+ }
+ if (n) {
+ nn = n->value - c->value;
+ c->ds = nn;
+ c->dd = nn;
+ }
+ }
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+void
+lib3ds_lin1_track_setup(Lib3dsLin1Track *track)
+{
+ Lib3dsLin1Key *pp,*pc,*pn,*pl;
+
+ ASSERT(track);
+ pc=track->keyL;
+ if (!pc) {
+ return;
+ }
+ if (!pc->next) {
+ pc->ds=0;
+ pc->dd=0;
+ return;
+ }
+
+ if (track->flags&LIB3DS_SMOOTH) {
+ for (pl=track->keyL; pl->next->next; pl=pl->next);
+ lib3ds_lin1_key_setup(pl, pl->next, pc, 0, pc->next);
+ }
+ else {
+ lib3ds_lin1_key_setup(0, 0, pc, 0, pc->next);
+ }
+ for (;;) {
+ pp=pc;
+ pc=pc->next;
+ pn=pc->next;
+ if (!pn) {
+ break;
+ }
+ lib3ds_lin1_key_setup(pp, 0, pc, 0, pn);
+ }
+
+ if (track->flags&LIB3DS_SMOOTH) {
+ lib3ds_lin1_key_setup(pp, 0, pc, track->keyL, track->keyL->next);
+ }
+ else {
+ lib3ds_lin1_key_setup(pp, 0, pc, 0, 0);
+ }
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+void
+lib3ds_lin1_track_insert(Lib3dsLin1Track *track, Lib3dsLin1Key *key)
+{
+ ASSERT(track);
+ ASSERT(key);
+ ASSERT(!key->next);
+
+ if (!track->keyL) {
+ track->keyL=key;
+ key->next=0;
+ }
+ else {
+ Lib3dsLin1Key *k,*p;
+
+ for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
+ if (k->tcb.frame>key->tcb.frame) {
+ break;
+ }
+ }
+ if (!p) {
+ key->next=track->keyL;
+ track->keyL=key;
+ }
+ else {
+ key->next=k;
+ p->next=key;
+ }
+
+ if (k && (key->tcb.frame==k->tcb.frame)) {
+ key->next=k->next;
+ lib3ds_lin1_key_free(k);
+ }
+ }
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+void
+lib3ds_lin1_track_remove(Lib3dsLin1Track *track, Lib3dsIntd frame)
+{
+ Lib3dsLin1Key *k,*p;
+
+ ASSERT(track);
+ if (!track->keyL) {
+ return;
+ }
+ for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
+ if (k->tcb.frame==frame) {
+ if (!p) {
+ track->keyL=track->keyL->next;
+ }
+ else {
+ p->next=k->next;
+ }
+ lib3ds_lin1_key_free(k);
+ break;
+ }
+ }
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+void
+lib3ds_lin1_track_eval(Lib3dsLin1Track *track, Lib3dsFloat *p, Lib3dsFloat t)
+{
+ Lib3dsLin1Key *k;
+ Lib3dsFloat nt;
+ Lib3dsFloat u;
+
+ ASSERT(p);
+ if (!track->keyL) {
+ *p=0;
+ return;
+ }
+ if (!track->keyL->next) {
+ *p = track->keyL->value;
+ return;
+ }
+
+ for (k=track->keyL; k->next!=0; k=k->next) {
+ if ((t>=(Lib3dsFloat)k->tcb.frame) && (t<(Lib3dsFloat)k->next->tcb.frame)) {
+ break;
+ }
+ }
+ if (!k->next) {
+ if (track->flags&LIB3DS_REPEAT) {
+ nt=(Lib3dsFloat)fmod(t, k->tcb.frame);
+ for (k=track->keyL; k->next!=0; k=k->next) {
+ if ((nt>=(Lib3dsFloat)k->tcb.frame) && (nt<(Lib3dsFloat)k->next->tcb.frame)) {
+ break;
+ }
+ }
+ ASSERT(k->next);
+ }
+ else {
+ *p = k->value;
+ return;
+ }
+ }
+ else {
+ nt=t;
+ }
+ u=nt - (Lib3dsFloat)k->tcb.frame;
+ u/=(Lib3dsFloat)(k->next->tcb.frame - k->tcb.frame);
+
+ *p = lib3ds_float_cubic(
+ k->value,
+ k->dd,
+ k->next->ds,
+ k->next->value,
+ u
+ );
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+Lib3dsBool
+lib3ds_lin1_track_read(Lib3dsLin1Track *track, Lib3dsIo *io)
+{
+ int keys;
+ int i;
+ Lib3dsLin1Key *k;
+
+ track->flags=lib3ds_io_read_word(io);
+ lib3ds_io_read_dword(io);
+ lib3ds_io_read_dword(io);
+ keys=lib3ds_io_read_intd(io);
+
+ for (i=0; i<keys; ++i) {
+ k=lib3ds_lin1_key_new();
+ if (!lib3ds_tcb_read(&k->tcb, io)) {
+ return(LIB3DS_FALSE);
+ }
+ k->value=lib3ds_io_read_float(io);
+ lib3ds_lin1_track_insert(track, k);
+ }
+ lib3ds_lin1_track_setup(track);
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+Lib3dsBool
+lib3ds_lin1_track_write(Lib3dsLin1Track *track, Lib3dsIo *io)
+{
+ Lib3dsLin1Key *k;
+ Lib3dsDword num=0;
+ for (k=track->keyL; k; k=k->next) {
+ ++num;
+ }
+ lib3ds_io_write_word(io, (Lib3dsWord)track->flags);
+ lib3ds_io_write_dword(io, 0);
+ lib3ds_io_write_dword(io, 0);
+ lib3ds_io_write_dword(io, num);
+
+ for (k=track->keyL; k; k=k->next) {
+ if (!lib3ds_tcb_write(&k->tcb,io)) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_io_write_float(io, k->value);
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * Create and return one keyframe in a Lin3 track. All values are
+ * initialized to zero.
+ *
+ * \ingroup tracks
+ */
+Lib3dsLin3Key*
+lib3ds_lin3_key_new()
+{
+ Lib3dsLin3Key* k;
+ k=(Lib3dsLin3Key*)calloc(sizeof(Lib3dsLin3Key), 1);
+ return(k);
+}
+
+
+/*!
+ * Free a Lin3 keyframe.
+ *
+ * \ingroup tracks
+ */
+void
+lib3ds_lin3_key_free(Lib3dsLin3Key *key)
+{
+ ASSERT(key);
+ free(key);
+}
+
+
+/*!
+ * Free all keyframes in a Lin3 track.
+ *
+ * \ingroup tracks
+ */
+void
+lib3ds_lin3_track_free_keys(Lib3dsLin3Track *track)
+{
+ Lib3dsLin3Key *p,*q;
+
+ ASSERT(track);
+ for (p=track->keyL; p; p=q) {
+ q=p->next;
+ lib3ds_lin3_key_free(p);
+ }
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+void
+lib3ds_lin3_key_setup(Lib3dsLin3Key *p, Lib3dsLin3Key *cp, Lib3dsLin3Key *c,
+ Lib3dsLin3Key *cn, Lib3dsLin3Key *n)
+{
+ Lib3dsVector np,nn;
+ Lib3dsFloat ksm,ksp,kdm,kdp;
+ int i;
+
+ ASSERT(c);
+ if (!cp) {
+ cp=c;
+ }
+ if (!cn) {
+ cn=c;
+ }
+ if (!p && !n) {
+ lib3ds_vector_zero(c->ds);
+ lib3ds_vector_zero(c->dd);
+ return;
+ }
+
+ if (n && p) {
+ lib3ds_tcb(&p->tcb, &cp->tcb, &c->tcb, &cn->tcb, &n->tcb, &ksm, &ksp, &kdm, &kdp);
+ lib3ds_vector_sub(np, c->value, p->value);
+ lib3ds_vector_sub(nn, n->value, c->value);
+
+ for(i=0; i<3; ++i) {
+ c->ds[i]=ksm*np[i] + ksp*nn[i];
+ c->dd[i]=kdm*np[i] + kdp*nn[i];
+ }
+ }
+ else {
+ if (p) {
+ lib3ds_vector_sub(np, c->value, p->value);
+ lib3ds_vector_copy(c->ds, np);
+ lib3ds_vector_copy(c->dd, np);
+ }
+ if (n) {
+ lib3ds_vector_sub(nn, n->value, c->value);
+ lib3ds_vector_copy(c->ds, nn);
+ lib3ds_vector_copy(c->dd, nn);
+ }
+ }
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+void
+lib3ds_lin3_track_setup(Lib3dsLin3Track *track)
+{
+ Lib3dsLin3Key *pp,*pc,*pn,*pl;
+
+ ASSERT(track);
+ pc=track->keyL;
+ if (!pc) {
+ return;
+ }
+ if (!pc->next) {
+ lib3ds_vector_zero(pc->ds);
+ lib3ds_vector_zero(pc->dd);
+ return;
+ }
+
+ if (track->flags&LIB3DS_SMOOTH) {
+ for (pl=track->keyL; pl->next->next; pl=pl->next);
+ lib3ds_lin3_key_setup(pl, pl->next, pc, 0, pc->next);
+ }
+ else {
+ lib3ds_lin3_key_setup(0, 0, pc, 0, pc->next);
+ }
+ for (;;) {
+ pp=pc;
+ pc=pc->next;
+ pn=pc->next;
+ if (!pn) {
+ break;
+ }
+ lib3ds_lin3_key_setup(pp, 0, pc, 0, pn);
+ }
+
+ if (track->flags&LIB3DS_SMOOTH) {
+ lib3ds_lin3_key_setup(pp, 0, pc, track->keyL, track->keyL->next);
+ }
+ else {
+ lib3ds_lin3_key_setup(pp, 0, pc, 0, 0);
+ }
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+void
+lib3ds_lin3_track_insert(Lib3dsLin3Track *track, Lib3dsLin3Key *key)
+{
+ ASSERT(track);
+ ASSERT(key);
+ ASSERT(!key->next);
+
+ if (!track->keyL) {
+ track->keyL=key;
+ key->next=0;
+ }
+ else {
+ Lib3dsLin3Key *k,*p;
+
+ for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
+ if (k->tcb.frame>key->tcb.frame) {
+ break;
+ }
+ }
+ if (!p) {
+ key->next=track->keyL;
+ track->keyL=key;
+ }
+ else {
+ key->next=k;
+ p->next=key;
+ }
+
+ if (k && (key->tcb.frame==k->tcb.frame)) {
+ key->next=k->next;
+ lib3ds_lin3_key_free(k);
+ }
+ }
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+void
+lib3ds_lin3_track_remove(Lib3dsLin3Track *track, Lib3dsIntd frame)
+{
+ Lib3dsLin3Key *k,*p;
+
+ ASSERT(track);
+ if (!track->keyL) {
+ return;
+ }
+ for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
+ if (k->tcb.frame==frame) {
+ if (!p) {
+ track->keyL=track->keyL->next;
+ }
+ else {
+ p->next=k->next;
+ }
+ lib3ds_lin3_key_free(k);
+ break;
+ }
+ }
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+void
+lib3ds_lin3_track_eval(Lib3dsLin3Track *track, Lib3dsVector p, Lib3dsFloat t)
+{
+ Lib3dsLin3Key *k;
+ Lib3dsFloat nt;
+ Lib3dsFloat u;
+
+ if (!track->keyL) {
+ lib3ds_vector_zero(p);
+ return;
+ }
+ if (!track->keyL->next) {
+ lib3ds_vector_copy(p, track->keyL->value);
+ return;
+ }
+
+ for (k=track->keyL; k->next!=0; k=k->next) {
+ if ((t>=(Lib3dsFloat)k->tcb.frame) && (t<(Lib3dsFloat)k->next->tcb.frame)) {
+ break;
+ }
+ }
+ if (!k->next) {
+ if (track->flags&LIB3DS_REPEAT) {
+ nt=(Lib3dsFloat)fmod(t, k->tcb.frame);
+ for (k=track->keyL; k->next!=0; k=k->next) {
+ if ((nt>=(Lib3dsFloat)k->tcb.frame) && (nt<(Lib3dsFloat)k->next->tcb.frame)) {
+ break;
+ }
+ }
+ ASSERT(k->next);
+ }
+ else {
+ lib3ds_vector_copy(p, k->value);
+ return;
+ }
+ }
+ else {
+ nt=t;
+ }
+ u=nt - (Lib3dsFloat)k->tcb.frame;
+ u/=(Lib3dsFloat)(k->next->tcb.frame - k->tcb.frame);
+
+ lib3ds_vector_cubic(
+ p,
+ k->value,
+ k->dd,
+ k->next->ds,
+ k->next->value,
+ u
+ );
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+Lib3dsBool
+lib3ds_lin3_track_read(Lib3dsLin3Track *track, Lib3dsIo *io)
+{
+ int keys;
+ int i,j;
+ Lib3dsLin3Key *k;
+
+ track->flags=lib3ds_io_read_word(io);
+ lib3ds_io_read_dword(io);
+ lib3ds_io_read_dword(io);
+ keys=lib3ds_io_read_intd(io);
+
+ for (i=0; i<keys; ++i) {
+ k=lib3ds_lin3_key_new();
+ if (!lib3ds_tcb_read(&k->tcb, io)) {
+ return(LIB3DS_FALSE);
+ }
+ for (j=0; j<3; ++j) {
+ k->value[j]=lib3ds_io_read_float(io);
+ }
+ lib3ds_lin3_track_insert(track, k);
+ }
+ lib3ds_lin3_track_setup(track);
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+Lib3dsBool
+lib3ds_lin3_track_write(Lib3dsLin3Track *track, Lib3dsIo *io)
+{
+ Lib3dsLin3Key *k;
+ Lib3dsDword num=0;
+ for (k=track->keyL; k; k=k->next) {
+ ++num;
+ }
+ lib3ds_io_write_word(io, (Lib3dsWord)track->flags);
+ lib3ds_io_write_dword(io, 0);
+ lib3ds_io_write_dword(io, 0);
+ lib3ds_io_write_dword(io, num);
+
+ for (k=track->keyL; k; k=k->next) {
+ if (!lib3ds_tcb_write(&k->tcb,io)) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_io_write_vector(io, k->value);
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+Lib3dsQuatKey*
+lib3ds_quat_key_new()
+{
+ Lib3dsQuatKey* k;
+ k=(Lib3dsQuatKey*)calloc(sizeof(Lib3dsQuatKey), 1);
+ return(k);
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+void
+lib3ds_quat_key_free(Lib3dsQuatKey *key)
+{
+ ASSERT(key);
+ free(key);
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+void
+lib3ds_quat_track_free_keys(Lib3dsQuatTrack *track)
+{
+ Lib3dsQuatKey *p,*q;
+
+ ASSERT(track);
+ for (p=track->keyL; p; p=q) {
+ q=p->next;
+ lib3ds_quat_key_free(p);
+ }
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+void
+lib3ds_quat_key_setup(Lib3dsQuatKey *p, Lib3dsQuatKey *cp, Lib3dsQuatKey *c,
+ Lib3dsQuatKey *cn, Lib3dsQuatKey *n)
+{
+ Lib3dsFloat ksm,ksp,kdm,kdp;
+ Lib3dsQuat q,qp,qn,qa,qb;
+ int i;
+
+ ASSERT(c);
+ if (!cp) {
+ cp=c;
+ }
+ if (!cn) {
+ cn=c;
+ }
+ if (!p || !n) {
+ lib3ds_quat_copy(c->ds, c->q);
+ lib3ds_quat_copy(c->dd, c->q);
+ return;
+ }
+
+ if (p) {
+ if (p->angle>LIB3DS_TWOPI-LIB3DS_EPSILON) {
+ lib3ds_quat_axis_angle(qp, p->axis, 0.0f);
+ lib3ds_quat_ln(qp);
+ }
+ else {
+ lib3ds_quat_copy(q, p->q);
+ if (lib3ds_quat_dot(q,c->q)<0) lib3ds_quat_neg(q);
+ lib3ds_quat_ln_dif(qp, c->q, q);
+ }
+ }
+ if (n) {
+ if (n->angle>LIB3DS_TWOPI-LIB3DS_EPSILON) {
+ lib3ds_quat_axis_angle(qn, n->axis, 0.0f);
+ lib3ds_quat_ln(qn);
+ }
+ else {
+ lib3ds_quat_copy(q, n->q);
+ if (lib3ds_quat_dot(q,c->q)<0) lib3ds_quat_neg(q);
+ lib3ds_quat_ln_dif(qn, c->q, q);
+ }
+ }
+
+ if (n && p) {
+ lib3ds_tcb(&p->tcb, &cp->tcb, &c->tcb, &cn->tcb, &n->tcb, &ksm, &ksp, &kdm, &kdp);
+ for(i=0; i<4; i++) {
+ qa[i]=-0.5f*(kdm*qn[i]+kdp*qp[i]);
+ qb[i]=-0.5f*(ksm*qn[i]+ksp*qp[i]);
+ }
+ lib3ds_quat_exp(qa);
+ lib3ds_quat_exp(qb);
+
+ lib3ds_quat_mul(c->ds, c->q, qa);
+ lib3ds_quat_mul(c->dd, c->q, qb);
+ }
+ else {
+ if (p) {
+ lib3ds_quat_exp(qp);
+ lib3ds_quat_mul(c->ds, c->q, qp);
+ lib3ds_quat_mul(c->dd, c->q, qp);
+ }
+ if (n) {
+ lib3ds_quat_exp(qn);
+ lib3ds_quat_mul(c->ds, c->q, qn);
+ lib3ds_quat_mul(c->dd, c->q, qn);
+ }
+ }
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+void
+lib3ds_quat_track_setup(Lib3dsQuatTrack *track)
+{
+ Lib3dsQuatKey *pp,*pc,*pn,*pl;
+ Lib3dsQuat q;
+
+ ASSERT(track);
+ for (pp=0,pc=track->keyL; pc; pp=pc,pc=pc->next) {
+ lib3ds_quat_axis_angle(q, pc->axis, pc->angle);
+ if (pp) {
+ lib3ds_quat_mul(pc->q, q, pp->q);
+ }
+ else {
+ lib3ds_quat_copy(pc->q, q);
+ }
+ }
+
+ pc=track->keyL;
+ if (!pc) {
+ return;
+ }
+ if (!pc->next) {
+ lib3ds_quat_copy(pc->ds, pc->q);
+ lib3ds_quat_copy(pc->dd, pc->q);
+ return;
+ }
+
+ if (track->flags&LIB3DS_SMOOTH) {
+ for (pl=track->keyL; pl->next->next; pl=pl->next);
+ lib3ds_quat_key_setup(pl, pl->next, pc, 0, pc->next);
+ }
+ else {
+ lib3ds_quat_key_setup(0, 0, pc, 0, pc->next);
+ }
+ for (;;) {
+ pp=pc;
+ pc=pc->next;
+ pn=pc->next;
+ if (!pn) {
+ break;
+ }
+ lib3ds_quat_key_setup(pp, 0, pc, 0, pn);
+ }
+
+ if (track->flags&LIB3DS_SMOOTH) {
+ lib3ds_quat_key_setup(pp, 0, pc, track->keyL, track->keyL->next);
+ }
+ else {
+ lib3ds_quat_key_setup(pp, 0, pc, 0, 0);
+ }
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+void
+lib3ds_quat_track_insert(Lib3dsQuatTrack *track, Lib3dsQuatKey *key)
+{
+ ASSERT(track);
+ ASSERT(key);
+ ASSERT(!key->next);
+
+ if (!track->keyL) {
+ track->keyL=key;
+ key->next=0;
+ }
+ else {
+ Lib3dsQuatKey *k,*p;
+
+ for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
+ if (k->tcb.frame>key->tcb.frame) {
+ break;
+ }
+ }
+ if (!p) {
+ key->next=track->keyL;
+ track->keyL=key;
+ }
+ else {
+ key->next=k;
+ p->next=key;
+ }
+
+ if (k && (key->tcb.frame==k->tcb.frame)) {
+ key->next=k->next;
+ lib3ds_quat_key_free(k);
+ }
+ }
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+void
+lib3ds_quat_track_remove(Lib3dsQuatTrack *track, Lib3dsIntd frame)
+{
+ Lib3dsQuatKey *k,*p;
+
+ ASSERT(track);
+ if (!track->keyL) {
+ return;
+ }
+ for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
+ if (k->tcb.frame==frame) {
+ if (!p) {
+ track->keyL=track->keyL->next;
+ }
+ else {
+ p->next=k->next;
+ }
+ lib3ds_quat_key_free(k);
+ break;
+ }
+ }
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+void
+lib3ds_quat_track_eval(Lib3dsQuatTrack *track, Lib3dsQuat q, Lib3dsFloat t)
+{
+ Lib3dsQuatKey *k;
+ Lib3dsFloat nt;
+ Lib3dsFloat u;
+
+ if (!track->keyL) {
+ lib3ds_quat_identity(q);
+ return;
+ }
+ if (!track->keyL->next) {
+ lib3ds_quat_copy(q, track->keyL->q);
+ return;
+ }
+
+ for (k=track->keyL; k->next!=0; k=k->next) {
+ if ((t>=k->tcb.frame) && (t<k->next->tcb.frame)) {
+ break;
+ }
+ }
+ if (!k->next) {
+ if (track->flags&LIB3DS_REPEAT) {
+ nt=(Lib3dsFloat)fmod(t, k->tcb.frame);
+ for (k=track->keyL; k->next!=0; k=k->next) {
+ if ((nt>=k->tcb.frame) && (nt<k->next->tcb.frame)) {
+ break;
+ }
+ }
+ ASSERT(k->next);
+ }
+ else {
+ lib3ds_quat_copy(q, k->q);
+ return;
+ }
+ }
+ else {
+ nt=t;
+ }
+ u=nt - k->tcb.frame;
+ u/=(k->next->tcb.frame - k->tcb.frame);
+
+ lib3ds_quat_squad(
+ q,
+ k->q,
+ k->dd,
+ k->next->ds,
+ k->next->q,
+ u
+ );
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+Lib3dsBool
+lib3ds_quat_track_read(Lib3dsQuatTrack *track, Lib3dsIo *io)
+{
+ int keys;
+ int i,j;
+ Lib3dsQuatKey *p,*k;
+
+ track->flags=lib3ds_io_read_word(io);
+ lib3ds_io_read_dword(io);
+ lib3ds_io_read_dword(io);
+ keys=lib3ds_io_read_intd(io);
+
+ for (p=0,i=0; i<keys; p=k,++i) {
+ k=lib3ds_quat_key_new();
+ if (!lib3ds_tcb_read(&k->tcb, io)) {
+ return(LIB3DS_FALSE);
+ }
+ k->angle=lib3ds_io_read_float(io);
+ for (j=0; j<3; ++j) {
+ k->axis[j]=lib3ds_io_read_float(io);
+ }
+ lib3ds_quat_track_insert(track, k);
+ }
+ lib3ds_quat_track_setup(track);
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+Lib3dsBool
+lib3ds_quat_track_write(Lib3dsQuatTrack *track, Lib3dsIo *io)
+{
+ Lib3dsQuatKey *k;
+ Lib3dsDword num=0;
+ for (k=track->keyL; k; k=k->next) {
+ ++num;
+ }
+ lib3ds_io_write_word(io, (Lib3dsWord)track->flags);
+ lib3ds_io_write_dword(io, 0);
+ lib3ds_io_write_dword(io, 0);
+ lib3ds_io_write_dword(io, num);
+
+ for (k=track->keyL; k; k=k->next) {
+ if (!lib3ds_tcb_write(&k->tcb,io)) {
+ return(LIB3DS_FALSE);
+ }
+ lib3ds_io_write_float(io, k->angle);
+ lib3ds_io_write_vector(io, k->axis);
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+Lib3dsMorphKey*
+lib3ds_morph_key_new()
+{
+ Lib3dsMorphKey* k;
+ k=(Lib3dsMorphKey*)calloc(sizeof(Lib3dsMorphKey), 1);
+ return(k);
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+void
+lib3ds_morph_key_free(Lib3dsMorphKey *key)
+{
+ ASSERT(key);
+ free(key);
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+void
+lib3ds_morph_track_free_keys(Lib3dsMorphTrack *track)
+{
+ Lib3dsMorphKey *p,*q;
+
+ ASSERT(track);
+ for (p=track->keyL; p; p=q) {
+ q=p->next;
+ lib3ds_morph_key_free(p);
+ }
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+void
+lib3ds_morph_track_insert(Lib3dsMorphTrack *track, Lib3dsMorphKey *key)
+{
+ ASSERT(track);
+ ASSERT(key);
+ ASSERT(!key->next);
+
+ if (!track->keyL) {
+ track->keyL=key;
+ key->next=0;
+ }
+ else {
+ Lib3dsMorphKey *k,*p;
+
+ for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
+ if (k->tcb.frame>key->tcb.frame) {
+ break;
+ }
+ }
+ if (!p) {
+ key->next=track->keyL;
+ track->keyL=key;
+ }
+ else {
+ key->next=k;
+ p->next=key;
+ }
+
+ if (k && (key->tcb.frame==k->tcb.frame)) {
+ key->next=k->next;
+ lib3ds_morph_key_free(k);
+ }
+ }
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+void
+lib3ds_morph_track_remove(Lib3dsMorphTrack *track, Lib3dsIntd frame)
+{
+ Lib3dsMorphKey *k,*p;
+
+ ASSERT(track);
+ if (!track->keyL) {
+ return;
+ }
+ for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
+ if (k->tcb.frame==frame) {
+ if (!p) {
+ track->keyL=track->keyL->next;
+ }
+ else {
+ p->next=k->next;
+ }
+ lib3ds_morph_key_free(k);
+ break;
+ }
+ }
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+void
+lib3ds_morph_track_eval(Lib3dsMorphTrack *track, char *p, Lib3dsFloat t)
+{
+ Lib3dsMorphKey *k;
+ char* result;
+
+ ASSERT(p);
+ if (!track->keyL) {
+ strcpy(p,"");
+ return;
+ }
+ if (!track->keyL->next) {
+ strcpy(p,track->keyL->name);
+ return;
+ }
+
+
+ /* TODO: this function finds the mesh frame that corresponds to this
+ * timeframe. It would be better to actually interpolate the mesh.
+ */
+
+ result=0;
+
+ for(k = track->keyL;
+ k->next != NULL && t >= k->next->tcb.frame;
+ k = k->next);
+
+ result=k->name;
+
+ if (result) {
+ strcpy(p,result);
+ }
+ else {
+ strcpy(p,"");
+ }
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+Lib3dsBool
+lib3ds_morph_track_read(Lib3dsMorphTrack *track, Lib3dsIo *io)
+{
+ /* This function was written by Stephane Denis on 5-18-04 */
+ int i;
+ Lib3dsMorphKey *k, *pk = 0;
+ int keys;
+ track->flags=lib3ds_io_read_word(io);
+ lib3ds_io_read_dword(io);
+ lib3ds_io_read_dword(io);
+ keys=lib3ds_io_read_intd(io);
+
+ for (i=0; i<keys; ++i) {
+ k=lib3ds_morph_key_new();
+ if (!lib3ds_tcb_read(&k->tcb, io)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!lib3ds_io_read_string(io, k->name, 11)) {
+ return(LIB3DS_FALSE);
+ }
+ if (!track->keyL)
+ track->keyL = k;
+ else
+ pk->next = k;
+ pk = k;
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup tracks
+ */
+Lib3dsBool
+lib3ds_morph_track_write(Lib3dsMorphTrack *track, Lib3dsIo *io)
+{
+ /* FIXME: */
+ ASSERT(0);
+ return(LIB3DS_FALSE);
+}
+
+
+
+void
+tcb_dump(Lib3dsTcb *tcb)
+{
+ printf(" tcb: frame=%d, flags=%04x, tens=%g, cont=%g, ",
+ (int)tcb->frame, tcb->flags, tcb->tens, tcb->cont);
+ printf("bias=%g, ease_to=%g, ease_from=%g\n",
+ tcb->bias, tcb->ease_to, tcb->ease_from);
+}
+
+
+void
+lib3ds_boolTrack_dump(Lib3dsBoolTrack *track)
+{
+ Lib3dsBoolKey *key;
+ printf("flags: %08x, keys:\n", (unsigned int)track->flags);
+ for( key = track->keyL; key != NULL; key = key->next)
+ {
+ tcb_dump(&key->tcb);
+ }
+}
+
+
+void
+lib3ds_lin1Track_dump(Lib3dsLin1Track *track)
+{
+ Lib3dsLin1Key *key;
+ printf("flags: %08x, keys:\n", (unsigned int)track->flags);
+ for( key = track->keyL; key != NULL; key = key->next)
+ {
+ tcb_dump(&key->tcb);
+ printf(" value = %g, dd=%g, ds=%g\n",
+ key->value, key->dd, key->ds);
+ }
+}
+
+
+void
+lib3ds_lin3Track_dump(Lib3dsLin3Track *track)
+{
+ Lib3dsLin3Key *key;
+ printf("flags: %08x, keys:\n", (unsigned int)track->flags);
+ for( key = track->keyL; key != NULL; key = key->next)
+ {
+ tcb_dump(&key->tcb);
+ printf(" value = %g,%g,%g, dd=%g,%g,%g, ds=%g,%g,%g\n",
+ key->value[0], key->value[1], key->value[2],
+ key->dd[0], key->dd[1], key->dd[2],
+ key->ds[0], key->ds[1], key->ds[2]);
+ }
+}
+
+
+void
+lib3ds_quatTrack_dump(Lib3dsQuatTrack *track)
+{
+ Lib3dsQuatKey *key;
+ printf("flags: %08x, keys:\n", (unsigned int)track->flags);
+ for( key = track->keyL; key != NULL; key = key->next)
+ {
+ tcb_dump(&key->tcb);
+ printf(" axis = %g,%g,%g, angle=%g, q=%g,%g,%g,%g\n",
+ key->axis[0], key->axis[1], key->axis[2], key->angle,
+ key->q[0], key->q[1], key->q[2], key->q[3]);
+ printf(" dd = %g,%g,%g,%g, ds=%g,%g,%g,%g\n",
+ key->dd[0], key->dd[1], key->dd[2], key->dd[3],
+ key->ds[0], key->ds[1], key->ds[2], key->ds[3]);
+ }
+}
+
+
+void
+lib3ds_morphTrack_dump(Lib3dsMorphTrack *track)
+{
+ Lib3dsMorphKey *key;
+ printf("flags: %08x, keys:\n", (unsigned int)track->flags);
+ for( key = track->keyL; key != NULL; key = key->next)
+ {
+ tcb_dump(&key->tcb);
+ printf(" name = %s\n", key->name);
+ }
+}
+
+
+
+void
+lib3ds_dump_tracks(Lib3dsNode *node)
+{
+ switch( node->type ) {
+ case LIB3DS_AMBIENT_NODE:
+ printf("ambient: ");
+ lib3ds_lin3Track_dump(&node->data.ambient.col_track);
+ break;
+ case LIB3DS_OBJECT_NODE:
+ printf("pos: ");
+ lib3ds_lin3Track_dump(&node->data.object.pos_track);
+ printf("rot: ");
+ lib3ds_quatTrack_dump(&node->data.object.rot_track);
+ printf("scl: ");
+ lib3ds_lin3Track_dump(&node->data.object.scl_track);
+ printf("morph: ");
+ lib3ds_morphTrack_dump(&node->data.object.morph_track);
+ printf("hide: ");
+ lib3ds_boolTrack_dump(&node->data.object.hide_track);
+ break;
+ case LIB3DS_CAMERA_NODE:
+ printf("pos: ");
+ lib3ds_lin3Track_dump(&node->data.camera.pos_track);
+ printf("fov: ");
+ lib3ds_lin1Track_dump(&node->data.camera.fov_track);
+ printf("roll: ");
+ lib3ds_lin1Track_dump(&node->data.camera.roll_track);
+ break;
+ case LIB3DS_TARGET_NODE:
+ printf("pos: ");
+ lib3ds_lin3Track_dump(&node->data.target.pos_track);
+ break;
+ case LIB3DS_LIGHT_NODE:
+ printf("pos: ");
+ lib3ds_lin3Track_dump(&node->data.light.pos_track);
+ printf("col: ");
+ lib3ds_lin3Track_dump(&node->data.light.col_track);
+ printf("hotspot: ");
+ lib3ds_lin1Track_dump(&node->data.light.hotspot_track);
+ printf("falloff: ");
+ lib3ds_lin1Track_dump(&node->data.light.falloff_track);
+ printf("roll: ");
+ lib3ds_lin1Track_dump(&node->data.light.roll_track);
+ break;
+ case LIB3DS_SPOT_NODE:
+ printf("pos: ");
+ lib3ds_lin3Track_dump(&node->data.spot.pos_track);
+ break;
+
+ default:
+ break;
+ }
+}
--- /dev/null
+/* -*- c -*- */
+#ifndef INCLUDED_LIB3DS_TRACKS_H
+#define INCLUDED_LIB3DS_TRACKS_H
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: tracks.h,v 1.9 2004/12/31 16:17:15 reed Exp $
+ */
+
+#ifndef INCLUDED_LIB3DS_TCB_H
+#include <lib3ds/tcb.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*!
+ * Track flags
+ * \ingroup tracks
+ */
+typedef enum {
+ LIB3DS_REPEAT =0x0001,
+ LIB3DS_SMOOTH =0x0002,
+ LIB3DS_LOCK_X =0x0008,
+ LIB3DS_LOCK_Y =0x0010,
+ LIB3DS_LOCK_Z =0x0020,
+ LIB3DS_UNLINK_X =0x0100,
+ LIB3DS_UNLINK_Y =0x0200,
+ LIB3DS_UNLINK_Z =0x0400
+} Lib3dsTrackFlags;
+
+/*!
+ * Boolean track key
+ * \ingroup tracks
+ */
+struct _Lib3dsBoolKey {
+ Lib3dsTcb tcb;
+ Lib3dsBoolKey *next;
+};
+
+/*!
+ * Boolean track
+ * \ingroup tracks
+ */
+struct _Lib3dsBoolTrack {
+ Lib3dsDword flags;
+ Lib3dsBoolKey *keyL;
+};
+
+/*!
+ * Floating-point track key
+ * \ingroup tracks
+ */
+struct _Lib3dsLin1Key {
+ Lib3dsTcb tcb;
+ Lib3dsLin1Key *next;
+ Lib3dsFloat value;
+ Lib3dsFloat dd;
+ Lib3dsFloat ds;
+};
+
+/*!
+ * Floating-point track
+ * \ingroup tracks
+ */
+struct _Lib3dsLin1Track {
+ Lib3dsDword flags;
+ Lib3dsLin1Key *keyL;
+};
+
+/*!
+ * Vector track key
+ * \ingroup tracks
+ */
+struct _Lib3dsLin3Key {
+ Lib3dsTcb tcb;
+ Lib3dsLin3Key *next;
+ Lib3dsVector value;
+ Lib3dsVector dd;
+ Lib3dsVector ds;
+};
+
+/*!
+ * Vector track
+ * \ingroup tracks
+ */
+struct _Lib3dsLin3Track {
+ Lib3dsDword flags;
+ Lib3dsLin3Key *keyL;
+};
+
+/*!
+ * Rotation track key
+ * \ingroup tracks
+ */
+struct _Lib3dsQuatKey {
+ Lib3dsTcb tcb;
+ Lib3dsQuatKey *next;
+ Lib3dsVector axis;
+ Lib3dsFloat angle;
+ Lib3dsQuat q;
+ Lib3dsQuat dd;
+ Lib3dsQuat ds;
+};
+
+/*!
+ * Rotation track
+ * \ingroup tracks
+ */
+struct _Lib3dsQuatTrack {
+ Lib3dsDword flags;
+ Lib3dsQuatKey *keyL;
+};
+
+/*!
+ * Morph track key
+ * \ingroup tracks
+ */
+struct _Lib3dsMorphKey {
+ Lib3dsTcb tcb;
+ Lib3dsMorphKey *next;
+ char name[64];
+};
+
+/*!
+ * Morph track
+ * \ingroup tracks
+ */
+struct _Lib3dsMorphTrack {
+ Lib3dsDword flags;
+ Lib3dsMorphKey *keyL;
+};
+
+extern LIB3DSAPI Lib3dsBoolKey* lib3ds_bool_key_new();
+extern LIB3DSAPI void lib3ds_bool_key_free(Lib3dsBoolKey* key);
+extern LIB3DSAPI void lib3ds_bool_track_free_keys(Lib3dsBoolTrack *track);
+extern LIB3DSAPI void lib3ds_bool_track_insert(Lib3dsBoolTrack *track, Lib3dsBoolKey* key);
+extern LIB3DSAPI void lib3ds_bool_track_remove(Lib3dsBoolTrack *track, Lib3dsIntd frame);
+extern LIB3DSAPI void lib3ds_bool_track_eval(Lib3dsBoolTrack *track, Lib3dsBool *p, Lib3dsFloat t);
+extern LIB3DSAPI Lib3dsBool lib3ds_bool_track_read(Lib3dsBoolTrack *track, Lib3dsIo *io);
+extern LIB3DSAPI Lib3dsBool lib3ds_bool_track_write(Lib3dsBoolTrack *track, Lib3dsIo *io);
+
+extern LIB3DSAPI Lib3dsLin1Key* lib3ds_lin1_key_new();
+extern LIB3DSAPI void lib3ds_lin1_key_free(Lib3dsLin1Key* key);
+extern LIB3DSAPI void lib3ds_lin1_track_free_keys(Lib3dsLin1Track *track);
+extern LIB3DSAPI void lib3ds_lin1_key_setup(Lib3dsLin1Key *p, Lib3dsLin1Key *cp, Lib3dsLin1Key *c,
+ Lib3dsLin1Key *cn, Lib3dsLin1Key *n);
+extern LIB3DSAPI void lib3ds_lin1_track_setup(Lib3dsLin1Track *track);
+extern LIB3DSAPI void lib3ds_lin1_track_insert(Lib3dsLin1Track *track, Lib3dsLin1Key *key);
+extern LIB3DSAPI void lib3ds_lin1_track_remove(Lib3dsLin1Track *track, Lib3dsIntd frame);
+extern LIB3DSAPI void lib3ds_lin1_track_eval(Lib3dsLin1Track *track, Lib3dsFloat *p, Lib3dsFloat t);
+extern LIB3DSAPI Lib3dsBool lib3ds_lin1_track_read(Lib3dsLin1Track *track, Lib3dsIo *io);
+extern LIB3DSAPI Lib3dsBool lib3ds_lin1_track_write(Lib3dsLin1Track *track, Lib3dsIo *io);
+
+extern LIB3DSAPI Lib3dsLin3Key* lib3ds_lin3_key_new();
+extern LIB3DSAPI void lib3ds_lin3_key_free(Lib3dsLin3Key* key);
+extern LIB3DSAPI void lib3ds_lin3_track_free_keys(Lib3dsLin3Track *track);
+extern LIB3DSAPI void lib3ds_lin3_key_setup(Lib3dsLin3Key *p, Lib3dsLin3Key *cp, Lib3dsLin3Key *c,
+ Lib3dsLin3Key *cn, Lib3dsLin3Key *n);
+extern LIB3DSAPI void lib3ds_lin3_track_setup(Lib3dsLin3Track *track);
+extern LIB3DSAPI void lib3ds_lin3_track_insert(Lib3dsLin3Track *track, Lib3dsLin3Key *key);
+extern LIB3DSAPI void lib3ds_lin3_track_remove(Lib3dsLin3Track *track, Lib3dsIntd frame);
+extern LIB3DSAPI void lib3ds_lin3_track_eval(Lib3dsLin3Track *track, Lib3dsVector p, Lib3dsFloat t);
+extern LIB3DSAPI Lib3dsBool lib3ds_lin3_track_read(Lib3dsLin3Track *track, Lib3dsIo *io);
+extern LIB3DSAPI Lib3dsBool lib3ds_lin3_track_write(Lib3dsLin3Track *track, Lib3dsIo *io);
+
+extern LIB3DSAPI Lib3dsQuatKey* lib3ds_quat_key_new();
+extern LIB3DSAPI void lib3ds_quat_key_free(Lib3dsQuatKey* key);
+extern LIB3DSAPI void lib3ds_quat_track_free_keys(Lib3dsQuatTrack *track);
+extern LIB3DSAPI void lib3ds_quat_key_setup(Lib3dsQuatKey *p, Lib3dsQuatKey *cp, Lib3dsQuatKey *c,
+ Lib3dsQuatKey *cn, Lib3dsQuatKey *n);
+extern LIB3DSAPI void lib3ds_quat_track_setup(Lib3dsQuatTrack *track);
+extern LIB3DSAPI void lib3ds_quat_track_insert(Lib3dsQuatTrack *track, Lib3dsQuatKey *key);
+extern LIB3DSAPI void lib3ds_quat_track_remove(Lib3dsQuatTrack *track, Lib3dsIntd frame);
+extern LIB3DSAPI void lib3ds_quat_track_eval(Lib3dsQuatTrack *track, Lib3dsQuat p, Lib3dsFloat t);
+extern LIB3DSAPI Lib3dsBool lib3ds_quat_track_read(Lib3dsQuatTrack *track, Lib3dsIo *io);
+extern LIB3DSAPI Lib3dsBool lib3ds_quat_track_write(Lib3dsQuatTrack *track, Lib3dsIo *io);
+
+extern LIB3DSAPI Lib3dsMorphKey* lib3ds_morph_key_new();
+extern LIB3DSAPI void lib3ds_morph_key_free(Lib3dsMorphKey* key);
+extern LIB3DSAPI void lib3ds_morph_track_free_keys(Lib3dsMorphTrack *track);
+extern LIB3DSAPI void lib3ds_morph_track_insert(Lib3dsMorphTrack *track, Lib3dsMorphKey *key);
+extern LIB3DSAPI void lib3ds_morph_track_remove(Lib3dsMorphTrack *track, Lib3dsIntd frame);
+extern LIB3DSAPI void lib3ds_morph_track_eval(Lib3dsMorphTrack *track, char *p, Lib3dsFloat t);
+extern LIB3DSAPI Lib3dsBool lib3ds_morph_track_read(Lib3dsMorphTrack *track, Lib3dsIo *io);
+extern LIB3DSAPI Lib3dsBool lib3ds_morph_track_write(Lib3dsMorphTrack *track, Lib3dsIo *io);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+
--- /dev/null
+/* -*- c -*- */
+#ifndef INCLUDED_LIB3DS_TYPES_H
+#define INCLUDED_LIB3DS_TYPES_H
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: types.h,v 1.18 2005/01/11 16:12:52 madmac Exp $
+ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined (UBUILD_SHARED) && defined(_WIN32) && (!defined(__GNUC__))
+#ifdef LIB3DS_EXPORT
+#define LIB3DSAPI __declspec(dllexport)
+#else
+#define LIB3DSAPI __declspec(dllimport)
+#endif
+#else
+#define LIB3DSAPI
+#endif
+
+#define LIB3DS_TRUE 1
+#define LIB3DS_FALSE 0
+
+typedef int Lib3dsBool;
+typedef unsigned char Lib3dsByte;
+typedef unsigned short int Lib3dsWord;
+typedef unsigned long Lib3dsDword;
+typedef signed char Lib3dsIntb;
+typedef signed short int Lib3dsIntw;
+typedef signed long Lib3dsIntd;
+typedef float Lib3dsFloat;
+typedef double Lib3dsDouble;
+
+typedef float Lib3dsVector[3];
+typedef float Lib3dsTexel[2];
+typedef float Lib3dsQuat[4];
+typedef float Lib3dsMatrix[4][4];
+typedef float Lib3dsRgb[3];
+typedef float Lib3dsRgba[4];
+
+#define LIB3DS_EPSILON (1e-8)
+#define LIB3DS_PI 3.14159265358979323846
+#define LIB3DS_TWOPI (2.0*LIB3DS_PI)
+#define LIB3DS_HALFPI (LIB3DS_PI/2.0)
+#define LIB3DS_RAD_TO_DEG(x) ((180.0/LIB3DS_PI)*(x))
+#define LIB3DS_DEG_TO_RAD(x) ((LIB3DS_PI/180.0)*(x))
+
+#ifndef INCLUDED_STDIO_H
+#define INCLUDED_STDIO_H
+#include <stdio.h>
+#endif
+
+#ifdef _DEBUG
+ #ifndef ASSERT
+ #include <assert.h>
+ #define ASSERT(__expr) assert(__expr)
+ #endif
+ #define LIB3DS_ERROR_LOG \
+ {printf("\t***LIB3DS_ERROR_LOG*** %s : %d\n", __FILE__, __LINE__);}
+#else
+ #ifndef ASSERT
+ #define ASSERT(__expr)
+ #endif
+ #define LIB3DS_ERROR_LOG
+#endif
+
+typedef struct _Lib3dsIo Lib3dsIo;
+typedef struct _Lib3dsFile Lib3dsFile;
+typedef struct _Lib3dsBackground Lib3dsBackground;
+typedef struct _Lib3dsAtmosphere Lib3dsAtmosphere;
+typedef struct _Lib3dsShadow Lib3dsShadow;
+typedef struct _Lib3dsViewport Lib3dsViewport;
+typedef struct _Lib3dsMaterial Lib3dsMaterial;
+typedef struct _Lib3dsFace Lib3dsFace;
+typedef struct _Lib3dsBoxMap Lib3dsBoxMap;
+typedef struct _Lib3dsMapData Lib3dsMapData;
+typedef struct _Lib3dsMesh Lib3dsMesh;
+typedef struct _Lib3dsCamera Lib3dsCamera;
+typedef struct _Lib3dsLight Lib3dsLight;
+typedef struct _Lib3dsBoolKey Lib3dsBoolKey;
+typedef struct _Lib3dsBoolTrack Lib3dsBoolTrack;
+typedef struct _Lib3dsLin1Key Lib3dsLin1Key;
+typedef struct _Lib3dsLin1Track Lib3dsLin1Track;
+typedef struct _Lib3dsLin3Key Lib3dsLin3Key;
+typedef struct _Lib3dsLin3Track Lib3dsLin3Track;
+typedef struct _Lib3dsQuatKey Lib3dsQuatKey;
+typedef struct _Lib3dsQuatTrack Lib3dsQuatTrack;
+typedef struct _Lib3dsMorphKey Lib3dsMorphKey;
+typedef struct _Lib3dsMorphTrack Lib3dsMorphTrack;
+
+typedef enum _Lib3dsNodeTypes {
+ LIB3DS_UNKNOWN_NODE =0,
+ LIB3DS_AMBIENT_NODE =1,
+ LIB3DS_OBJECT_NODE =2,
+ LIB3DS_CAMERA_NODE =3,
+ LIB3DS_TARGET_NODE =4,
+ LIB3DS_LIGHT_NODE =5,
+ LIB3DS_SPOT_NODE =6
+} Lib3dsNodeTypes;
+
+typedef struct _Lib3dsNode Lib3dsNode;
+
+typedef union _Lib3dsUserData {
+ void *p;
+ Lib3dsIntd i;
+ Lib3dsDword d;
+ Lib3dsFloat f;
+ Lib3dsMaterial *material;
+ Lib3dsMesh *mesh;
+ Lib3dsCamera *camera;
+ Lib3dsLight *light;
+ Lib3dsNode *node;
+} Lib3dsUserData;
+
+#ifndef LIB3DS_EXPORT
+ /* The purpose of this variable is to force a recompile of any code
+ * that links to the lib3ds library whenever there is an incompatible
+ * change in the header files. It should be sufficient to include
+ * any lib3ds header file in any source file to satisfy this dependency.
+ *
+ * This variable will be updated any time there is an incompatible change
+ * in the lib3ds data structures.
+ */
+// int lib3ds_version1_3;
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif
--- /dev/null
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: vector.c,v 1.9 2004/11/16 07:41:44 efalk Exp $
+ */
+#define LIB3DS_EXPORT
+#include <lib3ds/vector.h>
+#include <math.h>
+
+
+/*!
+ * \defgroup vector Vector Mathematics
+ *
+ * \author J.E. Hoffmann <je-h@gmx.net>
+ */
+/*!
+ * \typedef Lib3dsVector
+ * \ingroup vector
+ */
+
+
+/*!
+ * Clear a vector to zero.
+ *
+ * \param c Vector to clear.
+ *
+ * \ingroup vector
+ */
+void
+lib3ds_vector_zero(Lib3dsVector c)
+{
+ int i;
+ for (i=0; i<3; ++i) {
+ c[i]=0.0f;
+ }
+}
+
+
+/*!
+ * Copy a vector.
+ *
+ * \param dest Destination vector.
+ * \param src Source vector.
+ *
+ * \ingroup vector
+ */
+void
+lib3ds_vector_copy(Lib3dsVector dest, Lib3dsVector src)
+{
+ int i;
+ for (i=0; i<3; ++i) {
+ dest[i]=src[i];
+ }
+}
+
+
+/*!
+ * Negate a vector.
+ *
+ * \param c Vector to negate.
+ *
+ * \ingroup vector
+ */
+void
+lib3ds_vector_neg(Lib3dsVector c)
+{
+ int i;
+ for (i=0; i<3; ++i) {
+ c[i]=-c[i];
+ }
+}
+
+
+/*!
+ * Add two vectors.
+ *
+ * \param c Result.
+ * \param a First addend.
+ * \param b Second addend.
+ *
+ * \ingroup vector
+ */
+void
+lib3ds_vector_add(Lib3dsVector c, Lib3dsVector a, Lib3dsVector b)
+{
+ int i;
+ for (i=0; i<3; ++i) {
+ c[i]=a[i]+b[i];
+ }
+}
+
+
+/*!
+ * Subtract two vectors.
+ *
+ * \param c Result.
+ * \param a Addend.
+ * \param b Minuend.
+ *
+ * \ingroup vector
+ */
+void
+lib3ds_vector_sub(Lib3dsVector c, Lib3dsVector a, Lib3dsVector b)
+{
+ int i;
+ for (i=0; i<3; ++i) {
+ c[i]=a[i]-b[i];
+ }
+}
+
+
+/*!
+ * Multiply a vector by a scalar.
+ *
+ * \param c Vector to be multiplied.
+ * \param k Scalar.
+ *
+ * \ingroup vector
+ */
+void
+lib3ds_vector_scalar(Lib3dsVector c, Lib3dsFloat k)
+{
+ int i;
+ for (i=0; i<3; ++i) {
+ c[i]*=k;
+ }
+}
+
+
+/*!
+ * Compute cross product.
+ *
+ * \param c Result.
+ * \param a First vector.
+ * \param b Second vector.
+ *
+ * \ingroup vector
+ */
+void
+lib3ds_vector_cross(Lib3dsVector c, Lib3dsVector a, Lib3dsVector b)
+{
+ c[0]=a[1]*b[2] - a[2]*b[1];
+ c[1]=a[2]*b[0] - a[0]*b[2];
+ c[2]=a[0]*b[1] - a[1]*b[0];
+}
+
+
+/*!
+ * Compute dot product.
+ *
+ * \param a First vector.
+ * \param b Second vector.
+ *
+ * \return Dot product.
+ *
+ * \ingroup vector
+ */
+Lib3dsFloat
+lib3ds_vector_dot(Lib3dsVector a, Lib3dsVector b)
+{
+ return(a[0]*b[0] + a[1]*b[1] + a[2]*b[2]);
+}
+
+
+/*!
+ * Compute square of vector.
+ *
+ * Computes x*x + y*y + z*z.
+ *
+ * \param c Vector to square.
+ *
+ * \return Square of vector.
+ *
+ * \ingroup vector
+ */
+Lib3dsFloat
+lib3ds_vector_squared(Lib3dsVector c)
+{
+ return(c[0]*c[0] + c[1]*c[1] + c[2]*c[2]);
+}
+
+
+/*!
+ * Compute length of vector.
+ *
+ * Computes |c| = sqrt(x*x + y*y + z*z)
+ *
+ * \param c Vector to compute.
+ *
+ * \return Length of vector.
+ *
+ * \ingroup vector
+ */
+Lib3dsFloat
+lib3ds_vector_length(Lib3dsVector c)
+{
+ return((Lib3dsFloat)sqrt(c[0]*c[0] + c[1]*c[1] + c[2]*c[2]));
+}
+
+
+/*!
+ * Normalize a vector.
+ *
+ * Scales a vector so that its length is 1.0.
+ *
+ * \param c Vector to normalize.
+ *
+ * \ingroup vector
+ */
+void
+lib3ds_vector_normalize(Lib3dsVector c)
+{
+ Lib3dsFloat l,m;
+
+ l=(Lib3dsFloat)sqrt(c[0]*c[0] + c[1]*c[1] + c[2]*c[2]);
+ if (fabs(l)<LIB3DS_EPSILON) {
+ if ((c[0]>=c[1]) && (c[0]>=c[2])) {
+ c[0]=1.0f;
+ c[1]=c[2]=0.0f;
+ }
+ else
+ if (c[1]>=c[2]) {
+ c[1]=1.0f;
+ c[0]=c[2]=0.0f;
+ }
+ else {
+ c[2]=1.0f;
+ c[0]=c[1]=0.0f;
+ }
+ }
+ else {
+ m=1.0f/l;
+ c[0]*=m;
+ c[1]*=m;
+ c[2]*=m;
+ }
+}
+
+
+/*!
+ * Compute a vector normal to two line segments.
+ *
+ * Computes the normal vector to the lines b-a and b-c.
+ *
+ * \param n Returned normal vector.
+ * \param a Endpoint of first line.
+ * \param b Base point of both lines.
+ * \param c Endpoint of second line.
+ *
+ * \ingroup vector
+ */
+void
+lib3ds_vector_normal(Lib3dsVector n, Lib3dsVector a, Lib3dsVector b, Lib3dsVector c)
+{
+ Lib3dsVector p,q;
+
+ lib3ds_vector_sub(p,c,b);
+ lib3ds_vector_sub(q,a,b);
+ lib3ds_vector_cross(n,p,q);
+ lib3ds_vector_normalize(n);
+}
+
+
+/*!
+ * Multiply a point by a transformation matrix.
+ *
+ * Applies the given transformation matrix to the given point. With some
+ * transformation matrices, a vector may also be transformed.
+ *
+ * \param c Result.
+ * \param m Transformation matrix.
+ * \param a Input point.
+ *
+ * \ingroup vector
+ */
+void
+lib3ds_vector_transform(Lib3dsVector c, Lib3dsMatrix m, Lib3dsVector a)
+{
+ c[0]= m[0][0]*a[0] + m[1][0]*a[1] + m[2][0]*a[2] + m[3][0];
+ c[1]= m[0][1]*a[0] + m[1][1]*a[1] + m[2][1]*a[2] + m[3][1];
+ c[2]= m[0][2]*a[0] + m[1][2]*a[1] + m[2][2]*a[2] + m[3][2];
+}
+
+
+/*!
+ * Compute a point on a cubic spline.
+ *
+ * Computes a point on a parametric Bezier spline.
+ *
+ * \param c Result.
+ * \param a First endpoint of the spline.
+ * \param p First tangent vector of the spline.
+ * \param q Second tangent vector of the spline.
+ * \param b Second endpoint of the spline.
+ * \param t Spline parameter [0. 1.]
+ *
+ * \ingroup vector
+ */
+void
+lib3ds_vector_cubic(Lib3dsVector c, Lib3dsVector a, Lib3dsVector p, Lib3dsVector q,
+ Lib3dsVector b, Lib3dsFloat t)
+{
+ Lib3dsDouble x,y,z,w;
+
+ x=2*t*t*t - 3*t*t + 1;
+ y=-2*t*t*t + 3*t*t;
+ z=t*t*t - 2*t*t + t;
+ w=t*t*t - t*t;
+ c[0]=(Lib3dsFloat)(x*a[0] + y*b[0] + z*p[0] + w*q[0]);
+ c[1]=(Lib3dsFloat)(x*a[1] + y*b[1] + z*p[1] + w*q[1]);
+ c[2]=(Lib3dsFloat)(x*a[2] + y*b[2] + z*p[2] + w*q[2]);
+}
+
+
+/*!
+ * c[i] = min(c[i], a[i]);
+ *
+ * Computes minimum values of x,y,z independently.
+ *
+ * \ingroup vector
+ */
+void
+lib3ds_vector_min(Lib3dsVector c, Lib3dsVector a)
+{
+ int i;
+ for (i=0; i<3; ++i) {
+ if (a[i]<c[i]) {
+ c[i] = a[i];
+ }
+ }
+}
+
+
+/*!
+ * c[i] = max(c[i], a[i]);
+ *
+ * Computes maximum values of x,y,z independently.
+ *
+ * \ingroup vector
+ */
+void
+lib3ds_vector_max(Lib3dsVector c, Lib3dsVector a)
+{
+ int i;
+ for (i=0; i<3; ++i) {
+ if (a[i]>c[i]) {
+ c[i] = a[i];
+ }
+ }
+}
+
+
+/*!
+ * \ingroup vector
+ */
+void
+lib3ds_vector_dump(Lib3dsVector c)
+{
+ fprintf(stderr, "%f %f %f\n", c[0], c[1], c[2]);
+}
+
--- /dev/null
+/* -*- c -*- */
+#ifndef INCLUDED_LIB3DS_VECTOR_H
+#define INCLUDED_LIB3DS_VECTOR_H
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: vector.h,v 1.6 2004/12/31 16:17:15 reed Exp $
+ */
+
+#ifndef INCLUDED_LIB3DS_TYPES_H
+#include <lib3ds/types.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern LIB3DSAPI void lib3ds_vector_zero(Lib3dsVector c);
+extern LIB3DSAPI void lib3ds_vector_copy(Lib3dsVector dest, Lib3dsVector src);
+extern LIB3DSAPI void lib3ds_vector_neg(Lib3dsVector c);
+extern LIB3DSAPI void lib3ds_vector_add(Lib3dsVector c, Lib3dsVector a, Lib3dsVector b);
+extern LIB3DSAPI void lib3ds_vector_sub(Lib3dsVector c, Lib3dsVector a, Lib3dsVector b);
+extern LIB3DSAPI void lib3ds_vector_scalar(Lib3dsVector c, Lib3dsFloat k);
+extern LIB3DSAPI void lib3ds_vector_cross(Lib3dsVector c, Lib3dsVector a, Lib3dsVector b);
+extern LIB3DSAPI Lib3dsFloat lib3ds_vector_dot(Lib3dsVector a, Lib3dsVector b);
+extern LIB3DSAPI Lib3dsFloat lib3ds_vector_squared(Lib3dsVector c);
+extern LIB3DSAPI Lib3dsFloat lib3ds_vector_length(Lib3dsVector c);
+extern LIB3DSAPI void lib3ds_vector_normalize(Lib3dsVector c);
+extern LIB3DSAPI void lib3ds_vector_normal(Lib3dsVector n, Lib3dsVector a,
+ Lib3dsVector b, Lib3dsVector c);
+extern LIB3DSAPI void lib3ds_vector_transform(Lib3dsVector c, Lib3dsMatrix m, Lib3dsVector a);
+extern LIB3DSAPI void lib3ds_vector_cubic(Lib3dsVector c, Lib3dsVector a, Lib3dsVector p,
+ Lib3dsVector q, Lib3dsVector b, Lib3dsFloat t);
+extern LIB3DSAPI void lib3ds_vector_min(Lib3dsVector c, Lib3dsVector a);
+extern LIB3DSAPI void lib3ds_vector_max(Lib3dsVector c, Lib3dsVector a);
+extern LIB3DSAPI void lib3ds_vector_dump(Lib3dsVector c);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+
--- /dev/null
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: viewport.c,v 1.7 2004/11/16 07:40:56 efalk Exp $
+ */
+#define LIB3DS_EXPORT
+#include <lib3ds/viewport.h>
+#include <lib3ds/chunk.h>
+#include <lib3ds/io.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+/*!
+ * \defgroup viewport Viewport and default view settings
+ *
+ * \author J.E. Hoffmann <je-h@gmx.net>
+ */
+
+
+/*!
+ * \ingroup viewport
+ */
+Lib3dsBool
+lib3ds_viewport_read(Lib3dsViewport *viewport, Lib3dsIo *io)
+{
+ Lib3dsChunk c;
+ Lib3dsWord chunk;
+
+ if (!lib3ds_chunk_read_start(&c, 0, io)) {
+ return(LIB3DS_FALSE);
+ }
+
+ switch (c.chunk) {
+ case LIB3DS_VIEWPORT_LAYOUT:
+ {
+ int cur=0;
+ viewport->layout.style=lib3ds_io_read_word(io);
+ viewport->layout.active=lib3ds_io_read_intw(io);
+ lib3ds_io_read_intw(io);
+ viewport->layout.swap=lib3ds_io_read_intw(io);
+ lib3ds_io_read_intw(io);
+ viewport->layout.swap_prior=lib3ds_io_read_intw(io);
+ viewport->layout.swap_view=lib3ds_io_read_intw(io);
+ lib3ds_chunk_read_tell(&c, io);
+ while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
+ switch (chunk) {
+ case LIB3DS_VIEWPORT_SIZE:
+ {
+ viewport->layout.position[0]=lib3ds_io_read_word(io);
+ viewport->layout.position[1]=lib3ds_io_read_word(io);
+ viewport->layout.size[0]=lib3ds_io_read_word(io);
+ viewport->layout.size[1]=lib3ds_io_read_word(io);
+ }
+ break;
+ case LIB3DS_VIEWPORT_DATA_3:
+ {
+ lib3ds_viewport_set_views(viewport,cur+1);
+ lib3ds_io_read_intw(io);
+ viewport->layout.viewL[cur].axis_lock=lib3ds_io_read_word(io);
+ viewport->layout.viewL[cur].position[0]=lib3ds_io_read_intw(io);
+ viewport->layout.viewL[cur].position[1]=lib3ds_io_read_intw(io);
+ viewport->layout.viewL[cur].size[0]=lib3ds_io_read_intw(io);
+ viewport->layout.viewL[cur].size[1]=lib3ds_io_read_intw(io);
+ viewport->layout.viewL[cur].type=lib3ds_io_read_word(io);
+ viewport->layout.viewL[cur].zoom=lib3ds_io_read_float(io);
+ lib3ds_io_read_vector(io, viewport->layout.viewL[cur].center);
+ viewport->layout.viewL[cur].horiz_angle=lib3ds_io_read_float(io);
+ viewport->layout.viewL[cur].vert_angle=lib3ds_io_read_float(io);
+ lib3ds_io_read(io, (unsigned char*)viewport->layout.viewL[cur].camera, 11);
+ ++cur;
+ }
+ break;
+ case LIB3DS_VIEWPORT_DATA:
+ /* 3DS R2 & R3 chunk
+ unsupported */
+ break;
+ default:
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+ }
+ break;
+ case LIB3DS_DEFAULT_VIEW:
+ {
+ memset(&viewport->default_view,0,sizeof(Lib3dsDefaultView));
+ while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
+ switch (chunk) {
+ case LIB3DS_VIEW_TOP:
+ {
+ viewport->default_view.type=LIB3DS_VIEW_TYPE_TOP;
+ lib3ds_io_read_vector(io, viewport->default_view.position);
+ viewport->default_view.width=lib3ds_io_read_float(io);
+ }
+ break;
+ case LIB3DS_VIEW_BOTTOM:
+ {
+ viewport->default_view.type=LIB3DS_VIEW_TYPE_BOTTOM;
+ lib3ds_io_read_vector(io, viewport->default_view.position);
+ viewport->default_view.width=lib3ds_io_read_float(io);
+ }
+ break;
+ case LIB3DS_VIEW_LEFT:
+ {
+ viewport->default_view.type=LIB3DS_VIEW_TYPE_LEFT;
+ lib3ds_io_read_vector(io, viewport->default_view.position);
+ viewport->default_view.width=lib3ds_io_read_float(io);
+ }
+ break;
+ case LIB3DS_VIEW_RIGHT:
+ {
+ viewport->default_view.type=LIB3DS_VIEW_TYPE_RIGHT;
+ lib3ds_io_read_vector(io, viewport->default_view.position);
+ viewport->default_view.width=lib3ds_io_read_float(io);
+ }
+ break;
+ case LIB3DS_VIEW_FRONT:
+ {
+ viewport->default_view.type=LIB3DS_VIEW_TYPE_FRONT;
+ lib3ds_io_read_vector(io, viewport->default_view.position);
+ viewport->default_view.width=lib3ds_io_read_float(io);
+ }
+ break;
+ case LIB3DS_VIEW_BACK:
+ {
+ viewport->default_view.type=LIB3DS_VIEW_TYPE_BACK;
+ lib3ds_io_read_vector(io, viewport->default_view.position);
+ viewport->default_view.width=lib3ds_io_read_float(io);
+ }
+ break;
+ case LIB3DS_VIEW_USER:
+ {
+ viewport->default_view.type=LIB3DS_VIEW_TYPE_USER;
+ lib3ds_io_read_vector(io, viewport->default_view.position);
+ viewport->default_view.width=lib3ds_io_read_float(io);
+ viewport->default_view.horiz_angle=lib3ds_io_read_float(io);
+ viewport->default_view.vert_angle=lib3ds_io_read_float(io);
+ viewport->default_view.roll_angle=lib3ds_io_read_float(io);
+ }
+ break;
+ case LIB3DS_VIEW_CAMERA:
+ {
+ viewport->default_view.type=LIB3DS_VIEW_TYPE_CAMERA;
+ lib3ds_io_read(io, (unsigned char*)viewport->default_view.camera, 11);
+ }
+ break;
+ default:
+ lib3ds_chunk_unknown(chunk);
+ }
+ }
+ }
+ break;
+ }
+
+ lib3ds_chunk_read_end(&c, io);
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * \ingroup viewport
+ */
+void
+lib3ds_viewport_set_views(Lib3dsViewport *viewport, Lib3dsDword views)
+{
+ ASSERT(viewport);
+ if (viewport->layout.views) {
+ if (views) {
+ viewport->layout.views=views;
+ viewport->layout.viewL=(Lib3dsView*)realloc(viewport->layout.viewL, sizeof(Lib3dsView)*views);
+ }
+ else {
+ free(viewport->layout.viewL);
+ viewport->layout.views=0;
+ viewport->layout.viewL=0;
+ }
+ }
+ else {
+ if (views) {
+ viewport->layout.views=views;
+ viewport->layout.viewL=(Lib3dsView*)calloc(sizeof(Lib3dsView),views);
+ }
+ }
+}
+
+
+/*!
+ * \ingroup viewport
+ */
+Lib3dsBool
+lib3ds_viewport_write(Lib3dsViewport *viewport, Lib3dsIo *io)
+{
+ if (viewport->layout.views) {
+ Lib3dsChunk c;
+ unsigned i;
+
+ c.chunk=LIB3DS_VIEWPORT_LAYOUT;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+
+ lib3ds_io_write_word(io, viewport->layout.style);
+ lib3ds_io_write_intw(io, viewport->layout.active);
+ lib3ds_io_write_intw(io, 0);
+ lib3ds_io_write_intw(io, viewport->layout.swap);
+ lib3ds_io_write_intw(io, 0);
+ lib3ds_io_write_intw(io, viewport->layout.swap_prior);
+ lib3ds_io_write_intw(io, viewport->layout.swap_view);
+
+ {
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_VIEWPORT_SIZE;
+ c.size=14;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_intw(io, viewport->layout.position[0]);
+ lib3ds_io_write_intw(io, viewport->layout.position[1]);
+ lib3ds_io_write_intw(io, viewport->layout.size[0]);
+ lib3ds_io_write_intw(io, viewport->layout.size[1]);
+ }
+
+ for (i=0; i<viewport->layout.views; ++i) {
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_VIEWPORT_DATA_3;
+ c.size=55;
+ lib3ds_chunk_write(&c,io);
+
+ lib3ds_io_write_intw(io, 0);
+ lib3ds_io_write_word(io, viewport->layout.viewL[i].axis_lock);
+ lib3ds_io_write_intw(io, viewport->layout.viewL[i].position[0]);
+ lib3ds_io_write_intw(io, viewport->layout.viewL[i].position[1]);
+ lib3ds_io_write_intw(io, viewport->layout.viewL[i].size[0]);
+ lib3ds_io_write_intw(io, viewport->layout.viewL[i].size[1]);
+ lib3ds_io_write_word(io, viewport->layout.viewL[i].type);
+ lib3ds_io_write_float(io, viewport->layout.viewL[i].zoom);
+ lib3ds_io_write_vector(io, viewport->layout.viewL[i].center);
+ lib3ds_io_write_float(io, viewport->layout.viewL[i].horiz_angle);
+ lib3ds_io_write_float(io, viewport->layout.viewL[i].vert_angle);
+ lib3ds_io_write(io, (unsigned char*)viewport->layout.viewL[i].camera,11);
+ }
+
+ if (!lib3ds_chunk_write_end(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+
+ if (viewport->default_view.type) {
+ Lib3dsChunk c;
+
+ c.chunk=LIB3DS_DEFAULT_VIEW;
+ if (!lib3ds_chunk_write_start(&c,io)) {
+ return(LIB3DS_FALSE);
+ }
+
+ switch (viewport->default_view.type) {
+ case LIB3DS_VIEW_TYPE_TOP:
+ {
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_VIEW_TOP;
+ c.size=22;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_vector(io, viewport->default_view.position);
+ lib3ds_io_write_float(io, viewport->default_view.width);
+ }
+ break;
+ case LIB3DS_VIEW_TYPE_BOTTOM:
+ {
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_VIEW_BOTTOM;
+ c.size=22;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_vector(io, viewport->default_view.position);
+ lib3ds_io_write_float(io, viewport->default_view.width);
+ }
+ break;
+ case LIB3DS_VIEW_TYPE_LEFT:
+ {
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_VIEW_LEFT;
+ c.size=22;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_vector(io, viewport->default_view.position);
+ lib3ds_io_write_float(io, viewport->default_view.width);
+ }
+ break;
+ case LIB3DS_VIEW_TYPE_RIGHT:
+ {
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_VIEW_RIGHT;
+ c.size=22;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_vector(io, viewport->default_view.position);
+ lib3ds_io_write_float(io, viewport->default_view.width);
+ }
+ break;
+ case LIB3DS_VIEW_TYPE_FRONT:
+ {
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_VIEW_FRONT;
+ c.size=22;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_vector(io, viewport->default_view.position);
+ lib3ds_io_write_float(io, viewport->default_view.width);
+ }
+ break;
+ case LIB3DS_VIEW_TYPE_BACK:
+ {
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_VIEW_BACK;
+ c.size=22;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_vector(io, viewport->default_view.position);
+ lib3ds_io_write_float(io, viewport->default_view.width);
+ }
+ break;
+ case LIB3DS_VIEW_TYPE_USER:
+ {
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_VIEW_USER;
+ c.size=34;
+ lib3ds_chunk_write(&c,io);
+ lib3ds_io_write_vector(io, viewport->default_view.position);
+ lib3ds_io_write_float(io, viewport->default_view.width);
+ lib3ds_io_write_float(io, viewport->default_view.horiz_angle);
+ lib3ds_io_write_float(io, viewport->default_view.vert_angle);
+ lib3ds_io_write_float(io, viewport->default_view.roll_angle);
+ }
+ break;
+ case LIB3DS_VIEW_TYPE_CAMERA:
+ {
+ Lib3dsChunk c;
+ c.chunk=LIB3DS_VIEW_CAMERA;
+ c.size=17;
+ lib3ds_chunk_write(&c, io);
+ lib3ds_io_write(io, (unsigned char*)viewport->default_view.camera, 11);
+ }
+ break;
+ }
+
+ if (!lib3ds_chunk_write_end(&c, io)) {
+ return(LIB3DS_FALSE);
+ }
+ }
+ return(LIB3DS_TRUE);
+}
+
+
+/*!
+ * Dump viewport.
+ *
+ * \param viewport The viewport to be dumped.
+ *
+ * \ingroup node
+ */
+void
+lib3ds_viewport_dump(Lib3dsViewport *vp)
+{
+ Lib3dsView *view;
+ int i;
+ ASSERT(vp);
+
+ printf(" viewport:\n");
+ printf(" layout:\n");
+ printf(" style: %d\n", vp->layout.style);
+ printf(" active: %d\n", vp->layout.active);
+ printf(" swap: %d\n", vp->layout.swap);
+ printf(" swap_prior: %d\n", vp->layout.swap_prior);
+ printf(" position: %d,%d\n",
+ vp->layout.position[0], vp->layout.position[1]);
+ printf(" size: %d,%d\n", vp->layout.size[0], vp->layout.size[1]);
+ printf(" views: %ld\n", vp->layout.views);
+ if (vp->layout.views > 0 && vp->layout.viewL != NULL) {
+ for(i=0, view=vp->layout.viewL; i < vp->layout.views; ++i, ++view) {
+ printf(" view %d:\n", i);
+ printf(" type: %d\n", view->type);
+ printf(" axis_lock: %d\n", view->axis_lock);
+ printf(" position: (%d,%d)\n",
+ view->position[0], view->position[1]);
+ printf(" size: (%d,%d)\n", view->size[0], view->size[1]);
+ printf(" zoom: %g\n", view->zoom);
+ printf(" center: (%g,%g,%g)\n",
+ view->center[0], view->center[1], view->center[2]);
+ printf(" horiz_angle: %g\n", view->horiz_angle);
+ printf(" vert_angle: %g\n", view->vert_angle);
+ printf(" camera: %s\n", view->camera);
+ }
+ }
+
+ printf(" default_view:\n");
+ printf(" type: %d\n", vp->default_view.type);
+ printf(" position: (%g,%g,%g)\n",
+ vp->default_view.position[0],
+ vp->default_view.position[1],
+ vp->default_view.position[2]);
+ printf(" width: %g\n", vp->default_view.width);
+ printf(" horiz_angle: %g\n", vp->default_view.horiz_angle);
+ printf(" vert_angle: %g\n", vp->default_view.vert_angle);
+ printf(" roll_angle: %g\n", vp->default_view.roll_angle);
+ printf(" camera: %s\n", vp->default_view.camera);
+}
+
+
+/*!
+
+\typedef Lib3dsViewport
+ \ingroup viewport
+ \sa _Lib3dsViewport
+
+*/
--- /dev/null
+/* -*- c -*- */
+#ifndef INCLUDED_LIB3DS_VIEWPORT_H
+#define INCLUDED_LIB3DS_VIEWPORT_H
+/*
+ * The 3D Studio File Format Library
+ * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: viewport.h,v 1.6 2004/12/31 16:17:15 reed Exp $
+ */
+
+#ifndef INCLUDED_LIB3DS_TYPES_H
+#include <lib3ds/types.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*!
+ * Layout view types
+ * \ingroup viewport
+ */
+typedef enum _Lib3dsViewType {
+ LIB3DS_VIEW_TYPE_NOT_USED =0,
+ LIB3DS_VIEW_TYPE_TOP =1,
+ LIB3DS_VIEW_TYPE_BOTTOM =2,
+ LIB3DS_VIEW_TYPE_LEFT =3,
+ LIB3DS_VIEW_TYPE_RIGHT =4,
+ LIB3DS_VIEW_TYPE_FRONT =5,
+ LIB3DS_VIEW_TYPE_BACK =6,
+ LIB3DS_VIEW_TYPE_USER =7,
+ LIB3DS_VIEW_TYPE_SPOTLIGHT =18,
+ LIB3DS_VIEW_TYPE_CAMERA =65535
+} Lib3dsViewType;
+
+/*!
+ * Layout view settings
+ * \ingroup viewport
+ */
+typedef struct _Lib3dsView {
+ Lib3dsWord type;
+ Lib3dsWord axis_lock;
+ Lib3dsIntw position[2];
+ Lib3dsIntw size[2];
+ Lib3dsFloat zoom;
+ Lib3dsVector center;
+ Lib3dsFloat horiz_angle;
+ Lib3dsFloat vert_angle;
+ char camera[11];
+} Lib3dsView;
+
+/*!
+ * Layout styles
+ * \ingroup viewport
+ */
+typedef enum _Lib3dsLayoutStyle {
+ LIB3DS_LAYOUT_SINGLE =0,
+ LIB3DS_LAYOUT_TWO_PANE_VERT_SPLIT =1,
+ LIB3DS_LAYOUT_TWO_PANE_HORIZ_SPLIT =2,
+ LIB3DS_LAYOUT_FOUR_PANE =3,
+ LIB3DS_LAYOUT_THREE_PANE_LEFT_SPLIT =4,
+ LIB3DS_LAYOUT_THREE_PANE_BOTTOM_SPLIT =5,
+ LIB3DS_LAYOUT_THREE_PANE_RIGHT_SPLIT =6,
+ LIB3DS_LAYOUT_THREE_PANE_TOP_SPLIT =7,
+ LIB3DS_LAYOUT_THREE_PANE_VERT_SPLIT =8,
+ LIB3DS_LAYOUT_THREE_PANE_HORIZ_SPLIT =9,
+ LIB3DS_LAYOUT_FOUR_PANE_LEFT_SPLIT =10,
+ LIB3DS_LAYOUT_FOUR_PANE_RIGHT_SPLIT =11
+} Lib3dsLayoutStyle;
+
+/*!
+ * Viewport layout settings
+ * \ingroup viewport
+ */
+typedef struct _Lib3dsLayout {
+ Lib3dsWord style;
+ Lib3dsIntw active;
+ Lib3dsIntw swap;
+ Lib3dsIntw swap_prior;
+ Lib3dsIntw swap_view;
+ Lib3dsWord position[2];
+ Lib3dsWord size[2];
+ Lib3dsDword views;
+ Lib3dsView *viewL;
+} Lib3dsLayout;
+
+/*!
+ * Default view settings
+ * \ingroup viewport
+ */
+typedef struct _Lib3dsDefaultView {
+ Lib3dsWord type;
+ Lib3dsVector position;
+ Lib3dsFloat width;
+ Lib3dsFloat horiz_angle;
+ Lib3dsFloat vert_angle;
+ Lib3dsFloat roll_angle;
+ char camera[64];
+} Lib3dsDefaultView;
+
+/*!
+ * Viewport and default view settings
+ * \ingroup viewport
+ */
+struct _Lib3dsViewport {
+ Lib3dsLayout layout;
+ Lib3dsDefaultView default_view;
+};
+
+extern LIB3DSAPI Lib3dsBool lib3ds_viewport_read(Lib3dsViewport *viewport, Lib3dsIo *io);
+extern LIB3DSAPI void lib3ds_viewport_set_views(Lib3dsViewport *viewport, Lib3dsDword views);
+extern LIB3DSAPI Lib3dsBool lib3ds_viewport_write(Lib3dsViewport *viewport, Lib3dsIo *io);
+extern LIB3DSAPI void lib3ds_viewport_dump(Lib3dsViewport *viewport);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+
+
+
--- /dev/null
+
+This copy of the libpng notices is provided for your convenience. In case of
+any discrepancy between this copy and the notices in the file png.h that is
+included in the libpng distribution, the latter shall prevail.
+
+COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:
+
+If you modify libpng you may insert additional notices immediately following
+this sentence.
+
+This code is released under the libpng license.
+
+libpng versions 1.2.6, August 15, 2004, through 1.5.4, July 7, 2011, are
+Copyright (c) 2004, 2006-2011 Glenn Randers-Pehrson, and are
+distributed according to the same disclaimer and license as libpng-1.2.5
+with the following individual added to the list of Contributing Authors
+
+ Cosmin Truta
+
+libpng versions 1.0.7, July 1, 2000, through 1.2.5 - October 3, 2002, are
+Copyright (c) 2000-2002 Glenn Randers-Pehrson, and are
+distributed according to the same disclaimer and license as libpng-1.0.6
+with the following individuals added to the list of Contributing Authors
+
+ Simon-Pierre Cadieux
+ Eric S. Raymond
+ Gilles Vollant
+
+and with the following additions to the disclaimer:
+
+ There is no warranty against interference with your enjoyment of the
+ library or against infringement. There is no warranty that our
+ efforts or the library will fulfill any of your particular purposes
+ or needs. This library is provided with all faults, and the entire
+ risk of satisfactory quality, performance, accuracy, and effort is with
+ the user.
+
+libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are
+Copyright (c) 1998, 1999 Glenn Randers-Pehrson, and are
+distributed according to the same disclaimer and license as libpng-0.96,
+with the following individuals added to the list of Contributing Authors:
+
+ Tom Lane
+ Glenn Randers-Pehrson
+ Willem van Schaik
+
+libpng versions 0.89, June 1996, through 0.96, May 1997, are
+Copyright (c) 1996, 1997 Andreas Dilger
+Distributed according to the same disclaimer and license as libpng-0.88,
+with the following individuals added to the list of Contributing Authors:
+
+ John Bowler
+ Kevin Bracey
+ Sam Bushell
+ Magnus Holmgren
+ Greg Roelofs
+ Tom Tanner
+
+libpng versions 0.5, May 1995, through 0.88, January 1996, are
+Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+
+For the purposes of this copyright and license, "Contributing Authors"
+is defined as the following set of individuals:
+
+ Andreas Dilger
+ Dave Martindale
+ Guy Eric Schalnat
+ Paul Schmidt
+ Tim Wegner
+
+The PNG Reference Library is supplied "AS IS". The Contributing Authors
+and Group 42, Inc. disclaim all warranties, expressed or implied,
+including, without limitation, the warranties of merchantability and of
+fitness for any purpose. The Contributing Authors and Group 42, Inc.
+assume no liability for direct, indirect, incidental, special, exemplary,
+or consequential damages, which may result from the use of the PNG
+Reference Library, even if advised of the possibility of such damage.
+
+Permission is hereby granted to use, copy, modify, and distribute this
+source code, or portions hereof, for any purpose, without fee, subject
+to the following restrictions:
+
+1. The origin of this source code must not be misrepresented.
+
+2. Altered versions must be plainly marked as such and must not
+ be misrepresented as being the original source.
+
+3. This Copyright notice may not be removed or altered from any
+ source or altered source distribution.
+
+The Contributing Authors and Group 42, Inc. specifically permit, without
+fee, and encourage the use of this source code as a component to
+supporting the PNG file format in commercial products. If you use this
+source code in a product, acknowledgment is not required but would be
+appreciated.
+
+
+A "png_get_copyright" function is available, for convenient use in "about"
+boxes and the like:
+
+ printf("%s",png_get_copyright(NULL));
+
+Also, the PNG logo (in PNG format, of course) is supplied in the
+files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31).
+
+Libpng is OSI Certified Open Source Software. OSI Certified Open Source is a
+certification mark of the Open Source Initiative.
+
+Glenn Randers-Pehrson
+glennrp at users.sourceforge.net
+July 7, 2011
--- /dev/null
+obj = pngerror.o pngget.o pngmem.o png.o pngpread.o pngread.o pngrio.o \
+ pngrtran.o pngrutil.o pngset.o pngtrans.o pngwio.o pngwrite.o pngwtran.o \
+ pngwutil.o
+
+liba = ../libpng.a
+
+CFLAGS = -O3 -I../zlib
+
+$(liba): $(obj)
+ $(AR) rcs $@ $(obj)
+
+.PHONY: clean
+clean:
+ rm -f $(obj) $(liba)
--- /dev/null
+
+/* png.c - location for general purpose libpng functions
+ *
+ * Last changed in libpng 1.2.30 [August 15, 2008]
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ */
+
+#define PNG_INTERNAL
+#define PNG_NO_EXTERN
+#include "png.h"
+
+/* Generate a compiler error if there is an old png.h in the search path. */
+typedef version_1_2_33 Your_png_h_is_not_version_1_2_33;
+
+/* Version information for C files. This had better match the version
+ * string defined in png.h. */
+
+#ifdef PNG_USE_GLOBAL_ARRAYS
+/* png_libpng_ver was changed to a function in version 1.0.5c */
+PNG_CONST char png_libpng_ver[18] = PNG_LIBPNG_VER_STRING;
+
+#ifdef PNG_READ_SUPPORTED
+
+/* png_sig was changed to a function in version 1.0.5c */
+/* Place to hold the signature string for a PNG file. */
+PNG_CONST png_byte FARDATA png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10};
+#endif /* PNG_READ_SUPPORTED */
+
+/* Invoke global declarations for constant strings for known chunk types */
+PNG_IHDR;
+PNG_IDAT;
+PNG_IEND;
+PNG_PLTE;
+PNG_bKGD;
+PNG_cHRM;
+PNG_gAMA;
+PNG_hIST;
+PNG_iCCP;
+PNG_iTXt;
+PNG_oFFs;
+PNG_pCAL;
+PNG_sCAL;
+PNG_pHYs;
+PNG_sBIT;
+PNG_sPLT;
+PNG_sRGB;
+PNG_tEXt;
+PNG_tIME;
+PNG_tRNS;
+PNG_zTXt;
+
+#ifdef PNG_READ_SUPPORTED
+/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
+
+/* start of interlace block */
+PNG_CONST int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
+
+/* offset to next interlace block */
+PNG_CONST int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
+
+/* start of interlace block in the y direction */
+PNG_CONST int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
+
+/* offset to next interlace block in the y direction */
+PNG_CONST int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
+
+/* Height of interlace block. This is not currently used - if you need
+ * it, uncomment it here and in png.h
+PNG_CONST int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};
+*/
+
+/* Mask to determine which pixels are valid in a pass */
+PNG_CONST int FARDATA png_pass_mask[] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};
+
+/* Mask to determine which pixels to overwrite while displaying */
+PNG_CONST int FARDATA png_pass_dsp_mask[]
+ = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};
+
+#endif /* PNG_READ_SUPPORTED */
+#endif /* PNG_USE_GLOBAL_ARRAYS */
+
+/* Tells libpng that we have already handled the first "num_bytes" bytes
+ * of the PNG file signature. If the PNG data is embedded into another
+ * stream we can set num_bytes = 8 so that libpng will not attempt to read
+ * or write any of the magic bytes before it starts on the IHDR.
+ */
+
+#ifdef PNG_READ_SUPPORTED
+void PNGAPI
+png_set_sig_bytes(png_structp png_ptr, int num_bytes)
+{
+ if (png_ptr == NULL) return;
+ png_debug(1, "in png_set_sig_bytes\n");
+ if (num_bytes > 8)
+ png_error(png_ptr, "Too many bytes for PNG signature.");
+
+ png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes);
+}
+
+/* Checks whether the supplied bytes match the PNG signature. We allow
+ * checking less than the full 8-byte signature so that those apps that
+ * already read the first few bytes of a file to determine the file type
+ * can simply check the remaining bytes for extra assurance. Returns
+ * an integer less than, equal to, or greater than zero if sig is found,
+ * respectively, to be less than, to match, or be greater than the correct
+ * PNG signature (this is the same behaviour as strcmp, memcmp, etc).
+ */
+int PNGAPI
+png_sig_cmp(png_bytep sig, png_size_t start, png_size_t num_to_check)
+{
+ png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
+ if (num_to_check > 8)
+ num_to_check = 8;
+ else if (num_to_check < 1)
+ return (-1);
+
+ if (start > 7)
+ return (-1);
+
+ if (start + num_to_check > 8)
+ num_to_check = 8 - start;
+
+ return ((int)(png_memcmp(&sig[start], &png_signature[start], num_to_check)));
+}
+
+#if defined(PNG_1_0_X) || defined(PNG_1_2_X)
+/* (Obsolete) function to check signature bytes. It does not allow one
+ * to check a partial signature. This function might be removed in the
+ * future - use png_sig_cmp(). Returns true (nonzero) if the file is PNG.
+ */
+int PNGAPI
+png_check_sig(png_bytep sig, int num)
+{
+ return ((int)!png_sig_cmp(sig, (png_size_t)0, (png_size_t)num));
+}
+#endif
+#endif /* PNG_READ_SUPPORTED */
+
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
+/* Function to allocate memory for zlib and clear it to 0. */
+#ifdef PNG_1_0_X
+voidpf PNGAPI
+#else
+voidpf /* private */
+#endif
+png_zalloc(voidpf png_ptr, uInt items, uInt size)
+{
+ png_voidp ptr;
+ png_structp p=(png_structp)png_ptr;
+ png_uint_32 save_flags=p->flags;
+ png_uint_32 num_bytes;
+
+ if (png_ptr == NULL) return (NULL);
+ if (items > PNG_UINT_32_MAX/size)
+ {
+ png_warning (p, "Potential overflow in png_zalloc()");
+ return (NULL);
+ }
+ num_bytes = (png_uint_32)items * size;
+
+ p->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
+ ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes);
+ p->flags=save_flags;
+
+#if defined(PNG_1_0_X) && !defined(PNG_NO_ZALLOC_ZERO)
+ if (ptr == NULL)
+ return ((voidpf)ptr);
+
+ if (num_bytes > (png_uint_32)0x8000L)
+ {
+ png_memset(ptr, 0, (png_size_t)0x8000L);
+ png_memset((png_bytep)ptr + (png_size_t)0x8000L, 0,
+ (png_size_t)(num_bytes - (png_uint_32)0x8000L));
+ }
+ else
+ {
+ png_memset(ptr, 0, (png_size_t)num_bytes);
+ }
+#endif
+ return ((voidpf)ptr);
+}
+
+/* function to free memory for zlib */
+#ifdef PNG_1_0_X
+void PNGAPI
+#else
+void /* private */
+#endif
+png_zfree(voidpf png_ptr, voidpf ptr)
+{
+ png_free((png_structp)png_ptr, (png_voidp)ptr);
+}
+
+/* Reset the CRC variable to 32 bits of 1's. Care must be taken
+ * in case CRC is > 32 bits to leave the top bits 0.
+ */
+void /* PRIVATE */
+png_reset_crc(png_structp png_ptr)
+{
+ png_ptr->crc = crc32(0, Z_NULL, 0);
+}
+
+/* Calculate the CRC over a section of data. We can only pass as
+ * much data to this routine as the largest single buffer size. We
+ * also check that this data will actually be used before going to the
+ * trouble of calculating it.
+ */
+void /* PRIVATE */
+png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length)
+{
+ int need_crc = 1;
+
+ if (png_ptr->chunk_name[0] & 0x20) /* ancillary */
+ {
+ if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
+ (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))
+ need_crc = 0;
+ }
+ else /* critical */
+ {
+ if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)
+ need_crc = 0;
+ }
+
+ if (need_crc)
+ png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length);
+}
+
+/* Allocate the memory for an info_struct for the application. We don't
+ * really need the png_ptr, but it could potentially be useful in the
+ * future. This should be used in favour of malloc(png_sizeof(png_info))
+ * and png_info_init() so that applications that want to use a shared
+ * libpng don't have to be recompiled if png_info changes size.
+ */
+png_infop PNGAPI
+png_create_info_struct(png_structp png_ptr)
+{
+ png_infop info_ptr;
+
+ png_debug(1, "in png_create_info_struct\n");
+ if (png_ptr == NULL) return (NULL);
+#ifdef PNG_USER_MEM_SUPPORTED
+ info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO,
+ png_ptr->malloc_fn, png_ptr->mem_ptr);
+#else
+ info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
+#endif
+ if (info_ptr != NULL)
+ png_info_init_3(&info_ptr, png_sizeof(png_info));
+
+ return (info_ptr);
+}
+
+/* This function frees the memory associated with a single info struct.
+ * Normally, one would use either png_destroy_read_struct() or
+ * png_destroy_write_struct() to free an info struct, but this may be
+ * useful for some applications.
+ */
+void PNGAPI
+png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)
+{
+ png_infop info_ptr = NULL;
+ if (png_ptr == NULL) return;
+
+ png_debug(1, "in png_destroy_info_struct\n");
+ if (info_ptr_ptr != NULL)
+ info_ptr = *info_ptr_ptr;
+
+ if (info_ptr != NULL)
+ {
+ png_info_destroy(png_ptr, info_ptr);
+
+#ifdef PNG_USER_MEM_SUPPORTED
+ png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn,
+ png_ptr->mem_ptr);
+#else
+ png_destroy_struct((png_voidp)info_ptr);
+#endif
+ *info_ptr_ptr = NULL;
+ }
+}
+
+/* Initialize the info structure. This is now an internal function (0.89)
+ * and applications using it are urged to use png_create_info_struct()
+ * instead.
+ */
+#if defined(PNG_1_0_X) || defined(PNG_1_2_X)
+#undef png_info_init
+void PNGAPI
+png_info_init(png_infop info_ptr)
+{
+ /* We only come here via pre-1.0.12-compiled applications */
+ png_info_init_3(&info_ptr, 0);
+}
+#endif
+
+void PNGAPI
+png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size)
+{
+ png_infop info_ptr = *ptr_ptr;
+
+ if (info_ptr == NULL) return;
+
+ png_debug(1, "in png_info_init_3\n");
+
+ if (png_sizeof(png_info) > png_info_struct_size)
+ {
+ png_destroy_struct(info_ptr);
+ info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
+ *ptr_ptr = info_ptr;
+ }
+
+ /* set everything to 0 */
+ png_memset(info_ptr, 0, png_sizeof(png_info));
+}
+
+#ifdef PNG_FREE_ME_SUPPORTED
+void PNGAPI
+png_data_freer(png_structp png_ptr, png_infop info_ptr,
+ int freer, png_uint_32 mask)
+{
+ png_debug(1, "in png_data_freer\n");
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+ if (freer == PNG_DESTROY_WILL_FREE_DATA)
+ info_ptr->free_me |= mask;
+ else if (freer == PNG_USER_WILL_FREE_DATA)
+ info_ptr->free_me &= ~mask;
+ else
+ png_warning(png_ptr,
+ "Unknown freer parameter in png_data_freer.");
+}
+#endif
+
+void PNGAPI
+png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask,
+ int num)
+{
+ png_debug(1, "in png_free_data\n");
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+
+#if defined(PNG_TEXT_SUPPORTED)
+/* free text item num or (if num == -1) all text items */
+#ifdef PNG_FREE_ME_SUPPORTED
+if ((mask & PNG_FREE_TEXT) & info_ptr->free_me)
+#else
+if (mask & PNG_FREE_TEXT)
+#endif
+{
+ if (num != -1)
+ {
+ if (info_ptr->text && info_ptr->text[num].key)
+ {
+ png_free(png_ptr, info_ptr->text[num].key);
+ info_ptr->text[num].key = NULL;
+ }
+ }
+ else
+ {
+ int i;
+ for (i = 0; i < info_ptr->num_text; i++)
+ png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i);
+ png_free(png_ptr, info_ptr->text);
+ info_ptr->text = NULL;
+ info_ptr->num_text=0;
+ }
+}
+#endif
+
+#if defined(PNG_tRNS_SUPPORTED)
+/* free any tRNS entry */
+#ifdef PNG_FREE_ME_SUPPORTED
+if ((mask & PNG_FREE_TRNS) & info_ptr->free_me)
+#else
+if ((mask & PNG_FREE_TRNS) && (png_ptr->flags & PNG_FLAG_FREE_TRNS))
+#endif
+{
+ png_free(png_ptr, info_ptr->trans);
+ info_ptr->trans = NULL;
+ info_ptr->valid &= ~PNG_INFO_tRNS;
+#ifndef PNG_FREE_ME_SUPPORTED
+ png_ptr->flags &= ~PNG_FLAG_FREE_TRNS;
+#endif
+}
+#endif
+
+#if defined(PNG_sCAL_SUPPORTED)
+/* free any sCAL entry */
+#ifdef PNG_FREE_ME_SUPPORTED
+if ((mask & PNG_FREE_SCAL) & info_ptr->free_me)
+#else
+if (mask & PNG_FREE_SCAL)
+#endif
+{
+#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)
+ png_free(png_ptr, info_ptr->scal_s_width);
+ png_free(png_ptr, info_ptr->scal_s_height);
+ info_ptr->scal_s_width = NULL;
+ info_ptr->scal_s_height = NULL;
+#endif
+ info_ptr->valid &= ~PNG_INFO_sCAL;
+}
+#endif
+
+#if defined(PNG_pCAL_SUPPORTED)
+/* free any pCAL entry */
+#ifdef PNG_FREE_ME_SUPPORTED
+if ((mask & PNG_FREE_PCAL) & info_ptr->free_me)
+#else
+if (mask & PNG_FREE_PCAL)
+#endif
+{
+ png_free(png_ptr, info_ptr->pcal_purpose);
+ png_free(png_ptr, info_ptr->pcal_units);
+ info_ptr->pcal_purpose = NULL;
+ info_ptr->pcal_units = NULL;
+ if (info_ptr->pcal_params != NULL)
+ {
+ int i;
+ for (i = 0; i < (int)info_ptr->pcal_nparams; i++)
+ {
+ png_free(png_ptr, info_ptr->pcal_params[i]);
+ info_ptr->pcal_params[i]=NULL;
+ }
+ png_free(png_ptr, info_ptr->pcal_params);
+ info_ptr->pcal_params = NULL;
+ }
+ info_ptr->valid &= ~PNG_INFO_pCAL;
+}
+#endif
+
+#if defined(PNG_iCCP_SUPPORTED)
+/* free any iCCP entry */
+#ifdef PNG_FREE_ME_SUPPORTED
+if ((mask & PNG_FREE_ICCP) & info_ptr->free_me)
+#else
+if (mask & PNG_FREE_ICCP)
+#endif
+{
+ png_free(png_ptr, info_ptr->iccp_name);
+ png_free(png_ptr, info_ptr->iccp_profile);
+ info_ptr->iccp_name = NULL;
+ info_ptr->iccp_profile = NULL;
+ info_ptr->valid &= ~PNG_INFO_iCCP;
+}
+#endif
+
+#if defined(PNG_sPLT_SUPPORTED)
+/* free a given sPLT entry, or (if num == -1) all sPLT entries */
+#ifdef PNG_FREE_ME_SUPPORTED
+if ((mask & PNG_FREE_SPLT) & info_ptr->free_me)
+#else
+if (mask & PNG_FREE_SPLT)
+#endif
+{
+ if (num != -1)
+ {
+ if (info_ptr->splt_palettes)
+ {
+ png_free(png_ptr, info_ptr->splt_palettes[num].name);
+ png_free(png_ptr, info_ptr->splt_palettes[num].entries);
+ info_ptr->splt_palettes[num].name = NULL;
+ info_ptr->splt_palettes[num].entries = NULL;
+ }
+ }
+ else
+ {
+ if (info_ptr->splt_palettes_num)
+ {
+ int i;
+ for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
+ png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i);
+
+ png_free(png_ptr, info_ptr->splt_palettes);
+ info_ptr->splt_palettes = NULL;
+ info_ptr->splt_palettes_num = 0;
+ }
+ info_ptr->valid &= ~PNG_INFO_sPLT;
+ }
+}
+#endif
+
+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
+ if (png_ptr->unknown_chunk.data)
+ {
+ png_free(png_ptr, png_ptr->unknown_chunk.data);
+ png_ptr->unknown_chunk.data = NULL;
+ }
+
+#ifdef PNG_FREE_ME_SUPPORTED
+if ((mask & PNG_FREE_UNKN) & info_ptr->free_me)
+#else
+if (mask & PNG_FREE_UNKN)
+#endif
+{
+ if (num != -1)
+ {
+ if (info_ptr->unknown_chunks)
+ {
+ png_free(png_ptr, info_ptr->unknown_chunks[num].data);
+ info_ptr->unknown_chunks[num].data = NULL;
+ }
+ }
+ else
+ {
+ int i;
+
+ if (info_ptr->unknown_chunks_num)
+ {
+ for (i = 0; i < (int)info_ptr->unknown_chunks_num; i++)
+ png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i);
+
+ png_free(png_ptr, info_ptr->unknown_chunks);
+ info_ptr->unknown_chunks = NULL;
+ info_ptr->unknown_chunks_num = 0;
+ }
+ }
+}
+#endif
+
+#if defined(PNG_hIST_SUPPORTED)
+/* free any hIST entry */
+#ifdef PNG_FREE_ME_SUPPORTED
+if ((mask & PNG_FREE_HIST) & info_ptr->free_me)
+#else
+if ((mask & PNG_FREE_HIST) && (png_ptr->flags & PNG_FLAG_FREE_HIST))
+#endif
+{
+ png_free(png_ptr, info_ptr->hist);
+ info_ptr->hist = NULL;
+ info_ptr->valid &= ~PNG_INFO_hIST;
+#ifndef PNG_FREE_ME_SUPPORTED
+ png_ptr->flags &= ~PNG_FLAG_FREE_HIST;
+#endif
+}
+#endif
+
+/* free any PLTE entry that was internally allocated */
+#ifdef PNG_FREE_ME_SUPPORTED
+if ((mask & PNG_FREE_PLTE) & info_ptr->free_me)
+#else
+if ((mask & PNG_FREE_PLTE) && (png_ptr->flags & PNG_FLAG_FREE_PLTE))
+#endif
+{
+ png_zfree(png_ptr, info_ptr->palette);
+ info_ptr->palette = NULL;
+ info_ptr->valid &= ~PNG_INFO_PLTE;
+#ifndef PNG_FREE_ME_SUPPORTED
+ png_ptr->flags &= ~PNG_FLAG_FREE_PLTE;
+#endif
+ info_ptr->num_palette = 0;
+}
+
+#if defined(PNG_INFO_IMAGE_SUPPORTED)
+/* free any image bits attached to the info structure */
+#ifdef PNG_FREE_ME_SUPPORTED
+if ((mask & PNG_FREE_ROWS) & info_ptr->free_me)
+#else
+if (mask & PNG_FREE_ROWS)
+#endif
+{
+ if (info_ptr->row_pointers)
+ {
+ int row;
+ for (row = 0; row < (int)info_ptr->height; row++)
+ {
+ png_free(png_ptr, info_ptr->row_pointers[row]);
+ info_ptr->row_pointers[row]=NULL;
+ }
+ png_free(png_ptr, info_ptr->row_pointers);
+ info_ptr->row_pointers=NULL;
+ }
+ info_ptr->valid &= ~PNG_INFO_IDAT;
+}
+#endif
+
+#ifdef PNG_FREE_ME_SUPPORTED
+ if (num == -1)
+ info_ptr->free_me &= ~mask;
+ else
+ info_ptr->free_me &= ~(mask & ~PNG_FREE_MUL);
+#endif
+}
+
+/* This is an internal routine to free any memory that the info struct is
+ * pointing to before re-using it or freeing the struct itself. Recall
+ * that png_free() checks for NULL pointers for us.
+ */
+void /* PRIVATE */
+png_info_destroy(png_structp png_ptr, png_infop info_ptr)
+{
+ png_debug(1, "in png_info_destroy\n");
+
+ png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
+
+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
+ if (png_ptr->num_chunk_list)
+ {
+ png_free(png_ptr, png_ptr->chunk_list);
+ png_ptr->chunk_list=NULL;
+ png_ptr->num_chunk_list = 0;
+ }
+#endif
+
+ png_info_init_3(&info_ptr, png_sizeof(png_info));
+}
+#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
+
+/* This function returns a pointer to the io_ptr associated with the user
+ * functions. The application should free any memory associated with this
+ * pointer before png_write_destroy() or png_read_destroy() are called.
+ */
+png_voidp PNGAPI
+png_get_io_ptr(png_structp png_ptr)
+{
+ if (png_ptr == NULL) return (NULL);
+ return (png_ptr->io_ptr);
+}
+
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
+#if !defined(PNG_NO_STDIO)
+/* Initialize the default input/output functions for the PNG file. If you
+ * use your own read or write routines, you can call either png_set_read_fn()
+ * or png_set_write_fn() instead of png_init_io(). If you have defined
+ * PNG_NO_STDIO, you must use a function of your own because "FILE *" isn't
+ * necessarily available.
+ */
+void PNGAPI
+png_init_io(png_structp png_ptr, png_FILE_p fp)
+{
+ png_debug(1, "in png_init_io\n");
+ if (png_ptr == NULL) return;
+ png_ptr->io_ptr = (png_voidp)fp;
+}
+#endif
+
+#if defined(PNG_TIME_RFC1123_SUPPORTED)
+/* Convert the supplied time into an RFC 1123 string suitable for use in
+ * a "Creation Time" or other text-based time string.
+ */
+png_charp PNGAPI
+png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)
+{
+ static PNG_CONST char short_months[12][4] =
+ {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
+ "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
+
+ if (png_ptr == NULL) return (NULL);
+ if (png_ptr->time_buffer == NULL)
+ {
+ png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29*
+ png_sizeof(char)));
+ }
+
+#if defined(_WIN32_WCE)
+ {
+ wchar_t time_buf[29];
+ wsprintf(time_buf, TEXT("%d %S %d %02d:%02d:%02d +0000"),
+ ptime->day % 32, short_months[(ptime->month - 1) % 12],
+ ptime->year, ptime->hour % 24, ptime->minute % 60,
+ ptime->second % 61);
+ WideCharToMultiByte(CP_ACP, 0, time_buf, -1, png_ptr->time_buffer, 29,
+ NULL, NULL);
+ }
+#else
+#ifdef USE_FAR_KEYWORD
+ {
+ char near_time_buf[29];
+ png_snprintf6(near_time_buf, 29, "%d %s %d %02d:%02d:%02d +0000",
+ ptime->day % 32, short_months[(ptime->month - 1) % 12],
+ ptime->year, ptime->hour % 24, ptime->minute % 60,
+ ptime->second % 61);
+ png_memcpy(png_ptr->time_buffer, near_time_buf,
+ 29*png_sizeof(char));
+ }
+#else
+ png_snprintf6(png_ptr->time_buffer, 29, "%d %s %d %02d:%02d:%02d +0000",
+ ptime->day % 32, short_months[(ptime->month - 1) % 12],
+ ptime->year, ptime->hour % 24, ptime->minute % 60,
+ ptime->second % 61);
+#endif
+#endif /* _WIN32_WCE */
+ return ((png_charp)png_ptr->time_buffer);
+}
+#endif /* PNG_TIME_RFC1123_SUPPORTED */
+
+#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
+
+png_charp PNGAPI
+png_get_copyright(png_structp png_ptr)
+{
+ png_ptr = png_ptr; /* silence compiler warning about unused png_ptr */
+ return ((png_charp) "\n libpng version 1.2.33 - October 31, 2008\n\
+ Copyright (c) 1998-2008 Glenn Randers-Pehrson\n\
+ Copyright (c) 1996-1997 Andreas Dilger\n\
+ Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.\n");
+}
+
+/* The following return the library version as a short string in the
+ * format 1.0.0 through 99.99.99zz. To get the version of *.h files
+ * used with your application, print out PNG_LIBPNG_VER_STRING, which
+ * is defined in png.h.
+ * Note: now there is no difference between png_get_libpng_ver() and
+ * png_get_header_ver(). Due to the version_nn_nn_nn typedef guard,
+ * it is guaranteed that png.c uses the correct version of png.h.
+ */
+png_charp PNGAPI
+png_get_libpng_ver(png_structp png_ptr)
+{
+ /* Version of *.c files used when building libpng */
+ png_ptr = png_ptr; /* silence compiler warning about unused png_ptr */
+ return ((png_charp) PNG_LIBPNG_VER_STRING);
+}
+
+png_charp PNGAPI
+png_get_header_ver(png_structp png_ptr)
+{
+ /* Version of *.h files used when building libpng */
+ png_ptr = png_ptr; /* silence compiler warning about unused png_ptr */
+ return ((png_charp) PNG_LIBPNG_VER_STRING);
+}
+
+png_charp PNGAPI
+png_get_header_version(png_structp png_ptr)
+{
+ /* Returns longer string containing both version and date */
+ png_ptr = png_ptr; /* silence compiler warning about unused png_ptr */
+ return ((png_charp) PNG_HEADER_VERSION_STRING
+#ifndef PNG_READ_SUPPORTED
+ " (NO READ SUPPORT)"
+#endif
+ "\n");
+}
+
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+int PNGAPI
+png_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name)
+{
+ /* check chunk_name and return "keep" value if it's on the list, else 0 */
+ int i;
+ png_bytep p;
+ if (png_ptr == NULL || chunk_name == NULL || png_ptr->num_chunk_list<=0)
+ return 0;
+ p = png_ptr->chunk_list + png_ptr->num_chunk_list*5 - 5;
+ for (i = png_ptr->num_chunk_list; i; i--, p -= 5)
+ if (!png_memcmp(chunk_name, p, 4))
+ return ((int)*(p + 4));
+ return 0;
+}
+#endif
+
+/* This function, added to libpng-1.0.6g, is untested. */
+int PNGAPI
+png_reset_zstream(png_structp png_ptr)
+{
+ if (png_ptr == NULL) return Z_STREAM_ERROR;
+ return (inflateReset(&png_ptr->zstream));
+}
+#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
+
+/* This function was added to libpng-1.0.7 */
+png_uint_32 PNGAPI
+png_access_version_number(void)
+{
+ /* Version of *.c files used when building libpng */
+ return((png_uint_32) PNG_LIBPNG_VER);
+}
+
+
+#if defined(PNG_READ_SUPPORTED) && defined(PNG_ASSEMBLER_CODE_SUPPORTED)
+#if !defined(PNG_1_0_X)
+/* this function was added to libpng 1.2.0 */
+int PNGAPI
+png_mmx_support(void)
+{
+ /* obsolete, to be removed from libpng-1.4.0 */
+ return -1;
+}
+#endif /* PNG_1_0_X */
+#endif /* PNG_READ_SUPPORTED && PNG_ASSEMBLER_CODE_SUPPORTED */
+
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
+#ifdef PNG_SIZE_T
+/* Added at libpng version 1.2.6 */
+ PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size));
+png_size_t PNGAPI
+png_convert_size(size_t size)
+{
+ if (size > (png_size_t)-1)
+ PNG_ABORT(); /* We haven't got access to png_ptr, so no png_error() */
+ return ((png_size_t)size);
+}
+#endif /* PNG_SIZE_T */
+#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
--- /dev/null
+/* png.h - header file for PNG reference library
+ *
+ * libpng version 1.2.33 - October 31, 2008
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * Authors and maintainers:
+ * libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat
+ * libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger
+ * libpng versions 0.97, January 1998, through 1.2.33 - October 31, 2008: Glenn
+ * See also "Contributing Authors", below.
+ *
+ * Note about libpng version numbers:
+ *
+ * Due to various miscommunications, unforeseen code incompatibilities
+ * and occasional factors outside the authors' control, version numbering
+ * on the library has not always been consistent and straightforward.
+ * The following table summarizes matters since version 0.89c, which was
+ * the first widely used release:
+ *
+ * source png.h png.h shared-lib
+ * version string int version
+ * ------- ------ ----- ----------
+ * 0.89c "1.0 beta 3" 0.89 89 1.0.89
+ * 0.90 "1.0 beta 4" 0.90 90 0.90 [should have been 2.0.90]
+ * 0.95 "1.0 beta 5" 0.95 95 0.95 [should have been 2.0.95]
+ * 0.96 "1.0 beta 6" 0.96 96 0.96 [should have been 2.0.96]
+ * 0.97b "1.00.97 beta 7" 1.00.97 97 1.0.1 [should have been 2.0.97]
+ * 0.97c 0.97 97 2.0.97
+ * 0.98 0.98 98 2.0.98
+ * 0.99 0.99 98 2.0.99
+ * 0.99a-m 0.99 99 2.0.99
+ * 1.00 1.00 100 2.1.0 [100 should be 10000]
+ * 1.0.0 (from here on, the 100 2.1.0 [100 should be 10000]
+ * 1.0.1 png.h string is 10001 2.1.0
+ * 1.0.1a-e identical to the 10002 from here on, the shared library
+ * 1.0.2 source version) 10002 is 2.V where V is the source code
+ * 1.0.2a-b 10003 version, except as noted.
+ * 1.0.3 10003
+ * 1.0.3a-d 10004
+ * 1.0.4 10004
+ * 1.0.4a-f 10005
+ * 1.0.5 (+ 2 patches) 10005
+ * 1.0.5a-d 10006
+ * 1.0.5e-r 10100 (not source compatible)
+ * 1.0.5s-v 10006 (not binary compatible)
+ * 1.0.6 (+ 3 patches) 10006 (still binary incompatible)
+ * 1.0.6d-f 10007 (still binary incompatible)
+ * 1.0.6g 10007
+ * 1.0.6h 10007 10.6h (testing xy.z so-numbering)
+ * 1.0.6i 10007 10.6i
+ * 1.0.6j 10007 2.1.0.6j (incompatible with 1.0.0)
+ * 1.0.7beta11-14 DLLNUM 10007 2.1.0.7beta11-14 (binary compatible)
+ * 1.0.7beta15-18 1 10007 2.1.0.7beta15-18 (binary compatible)
+ * 1.0.7rc1-2 1 10007 2.1.0.7rc1-2 (binary compatible)
+ * 1.0.7 1 10007 (still compatible)
+ * 1.0.8beta1-4 1 10008 2.1.0.8beta1-4
+ * 1.0.8rc1 1 10008 2.1.0.8rc1
+ * 1.0.8 1 10008 2.1.0.8
+ * 1.0.9beta1-6 1 10009 2.1.0.9beta1-6
+ * 1.0.9rc1 1 10009 2.1.0.9rc1
+ * 1.0.9beta7-10 1 10009 2.1.0.9beta7-10
+ * 1.0.9rc2 1 10009 2.1.0.9rc2
+ * 1.0.9 1 10009 2.1.0.9
+ * 1.0.10beta1 1 10010 2.1.0.10beta1
+ * 1.0.10rc1 1 10010 2.1.0.10rc1
+ * 1.0.10 1 10010 2.1.0.10
+ * 1.0.11beta1-3 1 10011 2.1.0.11beta1-3
+ * 1.0.11rc1 1 10011 2.1.0.11rc1
+ * 1.0.11 1 10011 2.1.0.11
+ * 1.0.12beta1-2 2 10012 2.1.0.12beta1-2
+ * 1.0.12rc1 2 10012 2.1.0.12rc1
+ * 1.0.12 2 10012 2.1.0.12
+ * 1.1.0a-f - 10100 2.1.1.0a-f (branch abandoned)
+ * 1.2.0beta1-2 2 10200 2.1.2.0beta1-2
+ * 1.2.0beta3-5 3 10200 3.1.2.0beta3-5
+ * 1.2.0rc1 3 10200 3.1.2.0rc1
+ * 1.2.0 3 10200 3.1.2.0
+ * 1.2.1beta1-4 3 10201 3.1.2.1beta1-4
+ * 1.2.1rc1-2 3 10201 3.1.2.1rc1-2
+ * 1.2.1 3 10201 3.1.2.1
+ * 1.2.2beta1-6 12 10202 12.so.0.1.2.2beta1-6
+ * 1.0.13beta1 10 10013 10.so.0.1.0.13beta1
+ * 1.0.13rc1 10 10013 10.so.0.1.0.13rc1
+ * 1.2.2rc1 12 10202 12.so.0.1.2.2rc1
+ * 1.0.13 10 10013 10.so.0.1.0.13
+ * 1.2.2 12 10202 12.so.0.1.2.2
+ * 1.2.3rc1-6 12 10203 12.so.0.1.2.3rc1-6
+ * 1.2.3 12 10203 12.so.0.1.2.3
+ * 1.2.4beta1-3 13 10204 12.so.0.1.2.4beta1-3
+ * 1.0.14rc1 13 10014 10.so.0.1.0.14rc1
+ * 1.2.4rc1 13 10204 12.so.0.1.2.4rc1
+ * 1.0.14 10 10014 10.so.0.1.0.14
+ * 1.2.4 13 10204 12.so.0.1.2.4
+ * 1.2.5beta1-2 13 10205 12.so.0.1.2.5beta1-2
+ * 1.0.15rc1-3 10 10015 10.so.0.1.0.15rc1-3
+ * 1.2.5rc1-3 13 10205 12.so.0.1.2.5rc1-3
+ * 1.0.15 10 10015 10.so.0.1.0.15
+ * 1.2.5 13 10205 12.so.0.1.2.5
+ * 1.2.6beta1-4 13 10206 12.so.0.1.2.6beta1-4
+ * 1.0.16 10 10016 10.so.0.1.0.16
+ * 1.2.6 13 10206 12.so.0.1.2.6
+ * 1.2.7beta1-2 13 10207 12.so.0.1.2.7beta1-2
+ * 1.0.17rc1 10 10017 10.so.0.1.0.17rc1
+ * 1.2.7rc1 13 10207 12.so.0.1.2.7rc1
+ * 1.0.17 10 10017 10.so.0.1.0.17
+ * 1.2.7 13 10207 12.so.0.1.2.7
+ * 1.2.8beta1-5 13 10208 12.so.0.1.2.8beta1-5
+ * 1.0.18rc1-5 10 10018 10.so.0.1.0.18rc1-5
+ * 1.2.8rc1-5 13 10208 12.so.0.1.2.8rc1-5
+ * 1.0.18 10 10018 10.so.0.1.0.18
+ * 1.2.8 13 10208 12.so.0.1.2.8
+ * 1.2.9beta1-3 13 10209 12.so.0.1.2.9beta1-3
+ * 1.2.9beta4-11 13 10209 12.so.0.9[.0]
+ * 1.2.9rc1 13 10209 12.so.0.9[.0]
+ * 1.2.9 13 10209 12.so.0.9[.0]
+ * 1.2.10beta1-8 13 10210 12.so.0.10[.0]
+ * 1.2.10rc1-3 13 10210 12.so.0.10[.0]
+ * 1.2.10 13 10210 12.so.0.10[.0]
+ * 1.2.11beta1-4 13 10211 12.so.0.11[.0]
+ * 1.0.19rc1-5 10 10019 10.so.0.19[.0]
+ * 1.2.11rc1-5 13 10211 12.so.0.11[.0]
+ * 1.0.19 10 10019 10.so.0.19[.0]
+ * 1.2.11 13 10211 12.so.0.11[.0]
+ * 1.0.20 10 10020 10.so.0.20[.0]
+ * 1.2.12 13 10212 12.so.0.12[.0]
+ * 1.2.13beta1 13 10213 12.so.0.13[.0]
+ * 1.0.21 10 10021 10.so.0.21[.0]
+ * 1.2.13 13 10213 12.so.0.13[.0]
+ * 1.2.14beta1-2 13 10214 12.so.0.14[.0]
+ * 1.0.22rc1 10 10022 10.so.0.22[.0]
+ * 1.2.14rc1 13 10214 12.so.0.14[.0]
+ * 1.0.22 10 10022 10.so.0.22[.0]
+ * 1.2.14 13 10214 12.so.0.14[.0]
+ * 1.2.15beta1-6 13 10215 12.so.0.15[.0]
+ * 1.0.23rc1-5 10 10023 10.so.0.23[.0]
+ * 1.2.15rc1-5 13 10215 12.so.0.15[.0]
+ * 1.0.23 10 10023 10.so.0.23[.0]
+ * 1.2.15 13 10215 12.so.0.15[.0]
+ * 1.2.16beta1-2 13 10216 12.so.0.16[.0]
+ * 1.2.16rc1 13 10216 12.so.0.16[.0]
+ * 1.0.24 10 10024 10.so.0.24[.0]
+ * 1.2.16 13 10216 12.so.0.16[.0]
+ * 1.2.17beta1-2 13 10217 12.so.0.17[.0]
+ * 1.0.25rc1 10 10025 10.so.0.25[.0]
+ * 1.2.17rc1-3 13 10217 12.so.0.17[.0]
+ * 1.0.25 10 10025 10.so.0.25[.0]
+ * 1.2.17 13 10217 12.so.0.17[.0]
+ * 1.0.26 10 10026 10.so.0.26[.0]
+ * 1.2.18 13 10218 12.so.0.18[.0]
+ * 1.2.19beta1-31 13 10219 12.so.0.19[.0]
+ * 1.0.27rc1-6 10 10027 10.so.0.27[.0]
+ * 1.2.19rc1-6 13 10219 12.so.0.19[.0]
+ * 1.0.27 10 10027 10.so.0.27[.0]
+ * 1.2.19 13 10219 12.so.0.19[.0]
+ * 1.2.20beta01-04 13 10220 12.so.0.20[.0]
+ * 1.0.28rc1-6 10 10028 10.so.0.28[.0]
+ * 1.2.20rc1-6 13 10220 12.so.0.20[.0]
+ * 1.0.28 10 10028 10.so.0.28[.0]
+ * 1.2.20 13 10220 12.so.0.20[.0]
+ * 1.2.21beta1-2 13 10221 12.so.0.21[.0]
+ * 1.2.21rc1-3 13 10221 12.so.0.21[.0]
+ * 1.0.29 10 10029 10.so.0.29[.0]
+ * 1.2.21 13 10221 12.so.0.21[.0]
+ * 1.2.22beta1-4 13 10222 12.so.0.22[.0]
+ * 1.0.30rc1 10 10030 10.so.0.30[.0]
+ * 1.2.22rc1 13 10222 12.so.0.22[.0]
+ * 1.0.30 10 10030 10.so.0.30[.0]
+ * 1.2.22 13 10222 12.so.0.22[.0]
+ * 1.2.23beta01-05 13 10223 12.so.0.23[.0]
+ * 1.2.23rc01 13 10223 12.so.0.23[.0]
+ * 1.2.23 13 10223 12.so.0.23[.0]
+ * 1.2.24beta01-02 13 10224 12.so.0.24[.0]
+ * 1.2.24rc01 13 10224 12.so.0.24[.0]
+ * 1.2.24 13 10224 12.so.0.24[.0]
+ * 1.2.25beta01-06 13 10225 12.so.0.25[.0]
+ * 1.2.25rc01-02 13 10225 12.so.0.25[.0]
+ * 1.0.31 10 10031 10.so.0.31[.0]
+ * 1.2.25 13 10225 12.so.0.25[.0]
+ * 1.2.26beta01-06 13 10226 12.so.0.26[.0]
+ * 1.2.26rc01 13 10226 12.so.0.26[.0]
+ * 1.2.26 13 10226 12.so.0.26[.0]
+ * 1.0.32 10 10032 10.so.0.32[.0]
+ * 1.2.27beta01-06 13 10227 12.so.0.27[.0]
+ * 1.2.27rc01 13 10227 12.so.0.27[.0]
+ * 1.0.33 10 10033 10.so.0.33[.0]
+ * 1.2.27 13 10227 12.so.0.27[.0]
+ * 1.0.34 10 10034 10.so.0.34[.0]
+ * 1.2.28 13 10228 12.so.0.28[.0]
+ * 1.2.29beta01-03 13 10229 12.so.0.29[.0]
+ * 1.2.29rc01 13 10229 12.so.0.29[.0]
+ * 1.0.35 10 10035 10.so.0.35[.0]
+ * 1.2.29 13 10229 12.so.0.29[.0]
+ * 1.0.37 10 10037 10.so.0.37[.0]
+ * 1.2.30beta01-04 13 10230 12.so.0.30[.0]
+ * 1.0.38rc01-08 10 10038 10.so.0.38[.0]
+ * 1.2.30rc01-08 13 10230 12.so.0.30[.0]
+ * 1.0.38 10 10038 10.so.0.38[.0]
+ * 1.2.30 13 10230 12.so.0.30[.0]
+ * 1.0.39rc01-03 10 10039 10.so.0.39[.0]
+ * 1.2.31rc01-03 13 10231 12.so.0.31[.0]
+ * 1.0.39 10 10039 10.so.0.39[.0]
+ * 1.2.31 13 10231 12.so.0.31[.0]
+ * 1.2.32beta01-02 13 10232 12.so.0.32[.0]
+ * 1.0.40rc01 10 10040 10.so.0.40[.0]
+ * 1.2.32rc01 13 10232 12.so.0.32[.0]
+ * 1.0.40 10 10040 10.so.0.40[.0]
+ * 1.2.32 13 10232 12.so.0.32[.0]
+ * 1.2.33beta01-02 13 10233 12.so.0.33[.0]
+ * 1.2.33rc01-02 13 10233 12.so.0.33[.0]
+ * 1.0.41rc01 10 10041 10.so.0.41[.0]
+ * 1.2.33 13 10233 12.so.0.33[.0]
+ * 1.0.41 10 10041 10.so.0.41[.0]
+ *
+ * Henceforth the source version will match the shared-library major
+ * and minor numbers; the shared-library major version number will be
+ * used for changes in backward compatibility, as it is intended. The
+ * PNG_LIBPNG_VER macro, which is not used within libpng but is available
+ * for applications, is an unsigned integer of the form xyyzz corresponding
+ * to the source version x.y.z (leading zeros in y and z). Beta versions
+ * were given the previous public release number plus a letter, until
+ * version 1.0.6j; from then on they were given the upcoming public
+ * release number plus "betaNN" or "rcNN".
+ *
+ * Binary incompatibility exists only when applications make direct access
+ * to the info_ptr or png_ptr members through png.h, and the compiled
+ * application is loaded with a different version of the library.
+ *
+ * DLLNUM will change each time there are forward or backward changes
+ * in binary compatibility (e.g., when a new feature is added).
+ *
+ * See libpng.txt or libpng.3 for more information. The PNG specification
+ * is available as a W3C Recommendation and as an ISO Specification,
+ * <http://www.w3.org/TR/2003/REC-PNG-20031110/
+ */
+
+/*
+ * COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:
+ *
+ * If you modify libpng you may insert additional notices immediately following
+ * this sentence.
+ *
+ * libpng versions 1.2.6, August 15, 2004, through 1.2.33, October 31, 2008, are
+ * Copyright (c) 2004, 2006-2008 Glenn Randers-Pehrson, and are
+ * distributed according to the same disclaimer and license as libpng-1.2.5
+ * with the following individual added to the list of Contributing Authors:
+ *
+ * Cosmin Truta
+ *
+ * libpng versions 1.0.7, July 1, 2000, through 1.2.5, October 3, 2002, are
+ * Copyright (c) 2000-2002 Glenn Randers-Pehrson, and are
+ * distributed according to the same disclaimer and license as libpng-1.0.6
+ * with the following individuals added to the list of Contributing Authors:
+ *
+ * Simon-Pierre Cadieux
+ * Eric S. Raymond
+ * Gilles Vollant
+ *
+ * and with the following additions to the disclaimer:
+ *
+ * There is no warranty against interference with your enjoyment of the
+ * library or against infringement. There is no warranty that our
+ * efforts or the library will fulfill any of your particular purposes
+ * or needs. This library is provided with all faults, and the entire
+ * risk of satisfactory quality, performance, accuracy, and effort is with
+ * the user.
+ *
+ * libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are
+ * Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson, and are
+ * distributed according to the same disclaimer and license as libpng-0.96,
+ * with the following individuals added to the list of Contributing Authors:
+ *
+ * Tom Lane
+ * Glenn Randers-Pehrson
+ * Willem van Schaik
+ *
+ * libpng versions 0.89, June 1996, through 0.96, May 1997, are
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Distributed according to the same disclaimer and license as libpng-0.88,
+ * with the following individuals added to the list of Contributing Authors:
+ *
+ * John Bowler
+ * Kevin Bracey
+ * Sam Bushell
+ * Magnus Holmgren
+ * Greg Roelofs
+ * Tom Tanner
+ *
+ * libpng versions 0.5, May 1995, through 0.88, January 1996, are
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * For the purposes of this copyright and license, "Contributing Authors"
+ * is defined as the following set of individuals:
+ *
+ * Andreas Dilger
+ * Dave Martindale
+ * Guy Eric Schalnat
+ * Paul Schmidt
+ * Tim Wegner
+ *
+ * The PNG Reference Library is supplied "AS IS". The Contributing Authors
+ * and Group 42, Inc. disclaim all warranties, expressed or implied,
+ * including, without limitation, the warranties of merchantability and of
+ * fitness for any purpose. The Contributing Authors and Group 42, Inc.
+ * assume no liability for direct, indirect, incidental, special, exemplary,
+ * or consequential damages, which may result from the use of the PNG
+ * Reference Library, even if advised of the possibility of such damage.
+ *
+ * Permission is hereby granted to use, copy, modify, and distribute this
+ * source code, or portions hereof, for any purpose, without fee, subject
+ * to the following restrictions:
+ *
+ * 1. The origin of this source code must not be misrepresented.
+ *
+ * 2. Altered versions must be plainly marked as such and
+ * must not be misrepresented as being the original source.
+ *
+ * 3. This Copyright notice may not be removed or altered from
+ * any source or altered source distribution.
+ *
+ * The Contributing Authors and Group 42, Inc. specifically permit, without
+ * fee, and encourage the use of this source code as a component to
+ * supporting the PNG file format in commercial products. If you use this
+ * source code in a product, acknowledgment is not required but would be
+ * appreciated.
+ */
+
+/*
+ * A "png_get_copyright" function is available, for convenient use in "about"
+ * boxes and the like:
+ *
+ * printf("%s",png_get_copyright(NULL));
+ *
+ * Also, the PNG logo (in PNG format, of course) is supplied in the
+ * files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31).
+ */
+
+/*
+ * Libpng is OSI Certified Open Source Software. OSI Certified is a
+ * certification mark of the Open Source Initiative.
+ */
+
+/*
+ * The contributing authors would like to thank all those who helped
+ * with testing, bug fixes, and patience. This wouldn't have been
+ * possible without all of you.
+ *
+ * Thanks to Frank J. T. Wojcik for helping with the documentation.
+ */
+
+/*
+ * Y2K compliance in libpng:
+ * =========================
+ *
+ * October 31, 2008
+ *
+ * Since the PNG Development group is an ad-hoc body, we can't make
+ * an official declaration.
+ *
+ * This is your unofficial assurance that libpng from version 0.71 and
+ * upward through 1.2.33 are Y2K compliant. It is my belief that earlier
+ * versions were also Y2K compliant.
+ *
+ * Libpng only has three year fields. One is a 2-byte unsigned integer
+ * that will hold years up to 65535. The other two hold the date in text
+ * format, and will hold years up to 9999.
+ *
+ * The integer is
+ * "png_uint_16 year" in png_time_struct.
+ *
+ * The strings are
+ * "png_charp time_buffer" in png_struct and
+ * "near_time_buffer", which is a local character string in png.c.
+ *
+ * There are seven time-related functions:
+ * png.c: png_convert_to_rfc_1123() in png.c
+ * (formerly png_convert_to_rfc_1152() in error)
+ * png_convert_from_struct_tm() in pngwrite.c, called in pngwrite.c
+ * png_convert_from_time_t() in pngwrite.c
+ * png_get_tIME() in pngget.c
+ * png_handle_tIME() in pngrutil.c, called in pngread.c
+ * png_set_tIME() in pngset.c
+ * png_write_tIME() in pngwutil.c, called in pngwrite.c
+ *
+ * All handle dates properly in a Y2K environment. The
+ * png_convert_from_time_t() function calls gmtime() to convert from system
+ * clock time, which returns (year - 1900), which we properly convert to
+ * the full 4-digit year. There is a possibility that applications using
+ * libpng are not passing 4-digit years into the png_convert_to_rfc_1123()
+ * function, or that they are incorrectly passing only a 2-digit year
+ * instead of "year - 1900" into the png_convert_from_struct_tm() function,
+ * but this is not under our control. The libpng documentation has always
+ * stated that it works with 4-digit years, and the APIs have been
+ * documented as such.
+ *
+ * The tIME chunk itself is also Y2K compliant. It uses a 2-byte unsigned
+ * integer to hold the year, and can hold years as large as 65535.
+ *
+ * zlib, upon which libpng depends, is also Y2K compliant. It contains
+ * no date-related code.
+ *
+ * Glenn Randers-Pehrson
+ * libpng maintainer
+ * PNG Development Group
+ */
+
+#ifndef PNG_H
+#define PNG_H
+
+/* This is not the place to learn how to use libpng. The file libpng.txt
+ * describes how to use libpng, and the file example.c summarizes it
+ * with some code on which to build. This file is useful for looking
+ * at the actual function definitions and structure components.
+ */
+
+/* Version information for png.h - this should match the version in png.c */
+#define PNG_LIBPNG_VER_STRING "1.2.33"
+#define PNG_HEADER_VERSION_STRING \
+ " libpng version 1.2.33 - October 31, 2008\n"
+
+#define PNG_LIBPNG_VER_SONUM 0
+#define PNG_LIBPNG_VER_DLLNUM 13
+
+/* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */
+#define PNG_LIBPNG_VER_MAJOR 1
+#define PNG_LIBPNG_VER_MINOR 2
+#define PNG_LIBPNG_VER_RELEASE 33
+/* This should match the numeric part of the final component of
+ * PNG_LIBPNG_VER_STRING, omitting any leading zero: */
+
+#define PNG_LIBPNG_VER_BUILD 0
+
+/* Release Status */
+#define PNG_LIBPNG_BUILD_ALPHA 1
+#define PNG_LIBPNG_BUILD_BETA 2
+#define PNG_LIBPNG_BUILD_RC 3
+#define PNG_LIBPNG_BUILD_STABLE 4
+#define PNG_LIBPNG_BUILD_RELEASE_STATUS_MASK 7
+
+/* Release-Specific Flags */
+#define PNG_LIBPNG_BUILD_PATCH 8 /* Can be OR'ed with
+ PNG_LIBPNG_BUILD_STABLE only */
+#define PNG_LIBPNG_BUILD_PRIVATE 16 /* Cannot be OR'ed with
+ PNG_LIBPNG_BUILD_SPECIAL */
+#define PNG_LIBPNG_BUILD_SPECIAL 32 /* Cannot be OR'ed with
+ PNG_LIBPNG_BUILD_PRIVATE */
+
+#define PNG_LIBPNG_BUILD_BASE_TYPE PNG_LIBPNG_BUILD_STABLE
+
+/* Careful here. At one time, Guy wanted to use 082, but that would be octal.
+ * We must not include leading zeros.
+ * Versions 0.7 through 1.0.0 were in the range 0 to 100 here (only
+ * version 1.0.0 was mis-numbered 100 instead of 10000). From
+ * version 1.0.1 it's xxyyzz, where x=major, y=minor, z=release */
+#define PNG_LIBPNG_VER 10233 /* 1.2.33 */
+
+#ifndef PNG_VERSION_INFO_ONLY
+/* include the compression library's header */
+#include "zlib.h"
+#endif
+
+/* include all user configurable info, including optional assembler routines */
+#include "pngconf.h"
+
+/*
+ * Added at libpng-1.2.8 */
+/* Ref MSDN: Private as priority over Special
+ * VS_FF_PRIVATEBUILD File *was not* built using standard release
+ * procedures. If this value is given, the StringFileInfo block must
+ * contain a PrivateBuild string.
+ *
+ * VS_FF_SPECIALBUILD File *was* built by the original company using
+ * standard release procedures but is a variation of the standard
+ * file of the same version number. If this value is given, the
+ * StringFileInfo block must contain a SpecialBuild string.
+ */
+
+#if defined(PNG_USER_PRIVATEBUILD)
+# define PNG_LIBPNG_BUILD_TYPE \
+ (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_PRIVATE)
+#else
+# if defined(PNG_LIBPNG_SPECIALBUILD)
+# define PNG_LIBPNG_BUILD_TYPE \
+ (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_SPECIAL)
+# else
+# define PNG_LIBPNG_BUILD_TYPE (PNG_LIBPNG_BUILD_BASE_TYPE)
+# endif
+#endif
+
+#ifndef PNG_VERSION_INFO_ONLY
+
+/* Inhibit C++ name-mangling for libpng functions but not for system calls. */
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/* This file is arranged in several sections. The first section contains
+ * structure and type definitions. The second section contains the external
+ * library functions, while the third has the internal library functions,
+ * which applications aren't expected to use directly.
+ */
+
+#ifndef PNG_NO_TYPECAST_NULL
+#define int_p_NULL (int *)NULL
+#define png_bytep_NULL (png_bytep)NULL
+#define png_bytepp_NULL (png_bytepp)NULL
+#define png_doublep_NULL (png_doublep)NULL
+#define png_error_ptr_NULL (png_error_ptr)NULL
+#define png_flush_ptr_NULL (png_flush_ptr)NULL
+#define png_free_ptr_NULL (png_free_ptr)NULL
+#define png_infopp_NULL (png_infopp)NULL
+#define png_malloc_ptr_NULL (png_malloc_ptr)NULL
+#define png_read_status_ptr_NULL (png_read_status_ptr)NULL
+#define png_rw_ptr_NULL (png_rw_ptr)NULL
+#define png_structp_NULL (png_structp)NULL
+#define png_uint_16p_NULL (png_uint_16p)NULL
+#define png_voidp_NULL (png_voidp)NULL
+#define png_write_status_ptr_NULL (png_write_status_ptr)NULL
+#else
+#define int_p_NULL NULL
+#define png_bytep_NULL NULL
+#define png_bytepp_NULL NULL
+#define png_doublep_NULL NULL
+#define png_error_ptr_NULL NULL
+#define png_flush_ptr_NULL NULL
+#define png_free_ptr_NULL NULL
+#define png_infopp_NULL NULL
+#define png_malloc_ptr_NULL NULL
+#define png_read_status_ptr_NULL NULL
+#define png_rw_ptr_NULL NULL
+#define png_structp_NULL NULL
+#define png_uint_16p_NULL NULL
+#define png_voidp_NULL NULL
+#define png_write_status_ptr_NULL NULL
+#endif
+
+/* variables declared in png.c - only it needs to define PNG_NO_EXTERN */
+#if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN)
+/* Version information for C files, stored in png.c. This had better match
+ * the version above.
+ */
+#ifdef PNG_USE_GLOBAL_ARRAYS
+PNG_EXPORT_VAR (PNG_CONST char) png_libpng_ver[18];
+ /* need room for 99.99.99beta99z */
+#else
+#define png_libpng_ver png_get_header_ver(NULL)
+#endif
+
+#ifdef PNG_USE_GLOBAL_ARRAYS
+/* This was removed in version 1.0.5c */
+/* Structures to facilitate easy interlacing. See png.c for more details */
+PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_start[7];
+PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_inc[7];
+PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_ystart[7];
+PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_yinc[7];
+PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_mask[7];
+PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_dsp_mask[7];
+/* This isn't currently used. If you need it, see png.c for more details.
+PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_height[7];
+*/
+#endif
+
+#endif /* PNG_NO_EXTERN */
+
+/* Three color definitions. The order of the red, green, and blue, (and the
+ * exact size) is not important, although the size of the fields need to
+ * be png_byte or png_uint_16 (as defined below).
+ */
+typedef struct png_color_struct
+{
+ png_byte red;
+ png_byte green;
+ png_byte blue;
+} png_color;
+typedef png_color FAR * png_colorp;
+typedef png_color FAR * FAR * png_colorpp;
+
+typedef struct png_color_16_struct
+{
+ png_byte index; /* used for palette files */
+ png_uint_16 red; /* for use in red green blue files */
+ png_uint_16 green;
+ png_uint_16 blue;
+ png_uint_16 gray; /* for use in grayscale files */
+} png_color_16;
+typedef png_color_16 FAR * png_color_16p;
+typedef png_color_16 FAR * FAR * png_color_16pp;
+
+typedef struct png_color_8_struct
+{
+ png_byte red; /* for use in red green blue files */
+ png_byte green;
+ png_byte blue;
+ png_byte gray; /* for use in grayscale files */
+ png_byte alpha; /* for alpha channel files */
+} png_color_8;
+typedef png_color_8 FAR * png_color_8p;
+typedef png_color_8 FAR * FAR * png_color_8pp;
+
+/*
+ * The following two structures are used for the in-core representation
+ * of sPLT chunks.
+ */
+typedef struct png_sPLT_entry_struct
+{
+ png_uint_16 red;
+ png_uint_16 green;
+ png_uint_16 blue;
+ png_uint_16 alpha;
+ png_uint_16 frequency;
+} png_sPLT_entry;
+typedef png_sPLT_entry FAR * png_sPLT_entryp;
+typedef png_sPLT_entry FAR * FAR * png_sPLT_entrypp;
+
+/* When the depth of the sPLT palette is 8 bits, the color and alpha samples
+ * occupy the LSB of their respective members, and the MSB of each member
+ * is zero-filled. The frequency member always occupies the full 16 bits.
+ */
+
+typedef struct png_sPLT_struct
+{
+ png_charp name; /* palette name */
+ png_byte depth; /* depth of palette samples */
+ png_sPLT_entryp entries; /* palette entries */
+ png_int_32 nentries; /* number of palette entries */
+} png_sPLT_t;
+typedef png_sPLT_t FAR * png_sPLT_tp;
+typedef png_sPLT_t FAR * FAR * png_sPLT_tpp;
+
+#ifdef PNG_TEXT_SUPPORTED
+/* png_text holds the contents of a text/ztxt/itxt chunk in a PNG file,
+ * and whether that contents is compressed or not. The "key" field
+ * points to a regular zero-terminated C string. The "text", "lang", and
+ * "lang_key" fields can be regular C strings, empty strings, or NULL pointers.
+ * However, the * structure returned by png_get_text() will always contain
+ * regular zero-terminated C strings (possibly empty), never NULL pointers,
+ * so they can be safely used in printf() and other string-handling functions.
+ */
+typedef struct png_text_struct
+{
+ int compression; /* compression value:
+ -1: tEXt, none
+ 0: zTXt, deflate
+ 1: iTXt, none
+ 2: iTXt, deflate */
+ png_charp key; /* keyword, 1-79 character description of "text" */
+ png_charp text; /* comment, may be an empty string (ie "")
+ or a NULL pointer */
+ png_size_t text_length; /* length of the text string */
+#ifdef PNG_iTXt_SUPPORTED
+ png_size_t itxt_length; /* length of the itxt string */
+ png_charp lang; /* language code, 0-79 characters
+ or a NULL pointer */
+ png_charp lang_key; /* keyword translated UTF-8 string, 0 or more
+ chars or a NULL pointer */
+#endif
+} png_text;
+typedef png_text FAR * png_textp;
+typedef png_text FAR * FAR * png_textpp;
+#endif
+
+/* Supported compression types for text in PNG files (tEXt, and zTXt).
+ * The values of the PNG_TEXT_COMPRESSION_ defines should NOT be changed. */
+#define PNG_TEXT_COMPRESSION_NONE_WR -3
+#define PNG_TEXT_COMPRESSION_zTXt_WR -2
+#define PNG_TEXT_COMPRESSION_NONE -1
+#define PNG_TEXT_COMPRESSION_zTXt 0
+#define PNG_ITXT_COMPRESSION_NONE 1
+#define PNG_ITXT_COMPRESSION_zTXt 2
+#define PNG_TEXT_COMPRESSION_LAST 3 /* Not a valid value */
+
+/* png_time is a way to hold the time in an machine independent way.
+ * Two conversions are provided, both from time_t and struct tm. There
+ * is no portable way to convert to either of these structures, as far
+ * as I know. If you know of a portable way, send it to me. As a side
+ * note - PNG has always been Year 2000 compliant!
+ */
+typedef struct png_time_struct
+{
+ png_uint_16 year; /* full year, as in, 1995 */
+ png_byte month; /* month of year, 1 - 12 */
+ png_byte day; /* day of month, 1 - 31 */
+ png_byte hour; /* hour of day, 0 - 23 */
+ png_byte minute; /* minute of hour, 0 - 59 */
+ png_byte second; /* second of minute, 0 - 60 (for leap seconds) */
+} png_time;
+typedef png_time FAR * png_timep;
+typedef png_time FAR * FAR * png_timepp;
+
+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
+/* png_unknown_chunk is a structure to hold queued chunks for which there is
+ * no specific support. The idea is that we can use this to queue
+ * up private chunks for output even though the library doesn't actually
+ * know about their semantics.
+ */
+#define PNG_CHUNK_NAME_LENGTH 5
+typedef struct png_unknown_chunk_t
+{
+ png_byte name[PNG_CHUNK_NAME_LENGTH];
+ png_byte *data;
+ png_size_t size;
+
+ /* libpng-using applications should NOT directly modify this byte. */
+ png_byte location; /* mode of operation at read time */
+}
+png_unknown_chunk;
+typedef png_unknown_chunk FAR * png_unknown_chunkp;
+typedef png_unknown_chunk FAR * FAR * png_unknown_chunkpp;
+#endif
+
+/* png_info is a structure that holds the information in a PNG file so
+ * that the application can find out the characteristics of the image.
+ * If you are reading the file, this structure will tell you what is
+ * in the PNG file. If you are writing the file, fill in the information
+ * you want to put into the PNG file, then call png_write_info().
+ * The names chosen should be very close to the PNG specification, so
+ * consult that document for information about the meaning of each field.
+ *
+ * With libpng < 0.95, it was only possible to directly set and read the
+ * the values in the png_info_struct, which meant that the contents and
+ * order of the values had to remain fixed. With libpng 0.95 and later,
+ * however, there are now functions that abstract the contents of
+ * png_info_struct from the application, so this makes it easier to use
+ * libpng with dynamic libraries, and even makes it possible to use
+ * libraries that don't have all of the libpng ancillary chunk-handing
+ * functionality.
+ *
+ * In any case, the order of the parameters in png_info_struct should NOT
+ * be changed for as long as possible to keep compatibility with applications
+ * that use the old direct-access method with png_info_struct.
+ *
+ * The following members may have allocated storage attached that should be
+ * cleaned up before the structure is discarded: palette, trans, text,
+ * pcal_purpose, pcal_units, pcal_params, hist, iccp_name, iccp_profile,
+ * splt_palettes, scal_unit, row_pointers, and unknowns. By default, these
+ * are automatically freed when the info structure is deallocated, if they were
+ * allocated internally by libpng. This behavior can be changed by means
+ * of the png_data_freer() function.
+ *
+ * More allocation details: all the chunk-reading functions that
+ * change these members go through the corresponding png_set_*
+ * functions. A function to clear these members is available: see
+ * png_free_data(). The png_set_* functions do not depend on being
+ * able to point info structure members to any of the storage they are
+ * passed (they make their own copies), EXCEPT that the png_set_text
+ * functions use the same storage passed to them in the text_ptr or
+ * itxt_ptr structure argument, and the png_set_rows and png_set_unknowns
+ * functions do not make their own copies.
+ */
+typedef struct png_info_struct
+{
+ /* the following are necessary for every PNG file */
+ png_uint_32 width; /* width of image in pixels (from IHDR) */
+ png_uint_32 height; /* height of image in pixels (from IHDR) */
+ png_uint_32 valid; /* valid chunk data (see PNG_INFO_ below) */
+ png_uint_32 rowbytes; /* bytes needed to hold an untransformed row */
+ png_colorp palette; /* array of color values (valid & PNG_INFO_PLTE) */
+ png_uint_16 num_palette; /* number of color entries in "palette" (PLTE) */
+ png_uint_16 num_trans; /* number of transparent palette color (tRNS) */
+ png_byte bit_depth; /* 1, 2, 4, 8, or 16 bits/channel (from IHDR) */
+ png_byte color_type; /* see PNG_COLOR_TYPE_ below (from IHDR) */
+ /* The following three should have been named *_method not *_type */
+ png_byte compression_type; /* must be PNG_COMPRESSION_TYPE_BASE (IHDR) */
+ png_byte filter_type; /* must be PNG_FILTER_TYPE_BASE (from IHDR) */
+ png_byte interlace_type; /* One of PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */
+
+ /* The following is informational only on read, and not used on writes. */
+ png_byte channels; /* number of data channels per pixel (1, 2, 3, 4) */
+ png_byte pixel_depth; /* number of bits per pixel */
+ png_byte spare_byte; /* to align the data, and for future use */
+ png_byte signature[8]; /* magic bytes read by libpng from start of file */
+
+ /* The rest of the data is optional. If you are reading, check the
+ * valid field to see if the information in these are valid. If you
+ * are writing, set the valid field to those chunks you want written,
+ * and initialize the appropriate fields below.
+ */
+
+#if defined(PNG_gAMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)
+ /* The gAMA chunk describes the gamma characteristics of the system
+ * on which the image was created, normally in the range [1.0, 2.5].
+ * Data is valid if (valid & PNG_INFO_gAMA) is non-zero.
+ */
+ float gamma; /* gamma value of image, if (valid & PNG_INFO_gAMA) */
+#endif
+
+#if defined(PNG_sRGB_SUPPORTED)
+ /* GR-P, 0.96a */
+ /* Data valid if (valid & PNG_INFO_sRGB) non-zero. */
+ png_byte srgb_intent; /* sRGB rendering intent [0, 1, 2, or 3] */
+#endif
+
+#if defined(PNG_TEXT_SUPPORTED)
+ /* The tEXt, and zTXt chunks contain human-readable textual data in
+ * uncompressed, compressed, and optionally compressed forms, respectively.
+ * The data in "text" is an array of pointers to uncompressed,
+ * null-terminated C strings. Each chunk has a keyword that describes the
+ * textual data contained in that chunk. Keywords are not required to be
+ * unique, and the text string may be empty. Any number of text chunks may
+ * be in an image.
+ */
+ int num_text; /* number of comments read/to write */
+ int max_text; /* current size of text array */
+ png_textp text; /* array of comments read/to write */
+#endif /* PNG_TEXT_SUPPORTED */
+
+#if defined(PNG_tIME_SUPPORTED)
+ /* The tIME chunk holds the last time the displayed image data was
+ * modified. See the png_time struct for the contents of this struct.
+ */
+ png_time mod_time;
+#endif
+
+#if defined(PNG_sBIT_SUPPORTED)
+ /* The sBIT chunk specifies the number of significant high-order bits
+ * in the pixel data. Values are in the range [1, bit_depth], and are
+ * only specified for the channels in the pixel data. The contents of
+ * the low-order bits is not specified. Data is valid if
+ * (valid & PNG_INFO_sBIT) is non-zero.
+ */
+ png_color_8 sig_bit; /* significant bits in color channels */
+#endif
+
+#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_EXPAND_SUPPORTED) || \
+defined(PNG_READ_BACKGROUND_SUPPORTED)
+ /* The tRNS chunk supplies transparency data for paletted images and
+ * other image types that don't need a full alpha channel. There are
+ * "num_trans" transparency values for a paletted image, stored in the
+ * same order as the palette colors, starting from index 0. Values
+ * for the data are in the range [0, 255], ranging from fully transparent
+ * to fully opaque, respectively. For non-paletted images, there is a
+ * single color specified that should be treated as fully transparent.
+ * Data is valid if (valid & PNG_INFO_tRNS) is non-zero.
+ */
+ png_bytep trans; /* transparent values for paletted image */
+ png_color_16 trans_values; /* transparent color for non-palette image */
+#endif
+
+#if defined(PNG_bKGD_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+ /* The bKGD chunk gives the suggested image background color if the
+ * display program does not have its own background color and the image
+ * is needs to composited onto a background before display. The colors
+ * in "background" are normally in the same color space/depth as the
+ * pixel data. Data is valid if (valid & PNG_INFO_bKGD) is non-zero.
+ */
+ png_color_16 background;
+#endif
+
+#if defined(PNG_oFFs_SUPPORTED)
+ /* The oFFs chunk gives the offset in "offset_unit_type" units rightwards
+ * and downwards from the top-left corner of the display, page, or other
+ * application-specific co-ordinate space. See the PNG_OFFSET_ defines
+ * below for the unit types. Valid if (valid & PNG_INFO_oFFs) non-zero.
+ */
+ png_int_32 x_offset; /* x offset on page */
+ png_int_32 y_offset; /* y offset on page */
+ png_byte offset_unit_type; /* offset units type */
+#endif
+
+#if defined(PNG_pHYs_SUPPORTED)
+ /* The pHYs chunk gives the physical pixel density of the image for
+ * display or printing in "phys_unit_type" units (see PNG_RESOLUTION_
+ * defines below). Data is valid if (valid & PNG_INFO_pHYs) is non-zero.
+ */
+ png_uint_32 x_pixels_per_unit; /* horizontal pixel density */
+ png_uint_32 y_pixels_per_unit; /* vertical pixel density */
+ png_byte phys_unit_type; /* resolution type (see PNG_RESOLUTION_ below) */
+#endif
+
+#if defined(PNG_hIST_SUPPORTED)
+ /* The hIST chunk contains the relative frequency or importance of the
+ * various palette entries, so that a viewer can intelligently select a
+ * reduced-color palette, if required. Data is an array of "num_palette"
+ * values in the range [0,65535]. Data valid if (valid & PNG_INFO_hIST)
+ * is non-zero.
+ */
+ png_uint_16p hist;
+#endif
+
+#ifdef PNG_cHRM_SUPPORTED
+ /* The cHRM chunk describes the CIE color characteristics of the monitor
+ * on which the PNG was created. This data allows the viewer to do gamut
+ * mapping of the input image to ensure that the viewer sees the same
+ * colors in the image as the creator. Values are in the range
+ * [0.0, 0.8]. Data valid if (valid & PNG_INFO_cHRM) non-zero.
+ */
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+ float x_white;
+ float y_white;
+ float x_red;
+ float y_red;
+ float x_green;
+ float y_green;
+ float x_blue;
+ float y_blue;
+#endif
+#endif
+
+#if defined(PNG_pCAL_SUPPORTED)
+ /* The pCAL chunk describes a transformation between the stored pixel
+ * values and original physical data values used to create the image.
+ * The integer range [0, 2^bit_depth - 1] maps to the floating-point
+ * range given by [pcal_X0, pcal_X1], and are further transformed by a
+ * (possibly non-linear) transformation function given by "pcal_type"
+ * and "pcal_params" into "pcal_units". Please see the PNG_EQUATION_
+ * defines below, and the PNG-Group's PNG extensions document for a
+ * complete description of the transformations and how they should be
+ * implemented, and for a description of the ASCII parameter strings.
+ * Data values are valid if (valid & PNG_INFO_pCAL) non-zero.
+ */
+ png_charp pcal_purpose; /* pCAL chunk description string */
+ png_int_32 pcal_X0; /* minimum value */
+ png_int_32 pcal_X1; /* maximum value */
+ png_charp pcal_units; /* Latin-1 string giving physical units */
+ png_charpp pcal_params; /* ASCII strings containing parameter values */
+ png_byte pcal_type; /* equation type (see PNG_EQUATION_ below) */
+ png_byte pcal_nparams; /* number of parameters given in pcal_params */
+#endif
+
+/* New members added in libpng-1.0.6 */
+#ifdef PNG_FREE_ME_SUPPORTED
+ png_uint_32 free_me; /* flags items libpng is responsible for freeing */
+#endif
+
+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
+ /* storage for unknown chunks that the library doesn't recognize. */
+ png_unknown_chunkp unknown_chunks;
+ png_size_t unknown_chunks_num;
+#endif
+
+#if defined(PNG_iCCP_SUPPORTED)
+ /* iCCP chunk data. */
+ png_charp iccp_name; /* profile name */
+ png_charp iccp_profile; /* International Color Consortium profile data */
+ /* Note to maintainer: should be png_bytep */
+ png_uint_32 iccp_proflen; /* ICC profile data length */
+ png_byte iccp_compression; /* Always zero */
+#endif
+
+#if defined(PNG_sPLT_SUPPORTED)
+ /* data on sPLT chunks (there may be more than one). */
+ png_sPLT_tp splt_palettes;
+ png_uint_32 splt_palettes_num;
+#endif
+
+#if defined(PNG_sCAL_SUPPORTED)
+ /* The sCAL chunk describes the actual physical dimensions of the
+ * subject matter of the graphic. The chunk contains a unit specification
+ * a byte value, and two ASCII strings representing floating-point
+ * values. The values are width and height corresponsing to one pixel
+ * in the image. This external representation is converted to double
+ * here. Data values are valid if (valid & PNG_INFO_sCAL) is non-zero.
+ */
+ png_byte scal_unit; /* unit of physical scale */
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+ double scal_pixel_width; /* width of one pixel */
+ double scal_pixel_height; /* height of one pixel */
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+ png_charp scal_s_width; /* string containing height */
+ png_charp scal_s_height; /* string containing width */
+#endif
+#endif
+
+#if defined(PNG_INFO_IMAGE_SUPPORTED)
+ /* Memory has been allocated if (valid & PNG_ALLOCATED_INFO_ROWS) non-zero */
+ /* Data valid if (valid & PNG_INFO_IDAT) non-zero */
+ png_bytepp row_pointers; /* the image bits */
+#endif
+
+#if defined(PNG_FIXED_POINT_SUPPORTED) && defined(PNG_gAMA_SUPPORTED)
+ png_fixed_point int_gamma; /* gamma of image, if (valid & PNG_INFO_gAMA) */
+#endif
+
+#if defined(PNG_cHRM_SUPPORTED) && defined(PNG_FIXED_POINT_SUPPORTED)
+ png_fixed_point int_x_white;
+ png_fixed_point int_y_white;
+ png_fixed_point int_x_red;
+ png_fixed_point int_y_red;
+ png_fixed_point int_x_green;
+ png_fixed_point int_y_green;
+ png_fixed_point int_x_blue;
+ png_fixed_point int_y_blue;
+#endif
+
+} png_info;
+
+typedef png_info FAR * png_infop;
+typedef png_info FAR * FAR * png_infopp;
+
+/* Maximum positive integer used in PNG is (2^31)-1 */
+#define PNG_UINT_31_MAX ((png_uint_32)0x7fffffffL)
+#define PNG_UINT_32_MAX ((png_uint_32)(-1))
+#define PNG_SIZE_MAX ((png_size_t)(-1))
+#if defined(PNG_1_0_X) || defined (PNG_1_2_X)
+/* PNG_MAX_UINT is deprecated; use PNG_UINT_31_MAX instead. */
+#define PNG_MAX_UINT PNG_UINT_31_MAX
+#endif
+
+/* These describe the color_type field in png_info. */
+/* color type masks */
+#define PNG_COLOR_MASK_PALETTE 1
+#define PNG_COLOR_MASK_COLOR 2
+#define PNG_COLOR_MASK_ALPHA 4
+
+/* color types. Note that not all combinations are legal */
+#define PNG_COLOR_TYPE_GRAY 0
+#define PNG_COLOR_TYPE_PALETTE (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE)
+#define PNG_COLOR_TYPE_RGB (PNG_COLOR_MASK_COLOR)
+#define PNG_COLOR_TYPE_RGB_ALPHA (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA)
+#define PNG_COLOR_TYPE_GRAY_ALPHA (PNG_COLOR_MASK_ALPHA)
+/* aliases */
+#define PNG_COLOR_TYPE_RGBA PNG_COLOR_TYPE_RGB_ALPHA
+#define PNG_COLOR_TYPE_GA PNG_COLOR_TYPE_GRAY_ALPHA
+
+/* This is for compression type. PNG 1.0-1.2 only define the single type. */
+#define PNG_COMPRESSION_TYPE_BASE 0 /* Deflate method 8, 32K window */
+#define PNG_COMPRESSION_TYPE_DEFAULT PNG_COMPRESSION_TYPE_BASE
+
+/* This is for filter type. PNG 1.0-1.2 only define the single type. */
+#define PNG_FILTER_TYPE_BASE 0 /* Single row per-byte filtering */
+#define PNG_INTRAPIXEL_DIFFERENCING 64 /* Used only in MNG datastreams */
+#define PNG_FILTER_TYPE_DEFAULT PNG_FILTER_TYPE_BASE
+
+/* These are for the interlacing type. These values should NOT be changed. */
+#define PNG_INTERLACE_NONE 0 /* Non-interlaced image */
+#define PNG_INTERLACE_ADAM7 1 /* Adam7 interlacing */
+#define PNG_INTERLACE_LAST 2 /* Not a valid value */
+
+/* These are for the oFFs chunk. These values should NOT be changed. */
+#define PNG_OFFSET_PIXEL 0 /* Offset in pixels */
+#define PNG_OFFSET_MICROMETER 1 /* Offset in micrometers (1/10^6 meter) */
+#define PNG_OFFSET_LAST 2 /* Not a valid value */
+
+/* These are for the pCAL chunk. These values should NOT be changed. */
+#define PNG_EQUATION_LINEAR 0 /* Linear transformation */
+#define PNG_EQUATION_BASE_E 1 /* Exponential base e transform */
+#define PNG_EQUATION_ARBITRARY 2 /* Arbitrary base exponential transform */
+#define PNG_EQUATION_HYPERBOLIC 3 /* Hyperbolic sine transformation */
+#define PNG_EQUATION_LAST 4 /* Not a valid value */
+
+/* These are for the sCAL chunk. These values should NOT be changed. */
+#define PNG_SCALE_UNKNOWN 0 /* unknown unit (image scale) */
+#define PNG_SCALE_METER 1 /* meters per pixel */
+#define PNG_SCALE_RADIAN 2 /* radians per pixel */
+#define PNG_SCALE_LAST 3 /* Not a valid value */
+
+/* These are for the pHYs chunk. These values should NOT be changed. */
+#define PNG_RESOLUTION_UNKNOWN 0 /* pixels/unknown unit (aspect ratio) */
+#define PNG_RESOLUTION_METER 1 /* pixels/meter */
+#define PNG_RESOLUTION_LAST 2 /* Not a valid value */
+
+/* These are for the sRGB chunk. These values should NOT be changed. */
+#define PNG_sRGB_INTENT_PERCEPTUAL 0
+#define PNG_sRGB_INTENT_RELATIVE 1
+#define PNG_sRGB_INTENT_SATURATION 2
+#define PNG_sRGB_INTENT_ABSOLUTE 3
+#define PNG_sRGB_INTENT_LAST 4 /* Not a valid value */
+
+/* This is for text chunks */
+#define PNG_KEYWORD_MAX_LENGTH 79
+
+/* Maximum number of entries in PLTE/sPLT/tRNS arrays */
+#define PNG_MAX_PALETTE_LENGTH 256
+
+/* These determine if an ancillary chunk's data has been successfully read
+ * from the PNG header, or if the application has filled in the corresponding
+ * data in the info_struct to be written into the output file. The values
+ * of the PNG_INFO_<chunk> defines should NOT be changed.
+ */
+#define PNG_INFO_gAMA 0x0001
+#define PNG_INFO_sBIT 0x0002
+#define PNG_INFO_cHRM 0x0004
+#define PNG_INFO_PLTE 0x0008
+#define PNG_INFO_tRNS 0x0010
+#define PNG_INFO_bKGD 0x0020
+#define PNG_INFO_hIST 0x0040
+#define PNG_INFO_pHYs 0x0080
+#define PNG_INFO_oFFs 0x0100
+#define PNG_INFO_tIME 0x0200
+#define PNG_INFO_pCAL 0x0400
+#define PNG_INFO_sRGB 0x0800 /* GR-P, 0.96a */
+#define PNG_INFO_iCCP 0x1000 /* ESR, 1.0.6 */
+#define PNG_INFO_sPLT 0x2000 /* ESR, 1.0.6 */
+#define PNG_INFO_sCAL 0x4000 /* ESR, 1.0.6 */
+#define PNG_INFO_IDAT 0x8000L /* ESR, 1.0.6 */
+
+/* This is used for the transformation routines, as some of them
+ * change these values for the row. It also should enable using
+ * the routines for other purposes.
+ */
+typedef struct png_row_info_struct
+{
+ png_uint_32 width; /* width of row */
+ png_uint_32 rowbytes; /* number of bytes in row */
+ png_byte color_type; /* color type of row */
+ png_byte bit_depth; /* bit depth of row */
+ png_byte channels; /* number of channels (1, 2, 3, or 4) */
+ png_byte pixel_depth; /* bits per pixel (depth * channels) */
+} png_row_info;
+
+typedef png_row_info FAR * png_row_infop;
+typedef png_row_info FAR * FAR * png_row_infopp;
+
+/* These are the function types for the I/O functions and for the functions
+ * that allow the user to override the default I/O functions with his or her
+ * own. The png_error_ptr type should match that of user-supplied warning
+ * and error functions, while the png_rw_ptr type should match that of the
+ * user read/write data functions.
+ */
+typedef struct png_struct_def png_struct;
+typedef png_struct FAR * png_structp;
+
+typedef void (PNGAPI *png_error_ptr) PNGARG((png_structp, png_const_charp));
+typedef void (PNGAPI *png_rw_ptr) PNGARG((png_structp, png_bytep, png_size_t));
+typedef void (PNGAPI *png_flush_ptr) PNGARG((png_structp));
+typedef void (PNGAPI *png_read_status_ptr) PNGARG((png_structp, png_uint_32,
+ int));
+typedef void (PNGAPI *png_write_status_ptr) PNGARG((png_structp, png_uint_32,
+ int));
+
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
+typedef void (PNGAPI *png_progressive_info_ptr) PNGARG((png_structp, png_infop));
+typedef void (PNGAPI *png_progressive_end_ptr) PNGARG((png_structp, png_infop));
+typedef void (PNGAPI *png_progressive_row_ptr) PNGARG((png_structp, png_bytep,
+ png_uint_32, int));
+#endif
+
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
+ defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \
+ defined(PNG_LEGACY_SUPPORTED)
+typedef void (PNGAPI *png_user_transform_ptr) PNGARG((png_structp,
+ png_row_infop, png_bytep));
+#endif
+
+#if defined(PNG_USER_CHUNKS_SUPPORTED)
+typedef int (PNGAPI *png_user_chunk_ptr) PNGARG((png_structp, png_unknown_chunkp));
+#endif
+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
+typedef void (PNGAPI *png_unknown_chunk_ptr) PNGARG((png_structp));
+#endif
+
+/* Transform masks for the high-level interface */
+#define PNG_TRANSFORM_IDENTITY 0x0000 /* read and write */
+#define PNG_TRANSFORM_STRIP_16 0x0001 /* read only */
+#define PNG_TRANSFORM_STRIP_ALPHA 0x0002 /* read only */
+#define PNG_TRANSFORM_PACKING 0x0004 /* read and write */
+#define PNG_TRANSFORM_PACKSWAP 0x0008 /* read and write */
+#define PNG_TRANSFORM_EXPAND 0x0010 /* read only */
+#define PNG_TRANSFORM_INVERT_MONO 0x0020 /* read and write */
+#define PNG_TRANSFORM_SHIFT 0x0040 /* read and write */
+#define PNG_TRANSFORM_BGR 0x0080 /* read and write */
+#define PNG_TRANSFORM_SWAP_ALPHA 0x0100 /* read and write */
+#define PNG_TRANSFORM_SWAP_ENDIAN 0x0200 /* read and write */
+#define PNG_TRANSFORM_INVERT_ALPHA 0x0400 /* read and write */
+#define PNG_TRANSFORM_STRIP_FILLER 0x0800 /* WRITE only */
+
+/* Flags for MNG supported features */
+#define PNG_FLAG_MNG_EMPTY_PLTE 0x01
+#define PNG_FLAG_MNG_FILTER_64 0x04
+#define PNG_ALL_MNG_FEATURES 0x05
+
+typedef png_voidp (*png_malloc_ptr) PNGARG((png_structp, png_size_t));
+typedef void (*png_free_ptr) PNGARG((png_structp, png_voidp));
+
+/* The structure that holds the information to read and write PNG files.
+ * The only people who need to care about what is inside of this are the
+ * people who will be modifying the library for their own special needs.
+ * It should NOT be accessed directly by an application, except to store
+ * the jmp_buf.
+ */
+
+struct png_struct_def
+{
+#ifdef PNG_SETJMP_SUPPORTED
+ jmp_buf jmpbuf; /* used in png_error */
+#endif
+ png_error_ptr error_fn; /* function for printing errors and aborting */
+ png_error_ptr warning_fn; /* function for printing warnings */
+ png_voidp error_ptr; /* user supplied struct for error functions */
+ png_rw_ptr write_data_fn; /* function for writing output data */
+ png_rw_ptr read_data_fn; /* function for reading input data */
+ png_voidp io_ptr; /* ptr to application struct for I/O functions */
+
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
+ png_user_transform_ptr read_user_transform_fn; /* user read transform */
+#endif
+
+#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+ png_user_transform_ptr write_user_transform_fn; /* user write transform */
+#endif
+
+/* These were added in libpng-1.0.2 */
+#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
+ defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+ png_voidp user_transform_ptr; /* user supplied struct for user transform */
+ png_byte user_transform_depth; /* bit depth of user transformed pixels */
+ png_byte user_transform_channels; /* channels in user transformed pixels */
+#endif
+#endif
+
+ png_uint_32 mode; /* tells us where we are in the PNG file */
+ png_uint_32 flags; /* flags indicating various things to libpng */
+ png_uint_32 transformations; /* which transformations to perform */
+
+ z_stream zstream; /* pointer to decompression structure (below) */
+ png_bytep zbuf; /* buffer for zlib */
+ png_size_t zbuf_size; /* size of zbuf */
+ int zlib_level; /* holds zlib compression level */
+ int zlib_method; /* holds zlib compression method */
+ int zlib_window_bits; /* holds zlib compression window bits */
+ int zlib_mem_level; /* holds zlib compression memory level */
+ int zlib_strategy; /* holds zlib compression strategy */
+
+ png_uint_32 width; /* width of image in pixels */
+ png_uint_32 height; /* height of image in pixels */
+ png_uint_32 num_rows; /* number of rows in current pass */
+ png_uint_32 usr_width; /* width of row at start of write */
+ png_uint_32 rowbytes; /* size of row in bytes */
+ png_uint_32 irowbytes; /* size of current interlaced row in bytes */
+ png_uint_32 iwidth; /* width of current interlaced row in pixels */
+ png_uint_32 row_number; /* current row in interlace pass */
+ png_bytep prev_row; /* buffer to save previous (unfiltered) row */
+ png_bytep row_buf; /* buffer to save current (unfiltered) row */
+#ifndef PNG_NO_WRITE_FILTER
+ png_bytep sub_row; /* buffer to save "sub" row when filtering */
+ png_bytep up_row; /* buffer to save "up" row when filtering */
+ png_bytep avg_row; /* buffer to save "avg" row when filtering */
+ png_bytep paeth_row; /* buffer to save "Paeth" row when filtering */
+#endif
+ png_row_info row_info; /* used for transformation routines */
+
+ png_uint_32 idat_size; /* current IDAT size for read */
+ png_uint_32 crc; /* current chunk CRC value */
+ png_colorp palette; /* palette from the input file */
+ png_uint_16 num_palette; /* number of color entries in palette */
+ png_uint_16 num_trans; /* number of transparency values */
+ png_byte chunk_name[5]; /* null-terminated name of current chunk */
+ png_byte compression; /* file compression type (always 0) */
+ png_byte filter; /* file filter type (always 0) */
+ png_byte interlaced; /* PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */
+ png_byte pass; /* current interlace pass (0 - 6) */
+ png_byte do_filter; /* row filter flags (see PNG_FILTER_ below ) */
+ png_byte color_type; /* color type of file */
+ png_byte bit_depth; /* bit depth of file */
+ png_byte usr_bit_depth; /* bit depth of users row */
+ png_byte pixel_depth; /* number of bits per pixel */
+ png_byte channels; /* number of channels in file */
+ png_byte usr_channels; /* channels at start of write */
+ png_byte sig_bytes; /* magic bytes read/written from start of file */
+
+#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
+#ifdef PNG_LEGACY_SUPPORTED
+ png_byte filler; /* filler byte for pixel expansion */
+#else
+ png_uint_16 filler; /* filler bytes for pixel expansion */
+#endif
+#endif
+
+#if defined(PNG_bKGD_SUPPORTED)
+ png_byte background_gamma_type;
+# ifdef PNG_FLOATING_POINT_SUPPORTED
+ float background_gamma;
+# endif
+ png_color_16 background; /* background color in screen gamma space */
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+ png_color_16 background_1; /* background normalized to gamma 1.0 */
+#endif
+#endif /* PNG_bKGD_SUPPORTED */
+
+#if defined(PNG_WRITE_FLUSH_SUPPORTED)
+ png_flush_ptr output_flush_fn;/* Function for flushing output */
+ png_uint_32 flush_dist; /* how many rows apart to flush, 0 - no flush */
+ png_uint_32 flush_rows; /* number of rows written since last flush */
+#endif
+
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+ int gamma_shift; /* number of "insignificant" bits 16-bit gamma */
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+ float gamma; /* file gamma value */
+ float screen_gamma; /* screen gamma value (display_exponent) */
+#endif
+#endif
+
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+ png_bytep gamma_table; /* gamma table for 8-bit depth files */
+ png_bytep gamma_from_1; /* converts from 1.0 to screen */
+ png_bytep gamma_to_1; /* converts from file to 1.0 */
+ png_uint_16pp gamma_16_table; /* gamma table for 16-bit depth files */
+ png_uint_16pp gamma_16_from_1; /* converts from 1.0 to screen */
+ png_uint_16pp gamma_16_to_1; /* converts from file to 1.0 */
+#endif
+
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_sBIT_SUPPORTED)
+ png_color_8 sig_bit; /* significant bits in each available channel */
+#endif
+
+#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
+ png_color_8 shift; /* shift for significant bit tranformation */
+#endif
+
+#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) \
+ || defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+ png_bytep trans; /* transparency values for paletted files */
+ png_color_16 trans_values; /* transparency values for non-paletted files */
+#endif
+
+ png_read_status_ptr read_row_fn; /* called after each row is decoded */
+ png_write_status_ptr write_row_fn; /* called after each row is encoded */
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
+ png_progressive_info_ptr info_fn; /* called after header data fully read */
+ png_progressive_row_ptr row_fn; /* called after each prog. row is decoded */
+ png_progressive_end_ptr end_fn; /* called after image is complete */
+ png_bytep save_buffer_ptr; /* current location in save_buffer */
+ png_bytep save_buffer; /* buffer for previously read data */
+ png_bytep current_buffer_ptr; /* current location in current_buffer */
+ png_bytep current_buffer; /* buffer for recently used data */
+ png_uint_32 push_length; /* size of current input chunk */
+ png_uint_32 skip_length; /* bytes to skip in input data */
+ png_size_t save_buffer_size; /* amount of data now in save_buffer */
+ png_size_t save_buffer_max; /* total size of save_buffer */
+ png_size_t buffer_size; /* total amount of available input data */
+ png_size_t current_buffer_size; /* amount of data now in current_buffer */
+ int process_mode; /* what push library is currently doing */
+ int cur_palette; /* current push library palette index */
+
+# if defined(PNG_TEXT_SUPPORTED)
+ png_size_t current_text_size; /* current size of text input data */
+ png_size_t current_text_left; /* how much text left to read in input */
+ png_charp current_text; /* current text chunk buffer */
+ png_charp current_text_ptr; /* current location in current_text */
+# endif /* PNG_TEXT_SUPPORTED */
+#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
+
+#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
+/* for the Borland special 64K segment handler */
+ png_bytepp offset_table_ptr;
+ png_bytep offset_table;
+ png_uint_16 offset_table_number;
+ png_uint_16 offset_table_count;
+ png_uint_16 offset_table_count_free;
+#endif
+
+#if defined(PNG_READ_DITHER_SUPPORTED)
+ png_bytep palette_lookup; /* lookup table for dithering */
+ png_bytep dither_index; /* index translation for palette files */
+#endif
+
+#if defined(PNG_READ_DITHER_SUPPORTED) || defined(PNG_hIST_SUPPORTED)
+ png_uint_16p hist; /* histogram */
+#endif
+
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
+ png_byte heuristic_method; /* heuristic for row filter selection */
+ png_byte num_prev_filters; /* number of weights for previous rows */
+ png_bytep prev_filters; /* filter type(s) of previous row(s) */
+ png_uint_16p filter_weights; /* weight(s) for previous line(s) */
+ png_uint_16p inv_filter_weights; /* 1/weight(s) for previous line(s) */
+ png_uint_16p filter_costs; /* relative filter calculation cost */
+ png_uint_16p inv_filter_costs; /* 1/relative filter calculation cost */
+#endif
+
+#if defined(PNG_TIME_RFC1123_SUPPORTED)
+ png_charp time_buffer; /* String to hold RFC 1123 time text */
+#endif
+
+/* New members added in libpng-1.0.6 */
+
+#ifdef PNG_FREE_ME_SUPPORTED
+ png_uint_32 free_me; /* flags items libpng is responsible for freeing */
+#endif
+
+#if defined(PNG_USER_CHUNKS_SUPPORTED)
+ png_voidp user_chunk_ptr;
+ png_user_chunk_ptr read_user_chunk_fn; /* user read chunk handler */
+#endif
+
+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
+ int num_chunk_list;
+ png_bytep chunk_list;
+#endif
+
+/* New members added in libpng-1.0.3 */
+#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
+ png_byte rgb_to_gray_status;
+ /* These were changed from png_byte in libpng-1.0.6 */
+ png_uint_16 rgb_to_gray_red_coeff;
+ png_uint_16 rgb_to_gray_green_coeff;
+ png_uint_16 rgb_to_gray_blue_coeff;
+#endif
+
+/* New member added in libpng-1.0.4 (renamed in 1.0.9) */
+#if defined(PNG_MNG_FEATURES_SUPPORTED) || \
+ defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \
+ defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED)
+/* changed from png_byte to png_uint_32 at version 1.2.0 */
+#ifdef PNG_1_0_X
+ png_byte mng_features_permitted;
+#else
+ png_uint_32 mng_features_permitted;
+#endif /* PNG_1_0_X */
+#endif
+
+/* New member added in libpng-1.0.7 */
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+ png_fixed_point int_gamma;
+#endif
+
+/* New member added in libpng-1.0.9, ifdef'ed out in 1.0.12, enabled in 1.2.0 */
+#if defined(PNG_MNG_FEATURES_SUPPORTED)
+ png_byte filter_type;
+#endif
+
+#if defined(PNG_1_0_X)
+/* New member added in libpng-1.0.10, ifdef'ed out in 1.2.0 */
+ png_uint_32 row_buf_size;
+#endif
+
+/* New members added in libpng-1.2.0 */
+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED)
+# if !defined(PNG_1_0_X)
+# if defined(PNG_MMX_CODE_SUPPORTED)
+ png_byte mmx_bitdepth_threshold;
+ png_uint_32 mmx_rowbytes_threshold;
+# endif
+ png_uint_32 asm_flags;
+# endif
+#endif
+
+/* New members added in libpng-1.0.2 but first enabled by default in 1.2.0 */
+#ifdef PNG_USER_MEM_SUPPORTED
+ png_voidp mem_ptr; /* user supplied struct for mem functions */
+ png_malloc_ptr malloc_fn; /* function for allocating memory */
+ png_free_ptr free_fn; /* function for freeing memory */
+#endif
+
+/* New member added in libpng-1.0.13 and 1.2.0 */
+ png_bytep big_row_buf; /* buffer to save current (unfiltered) row */
+
+#if defined(PNG_READ_DITHER_SUPPORTED)
+/* The following three members were added at version 1.0.14 and 1.2.4 */
+ png_bytep dither_sort; /* working sort array */
+ png_bytep index_to_palette; /* where the original index currently is */
+ /* in the palette */
+ png_bytep palette_to_index; /* which original index points to this */
+ /* palette color */
+#endif
+
+/* New members added in libpng-1.0.16 and 1.2.6 */
+ png_byte compression_type;
+
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED
+ png_uint_32 user_width_max;
+ png_uint_32 user_height_max;
+#endif
+
+/* New member added in libpng-1.0.25 and 1.2.17 */
+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
+ /* storage for unknown chunk that the library doesn't recognize. */
+ png_unknown_chunk unknown_chunk;
+#endif
+
+/* New members added in libpng-1.2.26 */
+ png_uint_32 old_big_row_buf_size, old_prev_row_size;
+
+/* New member added in libpng-1.2.30 */
+ png_charp chunkdata; /* buffer for reading chunk data */
+
+};
+
+
+/* This triggers a compiler error in png.c, if png.c and png.h
+ * do not agree upon the version number.
+ */
+typedef png_structp version_1_2_33;
+
+typedef png_struct FAR * FAR * png_structpp;
+
+/* Here are the function definitions most commonly used. This is not
+ * the place to find out how to use libpng. See libpng.txt for the
+ * full explanation, see example.c for the summary. This just provides
+ * a simple one line description of the use of each function.
+ */
+
+/* Returns the version number of the library */
+extern PNG_EXPORT(png_uint_32,png_access_version_number) PNGARG((void));
+
+/* Tell lib we have already handled the first <num_bytes> magic bytes.
+ * Handling more than 8 bytes from the beginning of the file is an error.
+ */
+extern PNG_EXPORT(void,png_set_sig_bytes) PNGARG((png_structp png_ptr,
+ int num_bytes));
+
+/* Check sig[start] through sig[start + num_to_check - 1] to see if it's a
+ * PNG file. Returns zero if the supplied bytes match the 8-byte PNG
+ * signature, and non-zero otherwise. Having num_to_check == 0 or
+ * start > 7 will always fail (ie return non-zero).
+ */
+extern PNG_EXPORT(int,png_sig_cmp) PNGARG((png_bytep sig, png_size_t start,
+ png_size_t num_to_check));
+
+/* Simple signature checking function. This is the same as calling
+ * png_check_sig(sig, n) := !png_sig_cmp(sig, 0, n).
+ */
+extern PNG_EXPORT(int,png_check_sig) PNGARG((png_bytep sig, int num));
+
+/* Allocate and initialize png_ptr struct for reading, and any other memory. */
+extern PNG_EXPORT(png_structp,png_create_read_struct)
+ PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,
+ png_error_ptr error_fn, png_error_ptr warn_fn));
+
+/* Allocate and initialize png_ptr struct for writing, and any other memory */
+extern PNG_EXPORT(png_structp,png_create_write_struct)
+ PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,
+ png_error_ptr error_fn, png_error_ptr warn_fn));
+
+#ifdef PNG_WRITE_SUPPORTED
+extern PNG_EXPORT(png_uint_32,png_get_compression_buffer_size)
+ PNGARG((png_structp png_ptr));
+#endif
+
+#ifdef PNG_WRITE_SUPPORTED
+extern PNG_EXPORT(void,png_set_compression_buffer_size)
+ PNGARG((png_structp png_ptr, png_uint_32 size));
+#endif
+
+/* Reset the compression stream */
+extern PNG_EXPORT(int,png_reset_zstream) PNGARG((png_structp png_ptr));
+
+/* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */
+#ifdef PNG_USER_MEM_SUPPORTED
+extern PNG_EXPORT(png_structp,png_create_read_struct_2)
+ PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,
+ png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
+ png_malloc_ptr malloc_fn, png_free_ptr free_fn));
+extern PNG_EXPORT(png_structp,png_create_write_struct_2)
+ PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,
+ png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
+ png_malloc_ptr malloc_fn, png_free_ptr free_fn));
+#endif
+
+/* Write a PNG chunk - size, type, (optional) data, CRC. */
+extern PNG_EXPORT(void,png_write_chunk) PNGARG((png_structp png_ptr,
+ png_bytep chunk_name, png_bytep data, png_size_t length));
+
+/* Write the start of a PNG chunk - length and chunk name. */
+extern PNG_EXPORT(void,png_write_chunk_start) PNGARG((png_structp png_ptr,
+ png_bytep chunk_name, png_uint_32 length));
+
+/* Write the data of a PNG chunk started with png_write_chunk_start(). */
+extern PNG_EXPORT(void,png_write_chunk_data) PNGARG((png_structp png_ptr,
+ png_bytep data, png_size_t length));
+
+/* Finish a chunk started with png_write_chunk_start() (includes CRC). */
+extern PNG_EXPORT(void,png_write_chunk_end) PNGARG((png_structp png_ptr));
+
+/* Allocate and initialize the info structure */
+extern PNG_EXPORT(png_infop,png_create_info_struct)
+ PNGARG((png_structp png_ptr));
+
+#if defined(PNG_1_0_X) || defined (PNG_1_2_X)
+/* Initialize the info structure (old interface - DEPRECATED) */
+extern PNG_EXPORT(void,png_info_init) PNGARG((png_infop info_ptr));
+#undef png_info_init
+#define png_info_init(info_ptr) png_info_init_3(&info_ptr,\
+ png_sizeof(png_info));
+#endif
+
+extern PNG_EXPORT(void,png_info_init_3) PNGARG((png_infopp info_ptr,
+ png_size_t png_info_struct_size));
+
+/* Writes all the PNG information before the image. */
+extern PNG_EXPORT(void,png_write_info_before_PLTE) PNGARG((png_structp png_ptr,
+ png_infop info_ptr));
+extern PNG_EXPORT(void,png_write_info) PNGARG((png_structp png_ptr,
+ png_infop info_ptr));
+
+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED
+/* read the information before the actual image data. */
+extern PNG_EXPORT(void,png_read_info) PNGARG((png_structp png_ptr,
+ png_infop info_ptr));
+#endif
+
+#if defined(PNG_TIME_RFC1123_SUPPORTED)
+extern PNG_EXPORT(png_charp,png_convert_to_rfc1123)
+ PNGARG((png_structp png_ptr, png_timep ptime));
+#endif
+
+#if !defined(_WIN32_WCE)
+/* "time.h" functions are not supported on WindowsCE */
+#if defined(PNG_WRITE_tIME_SUPPORTED)
+/* convert from a struct tm to png_time */
+extern PNG_EXPORT(void,png_convert_from_struct_tm) PNGARG((png_timep ptime,
+ struct tm FAR * ttime));
+
+/* convert from time_t to png_time. Uses gmtime() */
+extern PNG_EXPORT(void,png_convert_from_time_t) PNGARG((png_timep ptime,
+ time_t ttime));
+#endif /* PNG_WRITE_tIME_SUPPORTED */
+#endif /* _WIN32_WCE */
+
+#if defined(PNG_READ_EXPAND_SUPPORTED)
+/* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */
+extern PNG_EXPORT(void,png_set_expand) PNGARG((png_structp png_ptr));
+#if !defined(PNG_1_0_X)
+extern PNG_EXPORT(void,png_set_expand_gray_1_2_4_to_8) PNGARG((png_structp
+ png_ptr));
+#endif
+extern PNG_EXPORT(void,png_set_palette_to_rgb) PNGARG((png_structp png_ptr));
+extern PNG_EXPORT(void,png_set_tRNS_to_alpha) PNGARG((png_structp png_ptr));
+#if defined(PNG_1_0_X) || defined (PNG_1_2_X)
+/* Deprecated */
+extern PNG_EXPORT(void,png_set_gray_1_2_4_to_8) PNGARG((png_structp png_ptr));
+#endif
+#endif
+
+#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
+/* Use blue, green, red order for pixels. */
+extern PNG_EXPORT(void,png_set_bgr) PNGARG((png_structp png_ptr));
+#endif
+
+#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
+/* Expand the grayscale to 24-bit RGB if necessary. */
+extern PNG_EXPORT(void,png_set_gray_to_rgb) PNGARG((png_structp png_ptr));
+#endif
+
+#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
+/* Reduce RGB to grayscale. */
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+extern PNG_EXPORT(void,png_set_rgb_to_gray) PNGARG((png_structp png_ptr,
+ int error_action, double red, double green ));
+#endif
+extern PNG_EXPORT(void,png_set_rgb_to_gray_fixed) PNGARG((png_structp png_ptr,
+ int error_action, png_fixed_point red, png_fixed_point green ));
+extern PNG_EXPORT(png_byte,png_get_rgb_to_gray_status) PNGARG((png_structp
+ png_ptr));
+#endif
+
+extern PNG_EXPORT(void,png_build_grayscale_palette) PNGARG((int bit_depth,
+ png_colorp palette));
+
+#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
+extern PNG_EXPORT(void,png_set_strip_alpha) PNGARG((png_structp png_ptr));
+#endif
+
+#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \
+ defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
+extern PNG_EXPORT(void,png_set_swap_alpha) PNGARG((png_structp png_ptr));
+#endif
+
+#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \
+ defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
+extern PNG_EXPORT(void,png_set_invert_alpha) PNGARG((png_structp png_ptr));
+#endif
+
+#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
+/* Add a filler byte to 8-bit Gray or 24-bit RGB images. */
+extern PNG_EXPORT(void,png_set_filler) PNGARG((png_structp png_ptr,
+ png_uint_32 filler, int flags));
+/* The values of the PNG_FILLER_ defines should NOT be changed */
+#define PNG_FILLER_BEFORE 0
+#define PNG_FILLER_AFTER 1
+/* Add an alpha byte to 8-bit Gray or 24-bit RGB images. */
+#if !defined(PNG_1_0_X)
+extern PNG_EXPORT(void,png_set_add_alpha) PNGARG((png_structp png_ptr,
+ png_uint_32 filler, int flags));
+#endif
+#endif /* PNG_READ_FILLER_SUPPORTED || PNG_WRITE_FILLER_SUPPORTED */
+
+#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
+/* Swap bytes in 16-bit depth files. */
+extern PNG_EXPORT(void,png_set_swap) PNGARG((png_structp png_ptr));
+#endif
+
+#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
+/* Use 1 byte per pixel in 1, 2, or 4-bit depth files. */
+extern PNG_EXPORT(void,png_set_packing) PNGARG((png_structp png_ptr));
+#endif
+
+#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED)
+/* Swap packing order of pixels in bytes. */
+extern PNG_EXPORT(void,png_set_packswap) PNGARG((png_structp png_ptr));
+#endif
+
+#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
+/* Converts files to legal bit depths. */
+extern PNG_EXPORT(void,png_set_shift) PNGARG((png_structp png_ptr,
+ png_color_8p true_bits));
+#endif
+
+#if defined(PNG_READ_INTERLACING_SUPPORTED) || \
+ defined(PNG_WRITE_INTERLACING_SUPPORTED)
+/* Have the code handle the interlacing. Returns the number of passes. */
+extern PNG_EXPORT(int,png_set_interlace_handling) PNGARG((png_structp png_ptr));
+#endif
+
+#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
+/* Invert monochrome files */
+extern PNG_EXPORT(void,png_set_invert_mono) PNGARG((png_structp png_ptr));
+#endif
+
+#if defined(PNG_READ_BACKGROUND_SUPPORTED)
+/* Handle alpha and tRNS by replacing with a background color. */
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+extern PNG_EXPORT(void,png_set_background) PNGARG((png_structp png_ptr,
+ png_color_16p background_color, int background_gamma_code,
+ int need_expand, double background_gamma));
+#endif
+#define PNG_BACKGROUND_GAMMA_UNKNOWN 0
+#define PNG_BACKGROUND_GAMMA_SCREEN 1
+#define PNG_BACKGROUND_GAMMA_FILE 2
+#define PNG_BACKGROUND_GAMMA_UNIQUE 3
+#endif
+
+#if defined(PNG_READ_16_TO_8_SUPPORTED)
+/* strip the second byte of information from a 16-bit depth file. */
+extern PNG_EXPORT(void,png_set_strip_16) PNGARG((png_structp png_ptr));
+#endif
+
+#if defined(PNG_READ_DITHER_SUPPORTED)
+/* Turn on dithering, and reduce the palette to the number of colors available. */
+extern PNG_EXPORT(void,png_set_dither) PNGARG((png_structp png_ptr,
+ png_colorp palette, int num_palette, int maximum_colors,
+ png_uint_16p histogram, int full_dither));
+#endif
+
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+/* Handle gamma correction. Screen_gamma=(display_exponent) */
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+extern PNG_EXPORT(void,png_set_gamma) PNGARG((png_structp png_ptr,
+ double screen_gamma, double default_file_gamma));
+#endif
+#endif
+
+#if defined(PNG_1_0_X) || defined (PNG_1_2_X)
+#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \
+ defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED)
+/* Permit or disallow empty PLTE (0: not permitted, 1: permitted) */
+/* Deprecated and will be removed. Use png_permit_mng_features() instead. */
+extern PNG_EXPORT(void,png_permit_empty_plte) PNGARG((png_structp png_ptr,
+ int empty_plte_permitted));
+#endif
+#endif
+
+#if defined(PNG_WRITE_FLUSH_SUPPORTED)
+/* Set how many lines between output flushes - 0 for no flushing */
+extern PNG_EXPORT(void,png_set_flush) PNGARG((png_structp png_ptr, int nrows));
+/* Flush the current PNG output buffer */
+extern PNG_EXPORT(void,png_write_flush) PNGARG((png_structp png_ptr));
+#endif
+
+/* optional update palette with requested transformations */
+extern PNG_EXPORT(void,png_start_read_image) PNGARG((png_structp png_ptr));
+
+/* optional call to update the users info structure */
+extern PNG_EXPORT(void,png_read_update_info) PNGARG((png_structp png_ptr,
+ png_infop info_ptr));
+
+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED
+/* read one or more rows of image data. */
+extern PNG_EXPORT(void,png_read_rows) PNGARG((png_structp png_ptr,
+ png_bytepp row, png_bytepp display_row, png_uint_32 num_rows));
+#endif
+
+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED
+/* read a row of data. */
+extern PNG_EXPORT(void,png_read_row) PNGARG((png_structp png_ptr,
+ png_bytep row,
+ png_bytep display_row));
+#endif
+
+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED
+/* read the whole image into memory at once. */
+extern PNG_EXPORT(void,png_read_image) PNGARG((png_structp png_ptr,
+ png_bytepp image));
+#endif
+
+/* write a row of image data */
+extern PNG_EXPORT(void,png_write_row) PNGARG((png_structp png_ptr,
+ png_bytep row));
+
+/* write a few rows of image data */
+extern PNG_EXPORT(void,png_write_rows) PNGARG((png_structp png_ptr,
+ png_bytepp row, png_uint_32 num_rows));
+
+/* write the image data */
+extern PNG_EXPORT(void,png_write_image) PNGARG((png_structp png_ptr,
+ png_bytepp image));
+
+/* writes the end of the PNG file. */
+extern PNG_EXPORT(void,png_write_end) PNGARG((png_structp png_ptr,
+ png_infop info_ptr));
+
+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED
+/* read the end of the PNG file. */
+extern PNG_EXPORT(void,png_read_end) PNGARG((png_structp png_ptr,
+ png_infop info_ptr));
+#endif
+
+/* free any memory associated with the png_info_struct */
+extern PNG_EXPORT(void,png_destroy_info_struct) PNGARG((png_structp png_ptr,
+ png_infopp info_ptr_ptr));
+
+/* free any memory associated with the png_struct and the png_info_structs */
+extern PNG_EXPORT(void,png_destroy_read_struct) PNGARG((png_structpp
+ png_ptr_ptr, png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr));
+
+/* free all memory used by the read (old method - NOT DLL EXPORTED) */
+extern void png_read_destroy PNGARG((png_structp png_ptr, png_infop info_ptr,
+ png_infop end_info_ptr));
+
+/* free any memory associated with the png_struct and the png_info_structs */
+extern PNG_EXPORT(void,png_destroy_write_struct)
+ PNGARG((png_structpp png_ptr_ptr, png_infopp info_ptr_ptr));
+
+/* free any memory used in png_ptr struct (old method - NOT DLL EXPORTED) */
+extern void png_write_destroy PNGARG((png_structp png_ptr));
+
+/* set the libpng method of handling chunk CRC errors */
+extern PNG_EXPORT(void,png_set_crc_action) PNGARG((png_structp png_ptr,
+ int crit_action, int ancil_action));
+
+/* Values for png_set_crc_action() to say how to handle CRC errors in
+ * ancillary and critical chunks, and whether to use the data contained
+ * therein. Note that it is impossible to "discard" data in a critical
+ * chunk. For versions prior to 0.90, the action was always error/quit,
+ * whereas in version 0.90 and later, the action for CRC errors in ancillary
+ * chunks is warn/discard. These values should NOT be changed.
+ *
+ * value action:critical action:ancillary
+ */
+#define PNG_CRC_DEFAULT 0 /* error/quit warn/discard data */
+#define PNG_CRC_ERROR_QUIT 1 /* error/quit error/quit */
+#define PNG_CRC_WARN_DISCARD 2 /* (INVALID) warn/discard data */
+#define PNG_CRC_WARN_USE 3 /* warn/use data warn/use data */
+#define PNG_CRC_QUIET_USE 4 /* quiet/use data quiet/use data */
+#define PNG_CRC_NO_CHANGE 5 /* use current value use current value */
+
+/* These functions give the user control over the scan-line filtering in
+ * libpng and the compression methods used by zlib. These functions are
+ * mainly useful for testing, as the defaults should work with most users.
+ * Those users who are tight on memory or want faster performance at the
+ * expense of compression can modify them. See the compression library
+ * header file (zlib.h) for an explination of the compression functions.
+ */
+
+/* set the filtering method(s) used by libpng. Currently, the only valid
+ * value for "method" is 0.
+ */
+extern PNG_EXPORT(void,png_set_filter) PNGARG((png_structp png_ptr, int method,
+ int filters));
+
+/* Flags for png_set_filter() to say which filters to use. The flags
+ * are chosen so that they don't conflict with real filter types
+ * below, in case they are supplied instead of the #defined constants.
+ * These values should NOT be changed.
+ */
+#define PNG_NO_FILTERS 0x00
+#define PNG_FILTER_NONE 0x08
+#define PNG_FILTER_SUB 0x10
+#define PNG_FILTER_UP 0x20
+#define PNG_FILTER_AVG 0x40
+#define PNG_FILTER_PAETH 0x80
+#define PNG_ALL_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP | \
+ PNG_FILTER_AVG | PNG_FILTER_PAETH)
+
+/* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now.
+ * These defines should NOT be changed.
+ */
+#define PNG_FILTER_VALUE_NONE 0
+#define PNG_FILTER_VALUE_SUB 1
+#define PNG_FILTER_VALUE_UP 2
+#define PNG_FILTER_VALUE_AVG 3
+#define PNG_FILTER_VALUE_PAETH 4
+#define PNG_FILTER_VALUE_LAST 5
+
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) /* EXPERIMENTAL */
+/* The "heuristic_method" is given by one of the PNG_FILTER_HEURISTIC_
+ * defines, either the default (minimum-sum-of-absolute-differences), or
+ * the experimental method (weighted-minimum-sum-of-absolute-differences).
+ *
+ * Weights are factors >= 1.0, indicating how important it is to keep the
+ * filter type consistent between rows. Larger numbers mean the current
+ * filter is that many times as likely to be the same as the "num_weights"
+ * previous filters. This is cumulative for each previous row with a weight.
+ * There needs to be "num_weights" values in "filter_weights", or it can be
+ * NULL if the weights aren't being specified. Weights have no influence on
+ * the selection of the first row filter. Well chosen weights can (in theory)
+ * improve the compression for a given image.
+ *
+ * Costs are factors >= 1.0 indicating the relative decoding costs of a
+ * filter type. Higher costs indicate more decoding expense, and are
+ * therefore less likely to be selected over a filter with lower computational
+ * costs. There needs to be a value in "filter_costs" for each valid filter
+ * type (given by PNG_FILTER_VALUE_LAST), or it can be NULL if you aren't
+ * setting the costs. Costs try to improve the speed of decompression without
+ * unduly increasing the compressed image size.
+ *
+ * A negative weight or cost indicates the default value is to be used, and
+ * values in the range [0.0, 1.0) indicate the value is to remain unchanged.
+ * The default values for both weights and costs are currently 1.0, but may
+ * change if good general weighting/cost heuristics can be found. If both
+ * the weights and costs are set to 1.0, this degenerates the WEIGHTED method
+ * to the UNWEIGHTED method, but with added encoding time/computation.
+ */
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+extern PNG_EXPORT(void,png_set_filter_heuristics) PNGARG((png_structp png_ptr,
+ int heuristic_method, int num_weights, png_doublep filter_weights,
+ png_doublep filter_costs));
+#endif
+#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */
+
+/* Heuristic used for row filter selection. These defines should NOT be
+ * changed.
+ */
+#define PNG_FILTER_HEURISTIC_DEFAULT 0 /* Currently "UNWEIGHTED" */
+#define PNG_FILTER_HEURISTIC_UNWEIGHTED 1 /* Used by libpng < 0.95 */
+#define PNG_FILTER_HEURISTIC_WEIGHTED 2 /* Experimental feature */
+#define PNG_FILTER_HEURISTIC_LAST 3 /* Not a valid value */
+
+/* Set the library compression level. Currently, valid values range from
+ * 0 - 9, corresponding directly to the zlib compression levels 0 - 9
+ * (0 - no compression, 9 - "maximal" compression). Note that tests have
+ * shown that zlib compression levels 3-6 usually perform as well as level 9
+ * for PNG images, and do considerably fewer caclulations. In the future,
+ * these values may not correspond directly to the zlib compression levels.
+ */
+extern PNG_EXPORT(void,png_set_compression_level) PNGARG((png_structp png_ptr,
+ int level));
+
+extern PNG_EXPORT(void,png_set_compression_mem_level)
+ PNGARG((png_structp png_ptr, int mem_level));
+
+extern PNG_EXPORT(void,png_set_compression_strategy)
+ PNGARG((png_structp png_ptr, int strategy));
+
+extern PNG_EXPORT(void,png_set_compression_window_bits)
+ PNGARG((png_structp png_ptr, int window_bits));
+
+extern PNG_EXPORT(void,png_set_compression_method) PNGARG((png_structp png_ptr,
+ int method));
+
+/* These next functions are called for input/output, memory, and error
+ * handling. They are in the file pngrio.c, pngwio.c, and pngerror.c,
+ * and call standard C I/O routines such as fread(), fwrite(), and
+ * fprintf(). These functions can be made to use other I/O routines
+ * at run time for those applications that need to handle I/O in a
+ * different manner by calling png_set_???_fn(). See libpng.txt for
+ * more information.
+ */
+
+#if !defined(PNG_NO_STDIO)
+/* Initialize the input/output for the PNG file to the default functions. */
+extern PNG_EXPORT(void,png_init_io) PNGARG((png_structp png_ptr, png_FILE_p fp));
+#endif
+
+/* Replace the (error and abort), and warning functions with user
+ * supplied functions. If no messages are to be printed you must still
+ * write and use replacement functions. The replacement error_fn should
+ * still do a longjmp to the last setjmp location if you are using this
+ * method of error handling. If error_fn or warning_fn is NULL, the
+ * default function will be used.
+ */
+
+extern PNG_EXPORT(void,png_set_error_fn) PNGARG((png_structp png_ptr,
+ png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn));
+
+/* Return the user pointer associated with the error functions */
+extern PNG_EXPORT(png_voidp,png_get_error_ptr) PNGARG((png_structp png_ptr));
+
+/* Replace the default data output functions with a user supplied one(s).
+ * If buffered output is not used, then output_flush_fn can be set to NULL.
+ * If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time
+ * output_flush_fn will be ignored (and thus can be NULL).
+ */
+extern PNG_EXPORT(void,png_set_write_fn) PNGARG((png_structp png_ptr,
+ png_voidp io_ptr, png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn));
+
+/* Replace the default data input function with a user supplied one. */
+extern PNG_EXPORT(void,png_set_read_fn) PNGARG((png_structp png_ptr,
+ png_voidp io_ptr, png_rw_ptr read_data_fn));
+
+/* Return the user pointer associated with the I/O functions */
+extern PNG_EXPORT(png_voidp,png_get_io_ptr) PNGARG((png_structp png_ptr));
+
+extern PNG_EXPORT(void,png_set_read_status_fn) PNGARG((png_structp png_ptr,
+ png_read_status_ptr read_row_fn));
+
+extern PNG_EXPORT(void,png_set_write_status_fn) PNGARG((png_structp png_ptr,
+ png_write_status_ptr write_row_fn));
+
+#ifdef PNG_USER_MEM_SUPPORTED
+/* Replace the default memory allocation functions with user supplied one(s). */
+extern PNG_EXPORT(void,png_set_mem_fn) PNGARG((png_structp png_ptr,
+ png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn));
+/* Return the user pointer associated with the memory functions */
+extern PNG_EXPORT(png_voidp,png_get_mem_ptr) PNGARG((png_structp png_ptr));
+#endif
+
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
+ defined(PNG_LEGACY_SUPPORTED)
+extern PNG_EXPORT(void,png_set_read_user_transform_fn) PNGARG((png_structp
+ png_ptr, png_user_transform_ptr read_user_transform_fn));
+#endif
+
+#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \
+ defined(PNG_LEGACY_SUPPORTED)
+extern PNG_EXPORT(void,png_set_write_user_transform_fn) PNGARG((png_structp
+ png_ptr, png_user_transform_ptr write_user_transform_fn));
+#endif
+
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
+ defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \
+ defined(PNG_LEGACY_SUPPORTED)
+extern PNG_EXPORT(void,png_set_user_transform_info) PNGARG((png_structp
+ png_ptr, png_voidp user_transform_ptr, int user_transform_depth,
+ int user_transform_channels));
+/* Return the user pointer associated with the user transform functions */
+extern PNG_EXPORT(png_voidp,png_get_user_transform_ptr)
+ PNGARG((png_structp png_ptr));
+#endif
+
+#ifdef PNG_USER_CHUNKS_SUPPORTED
+extern PNG_EXPORT(void,png_set_read_user_chunk_fn) PNGARG((png_structp png_ptr,
+ png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn));
+extern PNG_EXPORT(png_voidp,png_get_user_chunk_ptr) PNGARG((png_structp
+ png_ptr));
+#endif
+
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
+/* Sets the function callbacks for the push reader, and a pointer to a
+ * user-defined structure available to the callback functions.
+ */
+extern PNG_EXPORT(void,png_set_progressive_read_fn) PNGARG((png_structp png_ptr,
+ png_voidp progressive_ptr,
+ png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn,
+ png_progressive_end_ptr end_fn));
+
+/* returns the user pointer associated with the push read functions */
+extern PNG_EXPORT(png_voidp,png_get_progressive_ptr)
+ PNGARG((png_structp png_ptr));
+
+/* function to be called when data becomes available */
+extern PNG_EXPORT(void,png_process_data) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_bytep buffer, png_size_t buffer_size));
+
+/* function that combines rows. Not very much different than the
+ * png_combine_row() call. Is this even used?????
+ */
+extern PNG_EXPORT(void,png_progressive_combine_row) PNGARG((png_structp png_ptr,
+ png_bytep old_row, png_bytep new_row));
+#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
+
+extern PNG_EXPORT(png_voidp,png_malloc) PNGARG((png_structp png_ptr,
+ png_uint_32 size));
+
+#if defined(PNG_1_0_X)
+# define png_malloc_warn png_malloc
+#else
+/* Added at libpng version 1.2.4 */
+extern PNG_EXPORT(png_voidp,png_malloc_warn) PNGARG((png_structp png_ptr,
+ png_uint_32 size));
+#endif
+
+/* frees a pointer allocated by png_malloc() */
+extern PNG_EXPORT(void,png_free) PNGARG((png_structp png_ptr, png_voidp ptr));
+
+#if defined(PNG_1_0_X)
+/* Function to allocate memory for zlib. */
+extern PNG_EXPORT(voidpf,png_zalloc) PNGARG((voidpf png_ptr, uInt items,
+ uInt size));
+
+/* Function to free memory for zlib */
+extern PNG_EXPORT(void,png_zfree) PNGARG((voidpf png_ptr, voidpf ptr));
+#endif
+
+/* Free data that was allocated internally */
+extern PNG_EXPORT(void,png_free_data) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_uint_32 free_me, int num));
+#ifdef PNG_FREE_ME_SUPPORTED
+/* Reassign responsibility for freeing existing data, whether allocated
+ * by libpng or by the application */
+extern PNG_EXPORT(void,png_data_freer) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, int freer, png_uint_32 mask));
+#endif
+/* assignments for png_data_freer */
+#define PNG_DESTROY_WILL_FREE_DATA 1
+#define PNG_SET_WILL_FREE_DATA 1
+#define PNG_USER_WILL_FREE_DATA 2
+/* Flags for png_ptr->free_me and info_ptr->free_me */
+#define PNG_FREE_HIST 0x0008
+#define PNG_FREE_ICCP 0x0010
+#define PNG_FREE_SPLT 0x0020
+#define PNG_FREE_ROWS 0x0040
+#define PNG_FREE_PCAL 0x0080
+#define PNG_FREE_SCAL 0x0100
+#define PNG_FREE_UNKN 0x0200
+#define PNG_FREE_LIST 0x0400
+#define PNG_FREE_PLTE 0x1000
+#define PNG_FREE_TRNS 0x2000
+#define PNG_FREE_TEXT 0x4000
+#define PNG_FREE_ALL 0x7fff
+#define PNG_FREE_MUL 0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */
+
+#ifdef PNG_USER_MEM_SUPPORTED
+extern PNG_EXPORT(png_voidp,png_malloc_default) PNGARG((png_structp png_ptr,
+ png_uint_32 size));
+extern PNG_EXPORT(void,png_free_default) PNGARG((png_structp png_ptr,
+ png_voidp ptr));
+#endif
+
+extern PNG_EXPORT(png_voidp,png_memcpy_check) PNGARG((png_structp png_ptr,
+ png_voidp s1, png_voidp s2, png_uint_32 size));
+
+extern PNG_EXPORT(png_voidp,png_memset_check) PNGARG((png_structp png_ptr,
+ png_voidp s1, int value, png_uint_32 size));
+
+#if defined(USE_FAR_KEYWORD) /* memory model conversion function */
+extern void *png_far_to_near PNGARG((png_structp png_ptr,png_voidp ptr,
+ int check));
+#endif /* USE_FAR_KEYWORD */
+
+#ifndef PNG_NO_ERROR_TEXT
+/* Fatal error in PNG image of libpng - can't continue */
+extern PNG_EXPORT(void,png_error) PNGARG((png_structp png_ptr,
+ png_const_charp error_message));
+
+/* The same, but the chunk name is prepended to the error string. */
+extern PNG_EXPORT(void,png_chunk_error) PNGARG((png_structp png_ptr,
+ png_const_charp error_message));
+#else
+/* Fatal error in PNG image of libpng - can't continue */
+extern PNG_EXPORT(void,png_err) PNGARG((png_structp png_ptr));
+#endif
+
+#ifndef PNG_NO_WARNINGS
+/* Non-fatal error in libpng. Can continue, but may have a problem. */
+extern PNG_EXPORT(void,png_warning) PNGARG((png_structp png_ptr,
+ png_const_charp warning_message));
+
+#ifdef PNG_READ_SUPPORTED
+/* Non-fatal error in libpng, chunk name is prepended to message. */
+extern PNG_EXPORT(void,png_chunk_warning) PNGARG((png_structp png_ptr,
+ png_const_charp warning_message));
+#endif /* PNG_READ_SUPPORTED */
+#endif /* PNG_NO_WARNINGS */
+
+/* The png_set_<chunk> functions are for storing values in the png_info_struct.
+ * Similarly, the png_get_<chunk> calls are used to read values from the
+ * png_info_struct, either storing the parameters in the passed variables, or
+ * setting pointers into the png_info_struct where the data is stored. The
+ * png_get_<chunk> functions return a non-zero value if the data was available
+ * in info_ptr, or return zero and do not change any of the parameters if the
+ * data was not available.
+ *
+ * These functions should be used instead of directly accessing png_info
+ * to avoid problems with future changes in the size and internal layout of
+ * png_info_struct.
+ */
+/* Returns "flag" if chunk data is valid in info_ptr. */
+extern PNG_EXPORT(png_uint_32,png_get_valid) PNGARG((png_structp png_ptr,
+png_infop info_ptr, png_uint_32 flag));
+
+/* Returns number of bytes needed to hold a transformed row. */
+extern PNG_EXPORT(png_uint_32,png_get_rowbytes) PNGARG((png_structp png_ptr,
+png_infop info_ptr));
+
+#if defined(PNG_INFO_IMAGE_SUPPORTED)
+/* Returns row_pointers, which is an array of pointers to scanlines that was
+returned from png_read_png(). */
+extern PNG_EXPORT(png_bytepp,png_get_rows) PNGARG((png_structp png_ptr,
+png_infop info_ptr));
+/* Set row_pointers, which is an array of pointers to scanlines for use
+by png_write_png(). */
+extern PNG_EXPORT(void,png_set_rows) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_bytepp row_pointers));
+#endif
+
+/* Returns number of color channels in image. */
+extern PNG_EXPORT(png_byte,png_get_channels) PNGARG((png_structp png_ptr,
+png_infop info_ptr));
+
+#ifdef PNG_EASY_ACCESS_SUPPORTED
+/* Returns image width in pixels. */
+extern PNG_EXPORT(png_uint_32, png_get_image_width) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+
+/* Returns image height in pixels. */
+extern PNG_EXPORT(png_uint_32, png_get_image_height) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+
+/* Returns image bit_depth. */
+extern PNG_EXPORT(png_byte, png_get_bit_depth) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+
+/* Returns image color_type. */
+extern PNG_EXPORT(png_byte, png_get_color_type) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+
+/* Returns image filter_type. */
+extern PNG_EXPORT(png_byte, png_get_filter_type) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+
+/* Returns image interlace_type. */
+extern PNG_EXPORT(png_byte, png_get_interlace_type) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+
+/* Returns image compression_type. */
+extern PNG_EXPORT(png_byte, png_get_compression_type) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+
+/* Returns image resolution in pixels per meter, from pHYs chunk data. */
+extern PNG_EXPORT(png_uint_32, png_get_pixels_per_meter) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+extern PNG_EXPORT(png_uint_32, png_get_x_pixels_per_meter) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+extern PNG_EXPORT(png_uint_32, png_get_y_pixels_per_meter) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+
+/* Returns pixel aspect ratio, computed from pHYs chunk data. */
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+extern PNG_EXPORT(float, png_get_pixel_aspect_ratio) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+#endif
+
+/* Returns image x, y offset in pixels or microns, from oFFs chunk data. */
+extern PNG_EXPORT(png_int_32, png_get_x_offset_pixels) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+extern PNG_EXPORT(png_int_32, png_get_y_offset_pixels) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+extern PNG_EXPORT(png_int_32, png_get_x_offset_microns) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+extern PNG_EXPORT(png_int_32, png_get_y_offset_microns) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+
+#endif /* PNG_EASY_ACCESS_SUPPORTED */
+
+/* Returns pointer to signature string read from PNG header */
+extern PNG_EXPORT(png_bytep,png_get_signature) PNGARG((png_structp png_ptr,
+png_infop info_ptr));
+
+#if defined(PNG_bKGD_SUPPORTED)
+extern PNG_EXPORT(png_uint_32,png_get_bKGD) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_color_16p *background));
+#endif
+
+#if defined(PNG_bKGD_SUPPORTED)
+extern PNG_EXPORT(void,png_set_bKGD) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_color_16p background));
+#endif
+
+#if defined(PNG_cHRM_SUPPORTED)
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+extern PNG_EXPORT(png_uint_32,png_get_cHRM) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, double *white_x, double *white_y, double *red_x,
+ double *red_y, double *green_x, double *green_y, double *blue_x,
+ double *blue_y));
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+extern PNG_EXPORT(png_uint_32,png_get_cHRM_fixed) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_fixed_point *int_white_x, png_fixed_point
+ *int_white_y, png_fixed_point *int_red_x, png_fixed_point *int_red_y,
+ png_fixed_point *int_green_x, png_fixed_point *int_green_y, png_fixed_point
+ *int_blue_x, png_fixed_point *int_blue_y));
+#endif
+#endif
+
+#if defined(PNG_cHRM_SUPPORTED)
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+extern PNG_EXPORT(void,png_set_cHRM) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, double white_x, double white_y, double red_x,
+ double red_y, double green_x, double green_y, double blue_x, double blue_y));
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+extern PNG_EXPORT(void,png_set_cHRM_fixed) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_fixed_point int_white_x, png_fixed_point int_white_y,
+ png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point
+ int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x,
+ png_fixed_point int_blue_y));
+#endif
+#endif
+
+#if defined(PNG_gAMA_SUPPORTED)
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+extern PNG_EXPORT(png_uint_32,png_get_gAMA) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, double *file_gamma));
+#endif
+extern PNG_EXPORT(png_uint_32,png_get_gAMA_fixed) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_fixed_point *int_file_gamma));
+#endif
+
+#if defined(PNG_gAMA_SUPPORTED)
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+extern PNG_EXPORT(void,png_set_gAMA) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, double file_gamma));
+#endif
+extern PNG_EXPORT(void,png_set_gAMA_fixed) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_fixed_point int_file_gamma));
+#endif
+
+#if defined(PNG_hIST_SUPPORTED)
+extern PNG_EXPORT(png_uint_32,png_get_hIST) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_uint_16p *hist));
+#endif
+
+#if defined(PNG_hIST_SUPPORTED)
+extern PNG_EXPORT(void,png_set_hIST) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_uint_16p hist));
+#endif
+
+extern PNG_EXPORT(png_uint_32,png_get_IHDR) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_uint_32 *width, png_uint_32 *height,
+ int *bit_depth, int *color_type, int *interlace_method,
+ int *compression_method, int *filter_method));
+
+extern PNG_EXPORT(void,png_set_IHDR) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth,
+ int color_type, int interlace_method, int compression_method,
+ int filter_method));
+
+#if defined(PNG_oFFs_SUPPORTED)
+extern PNG_EXPORT(png_uint_32,png_get_oFFs) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_int_32 *offset_x, png_int_32 *offset_y,
+ int *unit_type));
+#endif
+
+#if defined(PNG_oFFs_SUPPORTED)
+extern PNG_EXPORT(void,png_set_oFFs) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_int_32 offset_x, png_int_32 offset_y,
+ int unit_type));
+#endif
+
+#if defined(PNG_pCAL_SUPPORTED)
+extern PNG_EXPORT(png_uint_32,png_get_pCAL) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_charp *purpose, png_int_32 *X0, png_int_32 *X1,
+ int *type, int *nparams, png_charp *units, png_charpp *params));
+#endif
+
+#if defined(PNG_pCAL_SUPPORTED)
+extern PNG_EXPORT(void,png_set_pCAL) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_charp purpose, png_int_32 X0, png_int_32 X1,
+ int type, int nparams, png_charp units, png_charpp params));
+#endif
+
+#if defined(PNG_pHYs_SUPPORTED)
+extern PNG_EXPORT(png_uint_32,png_get_pHYs) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type));
+#endif
+
+#if defined(PNG_pHYs_SUPPORTED)
+extern PNG_EXPORT(void,png_set_pHYs) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type));
+#endif
+
+extern PNG_EXPORT(png_uint_32,png_get_PLTE) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_colorp *palette, int *num_palette));
+
+extern PNG_EXPORT(void,png_set_PLTE) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_colorp palette, int num_palette));
+
+#if defined(PNG_sBIT_SUPPORTED)
+extern PNG_EXPORT(png_uint_32,png_get_sBIT) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_color_8p *sig_bit));
+#endif
+
+#if defined(PNG_sBIT_SUPPORTED)
+extern PNG_EXPORT(void,png_set_sBIT) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_color_8p sig_bit));
+#endif
+
+#if defined(PNG_sRGB_SUPPORTED)
+extern PNG_EXPORT(png_uint_32,png_get_sRGB) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, int *intent));
+#endif
+
+#if defined(PNG_sRGB_SUPPORTED)
+extern PNG_EXPORT(void,png_set_sRGB) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, int intent));
+extern PNG_EXPORT(void,png_set_sRGB_gAMA_and_cHRM) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, int intent));
+#endif
+
+#if defined(PNG_iCCP_SUPPORTED)
+extern PNG_EXPORT(png_uint_32,png_get_iCCP) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_charpp name, int *compression_type,
+ png_charpp profile, png_uint_32 *proflen));
+ /* Note to maintainer: profile should be png_bytepp */
+#endif
+
+#if defined(PNG_iCCP_SUPPORTED)
+extern PNG_EXPORT(void,png_set_iCCP) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_charp name, int compression_type,
+ png_charp profile, png_uint_32 proflen));
+ /* Note to maintainer: profile should be png_bytep */
+#endif
+
+#if defined(PNG_sPLT_SUPPORTED)
+extern PNG_EXPORT(png_uint_32,png_get_sPLT) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_sPLT_tpp entries));
+#endif
+
+#if defined(PNG_sPLT_SUPPORTED)
+extern PNG_EXPORT(void,png_set_sPLT) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_sPLT_tp entries, int nentries));
+#endif
+
+#if defined(PNG_TEXT_SUPPORTED)
+/* png_get_text also returns the number of text chunks in *num_text */
+extern PNG_EXPORT(png_uint_32,png_get_text) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_textp *text_ptr, int *num_text));
+#endif
+
+/*
+ * Note while png_set_text() will accept a structure whose text,
+ * language, and translated keywords are NULL pointers, the structure
+ * returned by png_get_text will always contain regular
+ * zero-terminated C strings. They might be empty strings but
+ * they will never be NULL pointers.
+ */
+
+#if defined(PNG_TEXT_SUPPORTED)
+extern PNG_EXPORT(void,png_set_text) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_textp text_ptr, int num_text));
+#endif
+
+#if defined(PNG_tIME_SUPPORTED)
+extern PNG_EXPORT(png_uint_32,png_get_tIME) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_timep *mod_time));
+#endif
+
+#if defined(PNG_tIME_SUPPORTED)
+extern PNG_EXPORT(void,png_set_tIME) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_timep mod_time));
+#endif
+
+#if defined(PNG_tRNS_SUPPORTED)
+extern PNG_EXPORT(png_uint_32,png_get_tRNS) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_bytep *trans, int *num_trans,
+ png_color_16p *trans_values));
+#endif
+
+#if defined(PNG_tRNS_SUPPORTED)
+extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_bytep trans, int num_trans,
+ png_color_16p trans_values));
+#endif
+
+#if defined(PNG_tRNS_SUPPORTED)
+#endif
+
+#if defined(PNG_sCAL_SUPPORTED)
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+extern PNG_EXPORT(png_uint_32,png_get_sCAL) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, int *unit, double *width, double *height));
+#else
+#ifdef PNG_FIXED_POINT_SUPPORTED
+extern PNG_EXPORT(png_uint_32,png_get_sCAL_s) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, int *unit, png_charpp swidth, png_charpp sheight));
+#endif
+#endif
+#endif /* PNG_sCAL_SUPPORTED */
+
+#if defined(PNG_sCAL_SUPPORTED)
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+extern PNG_EXPORT(void,png_set_sCAL) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, int unit, double width, double height));
+#else
+#ifdef PNG_FIXED_POINT_SUPPORTED
+extern PNG_EXPORT(void,png_set_sCAL_s) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, int unit, png_charp swidth, png_charp sheight));
+#endif
+#endif
+#endif /* PNG_sCAL_SUPPORTED || PNG_WRITE_sCAL_SUPPORTED */
+
+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
+/* provide a list of chunks and how they are to be handled, if the built-in
+ handling or default unknown chunk handling is not desired. Any chunks not
+ listed will be handled in the default manner. The IHDR and IEND chunks
+ must not be listed.
+ keep = 0: follow default behaviour
+ = 1: do not keep
+ = 2: keep only if safe-to-copy
+ = 3: keep even if unsafe-to-copy
+*/
+extern PNG_EXPORT(void, png_set_keep_unknown_chunks) PNGARG((png_structp
+ png_ptr, int keep, png_bytep chunk_list, int num_chunks));
+extern PNG_EXPORT(void, png_set_unknown_chunks) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns));
+extern PNG_EXPORT(void, png_set_unknown_chunk_location)
+ PNGARG((png_structp png_ptr, png_infop info_ptr, int chunk, int location));
+extern PNG_EXPORT(png_uint_32,png_get_unknown_chunks) PNGARG((png_structp
+ png_ptr, png_infop info_ptr, png_unknown_chunkpp entries));
+#endif
+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+PNG_EXPORT(int,png_handle_as_unknown) PNGARG((png_structp png_ptr, png_bytep
+ chunk_name));
+#endif
+
+/* Png_free_data() will turn off the "valid" flag for anything it frees.
+ If you need to turn it off for a chunk that your application has freed,
+ you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK); */
+extern PNG_EXPORT(void, png_set_invalid) PNGARG((png_structp png_ptr,
+ png_infop info_ptr, int mask));
+
+#if defined(PNG_INFO_IMAGE_SUPPORTED)
+/* The "params" pointer is currently not used and is for future expansion. */
+extern PNG_EXPORT(void, png_read_png) PNGARG((png_structp png_ptr,
+ png_infop info_ptr,
+ int transforms,
+ png_voidp params));
+extern PNG_EXPORT(void, png_write_png) PNGARG((png_structp png_ptr,
+ png_infop info_ptr,
+ int transforms,
+ png_voidp params));
+#endif
+
+/* Define PNG_DEBUG at compile time for debugging information. Higher
+ * numbers for PNG_DEBUG mean more debugging information. This has
+ * only been added since version 0.95 so it is not implemented throughout
+ * libpng yet, but more support will be added as needed.
+ */
+#ifdef PNG_DEBUG
+#if (PNG_DEBUG > 0)
+#if !defined(PNG_DEBUG_FILE) && defined(_MSC_VER)
+#include <crtdbg.h>
+#if (PNG_DEBUG > 1)
+#define png_debug(l,m) _RPT0(_CRT_WARN,m)
+#define png_debug1(l,m,p1) _RPT1(_CRT_WARN,m,p1)
+#define png_debug2(l,m,p1,p2) _RPT2(_CRT_WARN,m,p1,p2)
+#endif
+#else /* PNG_DEBUG_FILE || !_MSC_VER */
+#ifndef PNG_DEBUG_FILE
+#define PNG_DEBUG_FILE stderr
+#endif /* PNG_DEBUG_FILE */
+#if (PNG_DEBUG > 1)
+#define png_debug(l,m) \
+{ \
+ int num_tabs=l; \
+ fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \
+ (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":"")))); \
+}
+#define png_debug1(l,m,p1) \
+{ \
+ int num_tabs=l; \
+ fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \
+ (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1); \
+}
+#define png_debug2(l,m,p1,p2) \
+{ \
+ int num_tabs=l; \
+ fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \
+ (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1,p2); \
+}
+#endif /* (PNG_DEBUG > 1) */
+#endif /* _MSC_VER */
+#endif /* (PNG_DEBUG > 0) */
+#endif /* PNG_DEBUG */
+#ifndef png_debug
+#define png_debug(l, m)
+#endif
+#ifndef png_debug1
+#define png_debug1(l, m, p1)
+#endif
+#ifndef png_debug2
+#define png_debug2(l, m, p1, p2)
+#endif
+
+extern PNG_EXPORT(png_charp,png_get_copyright) PNGARG((png_structp png_ptr));
+extern PNG_EXPORT(png_charp,png_get_header_ver) PNGARG((png_structp png_ptr));
+extern PNG_EXPORT(png_charp,png_get_header_version) PNGARG((png_structp png_ptr));
+extern PNG_EXPORT(png_charp,png_get_libpng_ver) PNGARG((png_structp png_ptr));
+
+#ifdef PNG_MNG_FEATURES_SUPPORTED
+extern PNG_EXPORT(png_uint_32,png_permit_mng_features) PNGARG((png_structp
+ png_ptr, png_uint_32 mng_features_permitted));
+#endif
+
+/* For use in png_set_keep_unknown, added to version 1.2.6 */
+#define PNG_HANDLE_CHUNK_AS_DEFAULT 0
+#define PNG_HANDLE_CHUNK_NEVER 1
+#define PNG_HANDLE_CHUNK_IF_SAFE 2
+#define PNG_HANDLE_CHUNK_ALWAYS 3
+
+/* Added to version 1.2.0 */
+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED)
+#if defined(PNG_MMX_CODE_SUPPORTED)
+#define PNG_ASM_FLAG_MMX_SUPPORT_COMPILED 0x01 /* not user-settable */
+#define PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU 0x02 /* not user-settable */
+#define PNG_ASM_FLAG_MMX_READ_COMBINE_ROW 0x04
+#define PNG_ASM_FLAG_MMX_READ_INTERLACE 0x08
+#define PNG_ASM_FLAG_MMX_READ_FILTER_SUB 0x10
+#define PNG_ASM_FLAG_MMX_READ_FILTER_UP 0x20
+#define PNG_ASM_FLAG_MMX_READ_FILTER_AVG 0x40
+#define PNG_ASM_FLAG_MMX_READ_FILTER_PAETH 0x80
+#define PNG_ASM_FLAGS_INITIALIZED 0x80000000 /* not user-settable */
+
+#define PNG_MMX_READ_FLAGS ( PNG_ASM_FLAG_MMX_READ_COMBINE_ROW \
+ | PNG_ASM_FLAG_MMX_READ_INTERLACE \
+ | PNG_ASM_FLAG_MMX_READ_FILTER_SUB \
+ | PNG_ASM_FLAG_MMX_READ_FILTER_UP \
+ | PNG_ASM_FLAG_MMX_READ_FILTER_AVG \
+ | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH )
+#define PNG_MMX_WRITE_FLAGS ( 0 )
+
+#define PNG_MMX_FLAGS ( PNG_ASM_FLAG_MMX_SUPPORT_COMPILED \
+ | PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU \
+ | PNG_MMX_READ_FLAGS \
+ | PNG_MMX_WRITE_FLAGS )
+
+#define PNG_SELECT_READ 1
+#define PNG_SELECT_WRITE 2
+#endif /* PNG_MMX_CODE_SUPPORTED */
+
+#if !defined(PNG_1_0_X)
+/* pngget.c */
+extern PNG_EXPORT(png_uint_32,png_get_mmx_flagmask)
+ PNGARG((int flag_select, int *compilerID));
+
+/* pngget.c */
+extern PNG_EXPORT(png_uint_32,png_get_asm_flagmask)
+ PNGARG((int flag_select));
+
+/* pngget.c */
+extern PNG_EXPORT(png_uint_32,png_get_asm_flags)
+ PNGARG((png_structp png_ptr));
+
+/* pngget.c */
+extern PNG_EXPORT(png_byte,png_get_mmx_bitdepth_threshold)
+ PNGARG((png_structp png_ptr));
+
+/* pngget.c */
+extern PNG_EXPORT(png_uint_32,png_get_mmx_rowbytes_threshold)
+ PNGARG((png_structp png_ptr));
+
+/* pngset.c */
+extern PNG_EXPORT(void,png_set_asm_flags)
+ PNGARG((png_structp png_ptr, png_uint_32 asm_flags));
+
+/* pngset.c */
+extern PNG_EXPORT(void,png_set_mmx_thresholds)
+ PNGARG((png_structp png_ptr, png_byte mmx_bitdepth_threshold,
+ png_uint_32 mmx_rowbytes_threshold));
+
+#endif /* PNG_1_0_X */
+
+#if !defined(PNG_1_0_X)
+/* png.c, pnggccrd.c, or pngvcrd.c */
+extern PNG_EXPORT(int,png_mmx_support) PNGARG((void));
+#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */
+
+/* Strip the prepended error numbers ("#nnn ") from error and warning
+ * messages before passing them to the error or warning handler. */
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED
+extern PNG_EXPORT(void,png_set_strip_error_numbers) PNGARG((png_structp
+ png_ptr, png_uint_32 strip_mode));
+#endif
+
+#endif /* PNG_1_0_X */
+
+/* Added at libpng-1.2.6 */
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED
+extern PNG_EXPORT(void,png_set_user_limits) PNGARG((png_structp
+ png_ptr, png_uint_32 user_width_max, png_uint_32 user_height_max));
+extern PNG_EXPORT(png_uint_32,png_get_user_width_max) PNGARG((png_structp
+ png_ptr));
+extern PNG_EXPORT(png_uint_32,png_get_user_height_max) PNGARG((png_structp
+ png_ptr));
+#endif
+
+
+/* Maintainer: Put new public prototypes here ^, in libpng.3, and project defs */
+
+#ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED
+/* With these routines we avoid an integer divide, which will be slower on
+ * most machines. However, it does take more operations than the corresponding
+ * divide method, so it may be slower on a few RISC systems. There are two
+ * shifts (by 8 or 16 bits) and an addition, versus a single integer divide.
+ *
+ * Note that the rounding factors are NOT supposed to be the same! 128 and
+ * 32768 are correct for the NODIV code; 127 and 32767 are correct for the
+ * standard method.
+ *
+ * [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ]
+ */
+
+ /* fg and bg should be in `gamma 1.0' space; alpha is the opacity */
+
+# define png_composite(composite, fg, alpha, bg) \
+ { png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) * (png_uint_16)(alpha) \
+ + (png_uint_16)(bg)*(png_uint_16)(255 - \
+ (png_uint_16)(alpha)) + (png_uint_16)128); \
+ (composite) = (png_byte)((temp + (temp >> 8)) >> 8); }
+
+# define png_composite_16(composite, fg, alpha, bg) \
+ { png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) * (png_uint_32)(alpha) \
+ + (png_uint_32)(bg)*(png_uint_32)(65535L - \
+ (png_uint_32)(alpha)) + (png_uint_32)32768L); \
+ (composite) = (png_uint_16)((temp + (temp >> 16)) >> 16); }
+
+#else /* standard method using integer division */
+
+# define png_composite(composite, fg, alpha, bg) \
+ (composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) + \
+ (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \
+ (png_uint_16)127) / 255)
+
+# define png_composite_16(composite, fg, alpha, bg) \
+ (composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \
+ (png_uint_32)(bg)*(png_uint_32)(65535L - (png_uint_32)(alpha)) + \
+ (png_uint_32)32767) / (png_uint_32)65535L)
+
+#endif /* PNG_READ_COMPOSITE_NODIV_SUPPORTED */
+
+/* Inline macros to do direct reads of bytes from the input buffer. These
+ * require that you are using an architecture that uses PNG byte ordering
+ * (MSB first) and supports unaligned data storage. I think that PowerPC
+ * in big-endian mode and 680x0 are the only ones that will support this.
+ * The x86 line of processors definitely do not. The png_get_int_32()
+ * routine also assumes we are using two's complement format for negative
+ * values, which is almost certainly true.
+ */
+#if defined(PNG_READ_BIG_ENDIAN_SUPPORTED)
+# define png_get_uint_32(buf) ( *((png_uint_32p) (buf)))
+# define png_get_uint_16(buf) ( *((png_uint_16p) (buf)))
+# define png_get_int_32(buf) ( *((png_int_32p) (buf)))
+#else
+extern PNG_EXPORT(png_uint_32,png_get_uint_32) PNGARG((png_bytep buf));
+extern PNG_EXPORT(png_uint_16,png_get_uint_16) PNGARG((png_bytep buf));
+extern PNG_EXPORT(png_int_32,png_get_int_32) PNGARG((png_bytep buf));
+#endif /* !PNG_READ_BIG_ENDIAN_SUPPORTED */
+extern PNG_EXPORT(png_uint_32,png_get_uint_31)
+ PNGARG((png_structp png_ptr, png_bytep buf));
+/* No png_get_int_16 -- may be added if there's a real need for it. */
+
+/* Place a 32-bit number into a buffer in PNG byte order (big-endian).
+ */
+extern PNG_EXPORT(void,png_save_uint_32)
+ PNGARG((png_bytep buf, png_uint_32 i));
+extern PNG_EXPORT(void,png_save_int_32)
+ PNGARG((png_bytep buf, png_int_32 i));
+
+/* Place a 16-bit number into a buffer in PNG byte order.
+ * The parameter is declared unsigned int, not png_uint_16,
+ * just to avoid potential problems on pre-ANSI C compilers.
+ */
+extern PNG_EXPORT(void,png_save_uint_16)
+ PNGARG((png_bytep buf, unsigned int i));
+/* No png_save_int_16 -- may be added if there's a real need for it. */
+
+/* ************************************************************************* */
+
+/* These next functions are used internally in the code. They generally
+ * shouldn't be used unless you are writing code to add or replace some
+ * functionality in libpng. More information about most functions can
+ * be found in the files where the functions are located.
+ */
+
+
+/* Various modes of operation, that are visible to applications because
+ * they are used for unknown chunk location.
+ */
+#define PNG_HAVE_IHDR 0x01
+#define PNG_HAVE_PLTE 0x02
+#define PNG_HAVE_IDAT 0x04
+#define PNG_AFTER_IDAT 0x08 /* Have complete zlib datastream */
+#define PNG_HAVE_IEND 0x10
+
+#if defined(PNG_INTERNAL)
+
+/* More modes of operation. Note that after an init, mode is set to
+ * zero automatically when the structure is created.
+ */
+#define PNG_HAVE_gAMA 0x20
+#define PNG_HAVE_cHRM 0x40
+#define PNG_HAVE_sRGB 0x80
+#define PNG_HAVE_CHUNK_HEADER 0x100
+#define PNG_WROTE_tIME 0x200
+#define PNG_WROTE_INFO_BEFORE_PLTE 0x400
+#define PNG_BACKGROUND_IS_GRAY 0x800
+#define PNG_HAVE_PNG_SIGNATURE 0x1000
+#define PNG_HAVE_CHUNK_AFTER_IDAT 0x2000 /* Have another chunk after IDAT */
+
+/* flags for the transformations the PNG library does on the image data */
+#define PNG_BGR 0x0001
+#define PNG_INTERLACE 0x0002
+#define PNG_PACK 0x0004
+#define PNG_SHIFT 0x0008
+#define PNG_SWAP_BYTES 0x0010
+#define PNG_INVERT_MONO 0x0020
+#define PNG_DITHER 0x0040
+#define PNG_BACKGROUND 0x0080
+#define PNG_BACKGROUND_EXPAND 0x0100
+ /* 0x0200 unused */
+#define PNG_16_TO_8 0x0400
+#define PNG_RGBA 0x0800
+#define PNG_EXPAND 0x1000
+#define PNG_GAMMA 0x2000
+#define PNG_GRAY_TO_RGB 0x4000
+#define PNG_FILLER 0x8000L
+#define PNG_PACKSWAP 0x10000L
+#define PNG_SWAP_ALPHA 0x20000L
+#define PNG_STRIP_ALPHA 0x40000L
+#define PNG_INVERT_ALPHA 0x80000L
+#define PNG_USER_TRANSFORM 0x100000L
+#define PNG_RGB_TO_GRAY_ERR 0x200000L
+#define PNG_RGB_TO_GRAY_WARN 0x400000L
+#define PNG_RGB_TO_GRAY 0x600000L /* two bits, RGB_TO_GRAY_ERR|WARN */
+ /* 0x800000L Unused */
+#define PNG_ADD_ALPHA 0x1000000L /* Added to libpng-1.2.7 */
+#define PNG_EXPAND_tRNS 0x2000000L /* Added to libpng-1.2.9 */
+ /* 0x4000000L unused */
+ /* 0x8000000L unused */
+ /* 0x10000000L unused */
+ /* 0x20000000L unused */
+ /* 0x40000000L unused */
+
+/* flags for png_create_struct */
+#define PNG_STRUCT_PNG 0x0001
+#define PNG_STRUCT_INFO 0x0002
+
+/* Scaling factor for filter heuristic weighting calculations */
+#define PNG_WEIGHT_SHIFT 8
+#define PNG_WEIGHT_FACTOR (1<<(PNG_WEIGHT_SHIFT))
+#define PNG_COST_SHIFT 3
+#define PNG_COST_FACTOR (1<<(PNG_COST_SHIFT))
+
+/* flags for the png_ptr->flags rather than declaring a byte for each one */
+#define PNG_FLAG_ZLIB_CUSTOM_STRATEGY 0x0001
+#define PNG_FLAG_ZLIB_CUSTOM_LEVEL 0x0002
+#define PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL 0x0004
+#define PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS 0x0008
+#define PNG_FLAG_ZLIB_CUSTOM_METHOD 0x0010
+#define PNG_FLAG_ZLIB_FINISHED 0x0020
+#define PNG_FLAG_ROW_INIT 0x0040
+#define PNG_FLAG_FILLER_AFTER 0x0080
+#define PNG_FLAG_CRC_ANCILLARY_USE 0x0100
+#define PNG_FLAG_CRC_ANCILLARY_NOWARN 0x0200
+#define PNG_FLAG_CRC_CRITICAL_USE 0x0400
+#define PNG_FLAG_CRC_CRITICAL_IGNORE 0x0800
+#define PNG_FLAG_FREE_PLTE 0x1000
+#define PNG_FLAG_FREE_TRNS 0x2000
+#define PNG_FLAG_FREE_HIST 0x4000
+#define PNG_FLAG_KEEP_UNKNOWN_CHUNKS 0x8000L
+#define PNG_FLAG_KEEP_UNSAFE_CHUNKS 0x10000L
+#define PNG_FLAG_LIBRARY_MISMATCH 0x20000L
+#define PNG_FLAG_STRIP_ERROR_NUMBERS 0x40000L
+#define PNG_FLAG_STRIP_ERROR_TEXT 0x80000L
+#define PNG_FLAG_MALLOC_NULL_MEM_OK 0x100000L
+#define PNG_FLAG_ADD_ALPHA 0x200000L /* Added to libpng-1.2.8 */
+#define PNG_FLAG_STRIP_ALPHA 0x400000L /* Added to libpng-1.2.8 */
+ /* 0x800000L unused */
+ /* 0x1000000L unused */
+ /* 0x2000000L unused */
+ /* 0x4000000L unused */
+ /* 0x8000000L unused */
+ /* 0x10000000L unused */
+ /* 0x20000000L unused */
+ /* 0x40000000L unused */
+
+#define PNG_FLAG_CRC_ANCILLARY_MASK (PNG_FLAG_CRC_ANCILLARY_USE | \
+ PNG_FLAG_CRC_ANCILLARY_NOWARN)
+
+#define PNG_FLAG_CRC_CRITICAL_MASK (PNG_FLAG_CRC_CRITICAL_USE | \
+ PNG_FLAG_CRC_CRITICAL_IGNORE)
+
+#define PNG_FLAG_CRC_MASK (PNG_FLAG_CRC_ANCILLARY_MASK | \
+ PNG_FLAG_CRC_CRITICAL_MASK)
+
+/* save typing and make code easier to understand */
+
+#define PNG_COLOR_DIST(c1, c2) (abs((int)((c1).red) - (int)((c2).red)) + \
+ abs((int)((c1).green) - (int)((c2).green)) + \
+ abs((int)((c1).blue) - (int)((c2).blue)))
+
+/* Added to libpng-1.2.6 JB */
+#define PNG_ROWBYTES(pixel_bits, width) \
+ ((pixel_bits) >= 8 ? \
+ ((width) * (((png_uint_32)(pixel_bits)) >> 3)) : \
+ (( ((width) * ((png_uint_32)(pixel_bits))) + 7) >> 3) )
+
+/* PNG_OUT_OF_RANGE returns true if value is outside the range
+ ideal-delta..ideal+delta. Each argument is evaluated twice.
+ "ideal" and "delta" should be constants, normally simple
+ integers, "value" a variable. Added to libpng-1.2.6 JB */
+#define PNG_OUT_OF_RANGE(value, ideal, delta) \
+ ( (value) < (ideal)-(delta) || (value) > (ideal)+(delta) )
+
+/* variables declared in png.c - only it needs to define PNG_NO_EXTERN */
+#if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN)
+/* place to hold the signature string for a PNG file. */
+#ifdef PNG_USE_GLOBAL_ARRAYS
+ PNG_EXPORT_VAR (PNG_CONST png_byte FARDATA) png_sig[8];
+#else
+#endif
+#endif /* PNG_NO_EXTERN */
+
+/* Constant strings for known chunk types. If you need to add a chunk,
+ * define the name here, and add an invocation of the macro in png.c and
+ * wherever it's needed.
+ */
+#define PNG_IHDR png_byte png_IHDR[5] = { 73, 72, 68, 82, '\0'}
+#define PNG_IDAT png_byte png_IDAT[5] = { 73, 68, 65, 84, '\0'}
+#define PNG_IEND png_byte png_IEND[5] = { 73, 69, 78, 68, '\0'}
+#define PNG_PLTE png_byte png_PLTE[5] = { 80, 76, 84, 69, '\0'}
+#define PNG_bKGD png_byte png_bKGD[5] = { 98, 75, 71, 68, '\0'}
+#define PNG_cHRM png_byte png_cHRM[5] = { 99, 72, 82, 77, '\0'}
+#define PNG_gAMA png_byte png_gAMA[5] = {103, 65, 77, 65, '\0'}
+#define PNG_hIST png_byte png_hIST[5] = {104, 73, 83, 84, '\0'}
+#define PNG_iCCP png_byte png_iCCP[5] = {105, 67, 67, 80, '\0'}
+#define PNG_iTXt png_byte png_iTXt[5] = {105, 84, 88, 116, '\0'}
+#define PNG_oFFs png_byte png_oFFs[5] = {111, 70, 70, 115, '\0'}
+#define PNG_pCAL png_byte png_pCAL[5] = {112, 67, 65, 76, '\0'}
+#define PNG_sCAL png_byte png_sCAL[5] = {115, 67, 65, 76, '\0'}
+#define PNG_pHYs png_byte png_pHYs[5] = {112, 72, 89, 115, '\0'}
+#define PNG_sBIT png_byte png_sBIT[5] = {115, 66, 73, 84, '\0'}
+#define PNG_sPLT png_byte png_sPLT[5] = {115, 80, 76, 84, '\0'}
+#define PNG_sRGB png_byte png_sRGB[5] = {115, 82, 71, 66, '\0'}
+#define PNG_tEXt png_byte png_tEXt[5] = {116, 69, 88, 116, '\0'}
+#define PNG_tIME png_byte png_tIME[5] = {116, 73, 77, 69, '\0'}
+#define PNG_tRNS png_byte png_tRNS[5] = {116, 82, 78, 83, '\0'}
+#define PNG_zTXt png_byte png_zTXt[5] = {122, 84, 88, 116, '\0'}
+
+#ifdef PNG_USE_GLOBAL_ARRAYS
+PNG_EXPORT_VAR (png_byte FARDATA) png_IHDR[5];
+PNG_EXPORT_VAR (png_byte FARDATA) png_IDAT[5];
+PNG_EXPORT_VAR (png_byte FARDATA) png_IEND[5];
+PNG_EXPORT_VAR (png_byte FARDATA) png_PLTE[5];
+PNG_EXPORT_VAR (png_byte FARDATA) png_bKGD[5];
+PNG_EXPORT_VAR (png_byte FARDATA) png_cHRM[5];
+PNG_EXPORT_VAR (png_byte FARDATA) png_gAMA[5];
+PNG_EXPORT_VAR (png_byte FARDATA) png_hIST[5];
+PNG_EXPORT_VAR (png_byte FARDATA) png_iCCP[5];
+PNG_EXPORT_VAR (png_byte FARDATA) png_iTXt[5];
+PNG_EXPORT_VAR (png_byte FARDATA) png_oFFs[5];
+PNG_EXPORT_VAR (png_byte FARDATA) png_pCAL[5];
+PNG_EXPORT_VAR (png_byte FARDATA) png_sCAL[5];
+PNG_EXPORT_VAR (png_byte FARDATA) png_pHYs[5];
+PNG_EXPORT_VAR (png_byte FARDATA) png_sBIT[5];
+PNG_EXPORT_VAR (png_byte FARDATA) png_sPLT[5];
+PNG_EXPORT_VAR (png_byte FARDATA) png_sRGB[5];
+PNG_EXPORT_VAR (png_byte FARDATA) png_tEXt[5];
+PNG_EXPORT_VAR (png_byte FARDATA) png_tIME[5];
+PNG_EXPORT_VAR (png_byte FARDATA) png_tRNS[5];
+PNG_EXPORT_VAR (png_byte FARDATA) png_zTXt[5];
+#endif /* PNG_USE_GLOBAL_ARRAYS */
+
+#if defined(PNG_1_0_X) || defined (PNG_1_2_X)
+/* Initialize png_ptr struct for reading, and allocate any other memory.
+ * (old interface - DEPRECATED - use png_create_read_struct instead).
+ */
+extern PNG_EXPORT(void,png_read_init) PNGARG((png_structp png_ptr));
+#undef png_read_init
+#define png_read_init(png_ptr) png_read_init_3(&png_ptr, \
+ PNG_LIBPNG_VER_STRING, png_sizeof(png_struct));
+#endif
+
+extern PNG_EXPORT(void,png_read_init_3) PNGARG((png_structpp ptr_ptr,
+ png_const_charp user_png_ver, png_size_t png_struct_size));
+#if defined(PNG_1_0_X) || defined (PNG_1_2_X)
+extern PNG_EXPORT(void,png_read_init_2) PNGARG((png_structp png_ptr,
+ png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t
+ png_info_size));
+#endif
+
+#if defined(PNG_1_0_X) || defined (PNG_1_2_X)
+/* Initialize png_ptr struct for writing, and allocate any other memory.
+ * (old interface - DEPRECATED - use png_create_write_struct instead).
+ */
+extern PNG_EXPORT(void,png_write_init) PNGARG((png_structp png_ptr));
+#undef png_write_init
+#define png_write_init(png_ptr) png_write_init_3(&png_ptr, \
+ PNG_LIBPNG_VER_STRING, png_sizeof(png_struct));
+#endif
+
+extern PNG_EXPORT(void,png_write_init_3) PNGARG((png_structpp ptr_ptr,
+ png_const_charp user_png_ver, png_size_t png_struct_size));
+extern PNG_EXPORT(void,png_write_init_2) PNGARG((png_structp png_ptr,
+ png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t
+ png_info_size));
+
+/* Allocate memory for an internal libpng struct */
+PNG_EXTERN png_voidp png_create_struct PNGARG((int type));
+
+/* Free memory from internal libpng struct */
+PNG_EXTERN void png_destroy_struct PNGARG((png_voidp struct_ptr));
+
+PNG_EXTERN png_voidp png_create_struct_2 PNGARG((int type, png_malloc_ptr
+ malloc_fn, png_voidp mem_ptr));
+PNG_EXTERN void png_destroy_struct_2 PNGARG((png_voidp struct_ptr,
+ png_free_ptr free_fn, png_voidp mem_ptr));
+
+/* Free any memory that info_ptr points to and reset struct. */
+PNG_EXTERN void png_info_destroy PNGARG((png_structp png_ptr,
+ png_infop info_ptr));
+
+#ifndef PNG_1_0_X
+/* Function to allocate memory for zlib. */
+PNG_EXTERN voidpf png_zalloc PNGARG((voidpf png_ptr, uInt items, uInt size));
+
+/* Function to free memory for zlib */
+PNG_EXTERN void png_zfree PNGARG((voidpf png_ptr, voidpf ptr));
+
+#ifdef PNG_SIZE_T
+/* Function to convert a sizeof an item to png_sizeof item */
+ PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size));
+#endif
+
+/* Next four functions are used internally as callbacks. PNGAPI is required
+ * but not PNG_EXPORT. PNGAPI added at libpng version 1.2.3. */
+
+PNG_EXTERN void PNGAPI png_default_read_data PNGARG((png_structp png_ptr,
+ png_bytep data, png_size_t length));
+
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
+PNG_EXTERN void PNGAPI png_push_fill_buffer PNGARG((png_structp png_ptr,
+ png_bytep buffer, png_size_t length));
+#endif
+
+PNG_EXTERN void PNGAPI png_default_write_data PNGARG((png_structp png_ptr,
+ png_bytep data, png_size_t length));
+
+#if defined(PNG_WRITE_FLUSH_SUPPORTED)
+#if !defined(PNG_NO_STDIO)
+PNG_EXTERN void PNGAPI png_default_flush PNGARG((png_structp png_ptr));
+#endif
+#endif
+#else /* PNG_1_0_X */
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
+PNG_EXTERN void png_push_fill_buffer PNGARG((png_structp png_ptr,
+ png_bytep buffer, png_size_t length));
+#endif
+#endif /* PNG_1_0_X */
+
+/* Reset the CRC variable */
+PNG_EXTERN void png_reset_crc PNGARG((png_structp png_ptr));
+
+/* Write the "data" buffer to whatever output you are using. */
+PNG_EXTERN void png_write_data PNGARG((png_structp png_ptr, png_bytep data,
+ png_size_t length));
+
+/* Read data from whatever input you are using into the "data" buffer */
+PNG_EXTERN void png_read_data PNGARG((png_structp png_ptr, png_bytep data,
+ png_size_t length));
+
+/* Read bytes into buf, and update png_ptr->crc */
+PNG_EXTERN void png_crc_read PNGARG((png_structp png_ptr, png_bytep buf,
+ png_size_t length));
+
+/* Decompress data in a chunk that uses compression */
+#if defined(PNG_zTXt_SUPPORTED) || defined(PNG_iTXt_SUPPORTED) || \
+ defined(PNG_iCCP_SUPPORTED) || defined(PNG_sPLT_SUPPORTED)
+PNG_EXTERN void png_decompress_chunk PNGARG((png_structp png_ptr,
+ int comp_type, png_size_t chunklength,
+ png_size_t prefix_length, png_size_t *data_length));
+#endif
+
+/* Read "skip" bytes, read the file crc, and (optionally) verify png_ptr->crc */
+PNG_EXTERN int png_crc_finish PNGARG((png_structp png_ptr, png_uint_32 skip));
+
+/* Read the CRC from the file and compare it to the libpng calculated CRC */
+PNG_EXTERN int png_crc_error PNGARG((png_structp png_ptr));
+
+/* Calculate the CRC over a section of data. Note that we are only
+ * passing a maximum of 64K on systems that have this as a memory limit,
+ * since this is the maximum buffer size we can specify.
+ */
+PNG_EXTERN void png_calculate_crc PNGARG((png_structp png_ptr, png_bytep ptr,
+ png_size_t length));
+
+#if defined(PNG_WRITE_FLUSH_SUPPORTED)
+PNG_EXTERN void png_flush PNGARG((png_structp png_ptr));
+#endif
+
+/* simple function to write the signature */
+PNG_EXTERN void png_write_sig PNGARG((png_structp png_ptr));
+
+/* write various chunks */
+
+/* Write the IHDR chunk, and update the png_struct with the necessary
+ * information.
+ */
+PNG_EXTERN void png_write_IHDR PNGARG((png_structp png_ptr, png_uint_32 width,
+ png_uint_32 height,
+ int bit_depth, int color_type, int compression_method, int filter_method,
+ int interlace_method));
+
+PNG_EXTERN void png_write_PLTE PNGARG((png_structp png_ptr, png_colorp palette,
+ png_uint_32 num_pal));
+
+PNG_EXTERN void png_write_IDAT PNGARG((png_structp png_ptr, png_bytep data,
+ png_size_t length));
+
+PNG_EXTERN void png_write_IEND PNGARG((png_structp png_ptr));
+
+#if defined(PNG_WRITE_gAMA_SUPPORTED)
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+PNG_EXTERN void png_write_gAMA PNGARG((png_structp png_ptr, double file_gamma));
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+PNG_EXTERN void png_write_gAMA_fixed PNGARG((png_structp png_ptr, png_fixed_point
+ file_gamma));
+#endif
+#endif
+
+#if defined(PNG_WRITE_sBIT_SUPPORTED)
+PNG_EXTERN void png_write_sBIT PNGARG((png_structp png_ptr, png_color_8p sbit,
+ int color_type));
+#endif
+
+#if defined(PNG_WRITE_cHRM_SUPPORTED)
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+PNG_EXTERN void png_write_cHRM PNGARG((png_structp png_ptr,
+ double white_x, double white_y,
+ double red_x, double red_y, double green_x, double green_y,
+ double blue_x, double blue_y));
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+PNG_EXTERN void png_write_cHRM_fixed PNGARG((png_structp png_ptr,
+ png_fixed_point int_white_x, png_fixed_point int_white_y,
+ png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point
+ int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x,
+ png_fixed_point int_blue_y));
+#endif
+#endif
+
+#if defined(PNG_WRITE_sRGB_SUPPORTED)
+PNG_EXTERN void png_write_sRGB PNGARG((png_structp png_ptr,
+ int intent));
+#endif
+
+#if defined(PNG_WRITE_iCCP_SUPPORTED)
+PNG_EXTERN void png_write_iCCP PNGARG((png_structp png_ptr,
+ png_charp name, int compression_type,
+ png_charp profile, int proflen));
+ /* Note to maintainer: profile should be png_bytep */
+#endif
+
+#if defined(PNG_WRITE_sPLT_SUPPORTED)
+PNG_EXTERN void png_write_sPLT PNGARG((png_structp png_ptr,
+ png_sPLT_tp palette));
+#endif
+
+#if defined(PNG_WRITE_tRNS_SUPPORTED)
+PNG_EXTERN void png_write_tRNS PNGARG((png_structp png_ptr, png_bytep trans,
+ png_color_16p values, int number, int color_type));
+#endif
+
+#if defined(PNG_WRITE_bKGD_SUPPORTED)
+PNG_EXTERN void png_write_bKGD PNGARG((png_structp png_ptr,
+ png_color_16p values, int color_type));
+#endif
+
+#if defined(PNG_WRITE_hIST_SUPPORTED)
+PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr, png_uint_16p hist,
+ int num_hist));
+#endif
+
+#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \
+ defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)
+PNG_EXTERN png_size_t png_check_keyword PNGARG((png_structp png_ptr,
+ png_charp key, png_charpp new_key));
+#endif
+
+#if defined(PNG_WRITE_tEXt_SUPPORTED)
+PNG_EXTERN void png_write_tEXt PNGARG((png_structp png_ptr, png_charp key,
+ png_charp text, png_size_t text_len));
+#endif
+
+#if defined(PNG_WRITE_zTXt_SUPPORTED)
+PNG_EXTERN void png_write_zTXt PNGARG((png_structp png_ptr, png_charp key,
+ png_charp text, png_size_t text_len, int compression));
+#endif
+
+#if defined(PNG_WRITE_iTXt_SUPPORTED)
+PNG_EXTERN void png_write_iTXt PNGARG((png_structp png_ptr,
+ int compression, png_charp key, png_charp lang, png_charp lang_key,
+ png_charp text));
+#endif
+
+#if defined(PNG_TEXT_SUPPORTED) /* Added at version 1.0.14 and 1.2.4 */
+PNG_EXTERN int png_set_text_2 PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_textp text_ptr, int num_text));
+#endif
+
+#if defined(PNG_WRITE_oFFs_SUPPORTED)
+PNG_EXTERN void png_write_oFFs PNGARG((png_structp png_ptr,
+ png_int_32 x_offset, png_int_32 y_offset, int unit_type));
+#endif
+
+#if defined(PNG_WRITE_pCAL_SUPPORTED)
+PNG_EXTERN void png_write_pCAL PNGARG((png_structp png_ptr, png_charp purpose,
+ png_int_32 X0, png_int_32 X1, int type, int nparams,
+ png_charp units, png_charpp params));
+#endif
+
+#if defined(PNG_WRITE_pHYs_SUPPORTED)
+PNG_EXTERN void png_write_pHYs PNGARG((png_structp png_ptr,
+ png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit,
+ int unit_type));
+#endif
+
+#if defined(PNG_WRITE_tIME_SUPPORTED)
+PNG_EXTERN void png_write_tIME PNGARG((png_structp png_ptr,
+ png_timep mod_time));
+#endif
+
+#if defined(PNG_WRITE_sCAL_SUPPORTED)
+#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO)
+PNG_EXTERN void png_write_sCAL PNGARG((png_structp png_ptr,
+ int unit, double width, double height));
+#else
+#ifdef PNG_FIXED_POINT_SUPPORTED
+PNG_EXTERN void png_write_sCAL_s PNGARG((png_structp png_ptr,
+ int unit, png_charp width, png_charp height));
+#endif
+#endif
+#endif
+
+/* Called when finished processing a row of data */
+PNG_EXTERN void png_write_finish_row PNGARG((png_structp png_ptr));
+
+/* Internal use only. Called before first row of data */
+PNG_EXTERN void png_write_start_row PNGARG((png_structp png_ptr));
+
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+PNG_EXTERN void png_build_gamma_table PNGARG((png_structp png_ptr));
+#endif
+
+/* combine a row of data, dealing with alpha, etc. if requested */
+PNG_EXTERN void png_combine_row PNGARG((png_structp png_ptr, png_bytep row,
+ int mask));
+
+#if defined(PNG_READ_INTERLACING_SUPPORTED)
+/* expand an interlaced row */
+/* OLD pre-1.0.9 interface:
+PNG_EXTERN void png_do_read_interlace PNGARG((png_row_infop row_info,
+ png_bytep row, int pass, png_uint_32 transformations));
+ */
+PNG_EXTERN void png_do_read_interlace PNGARG((png_structp png_ptr));
+#endif
+
+/* GRR TO DO (2.0 or whenever): simplify other internal calling interfaces */
+
+#if defined(PNG_WRITE_INTERLACING_SUPPORTED)
+/* grab pixels out of a row for an interlaced pass */
+PNG_EXTERN void png_do_write_interlace PNGARG((png_row_infop row_info,
+ png_bytep row, int pass));
+#endif
+
+/* unfilter a row */
+PNG_EXTERN void png_read_filter_row PNGARG((png_structp png_ptr,
+ png_row_infop row_info, png_bytep row, png_bytep prev_row, int filter));
+
+/* Choose the best filter to use and filter the row data */
+PNG_EXTERN void png_write_find_filter PNGARG((png_structp png_ptr,
+ png_row_infop row_info));
+
+/* Write out the filtered row. */
+PNG_EXTERN void png_write_filtered_row PNGARG((png_structp png_ptr,
+ png_bytep filtered_row));
+/* finish a row while reading, dealing with interlacing passes, etc. */
+PNG_EXTERN void png_read_finish_row PNGARG((png_structp png_ptr));
+
+/* initialize the row buffers, etc. */
+PNG_EXTERN void png_read_start_row PNGARG((png_structp png_ptr));
+/* optional call to update the users info structure */
+PNG_EXTERN void png_read_transform_info PNGARG((png_structp png_ptr,
+ png_infop info_ptr));
+
+/* these are the functions that do the transformations */
+#if defined(PNG_READ_FILLER_SUPPORTED)
+PNG_EXTERN void png_do_read_filler PNGARG((png_row_infop row_info,
+ png_bytep row, png_uint_32 filler, png_uint_32 flags));
+#endif
+
+#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)
+PNG_EXTERN void png_do_read_swap_alpha PNGARG((png_row_infop row_info,
+ png_bytep row));
+#endif
+
+#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
+PNG_EXTERN void png_do_write_swap_alpha PNGARG((png_row_infop row_info,
+ png_bytep row));
+#endif
+
+#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
+PNG_EXTERN void png_do_read_invert_alpha PNGARG((png_row_infop row_info,
+ png_bytep row));
+#endif
+
+#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
+PNG_EXTERN void png_do_write_invert_alpha PNGARG((png_row_infop row_info,
+ png_bytep row));
+#endif
+
+#if defined(PNG_WRITE_FILLER_SUPPORTED) || \
+ defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
+PNG_EXTERN void png_do_strip_filler PNGARG((png_row_infop row_info,
+ png_bytep row, png_uint_32 flags));
+#endif
+
+#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
+PNG_EXTERN void png_do_swap PNGARG((png_row_infop row_info, png_bytep row));
+#endif
+
+#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED)
+PNG_EXTERN void png_do_packswap PNGARG((png_row_infop row_info, png_bytep row));
+#endif
+
+#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
+PNG_EXTERN int png_do_rgb_to_gray PNGARG((png_structp png_ptr, png_row_infop
+ row_info, png_bytep row));
+#endif
+
+#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
+PNG_EXTERN void png_do_gray_to_rgb PNGARG((png_row_infop row_info,
+ png_bytep row));
+#endif
+
+#if defined(PNG_READ_PACK_SUPPORTED)
+PNG_EXTERN void png_do_unpack PNGARG((png_row_infop row_info, png_bytep row));
+#endif
+
+#if defined(PNG_READ_SHIFT_SUPPORTED)
+PNG_EXTERN void png_do_unshift PNGARG((png_row_infop row_info, png_bytep row,
+ png_color_8p sig_bits));
+#endif
+
+#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
+PNG_EXTERN void png_do_invert PNGARG((png_row_infop row_info, png_bytep row));
+#endif
+
+#if defined(PNG_READ_16_TO_8_SUPPORTED)
+PNG_EXTERN void png_do_chop PNGARG((png_row_infop row_info, png_bytep row));
+#endif
+
+#if defined(PNG_READ_DITHER_SUPPORTED)
+PNG_EXTERN void png_do_dither PNGARG((png_row_infop row_info,
+ png_bytep row, png_bytep palette_lookup, png_bytep dither_lookup));
+
+# if defined(PNG_CORRECT_PALETTE_SUPPORTED)
+PNG_EXTERN void png_correct_palette PNGARG((png_structp png_ptr,
+ png_colorp palette, int num_palette));
+# endif
+#endif
+
+#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
+PNG_EXTERN void png_do_bgr PNGARG((png_row_infop row_info, png_bytep row));
+#endif
+
+#if defined(PNG_WRITE_PACK_SUPPORTED)
+PNG_EXTERN void png_do_pack PNGARG((png_row_infop row_info,
+ png_bytep row, png_uint_32 bit_depth));
+#endif
+
+#if defined(PNG_WRITE_SHIFT_SUPPORTED)
+PNG_EXTERN void png_do_shift PNGARG((png_row_infop row_info, png_bytep row,
+ png_color_8p bit_depth));
+#endif
+
+#if defined(PNG_READ_BACKGROUND_SUPPORTED)
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row,
+ png_color_16p trans_values, png_color_16p background,
+ png_color_16p background_1,
+ png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1,
+ png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1,
+ png_uint_16pp gamma_16_to_1, int gamma_shift));
+#else
+PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row,
+ png_color_16p trans_values, png_color_16p background));
+#endif
+#endif
+
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+PNG_EXTERN void png_do_gamma PNGARG((png_row_infop row_info, png_bytep row,
+ png_bytep gamma_table, png_uint_16pp gamma_16_table,
+ int gamma_shift));
+#endif
+
+#if defined(PNG_READ_EXPAND_SUPPORTED)
+PNG_EXTERN void png_do_expand_palette PNGARG((png_row_infop row_info,
+ png_bytep row, png_colorp palette, png_bytep trans, int num_trans));
+PNG_EXTERN void png_do_expand PNGARG((png_row_infop row_info,
+ png_bytep row, png_color_16p trans_value));
+#endif
+
+/* The following decodes the appropriate chunks, and does error correction,
+ * then calls the appropriate callback for the chunk if it is valid.
+ */
+
+/* decode the IHDR chunk */
+PNG_EXTERN void png_handle_IHDR PNGARG((png_structp png_ptr, png_infop info_ptr,
+ png_uint_32 length));
+PNG_EXTERN void png_handle_PLTE PNGARG((png_structp png_ptr, png_infop info_ptr,
+ png_uint_32 length));
+PNG_EXTERN void png_handle_IEND PNGARG((png_structp png_ptr, png_infop info_ptr,
+ png_uint_32 length));
+
+#if defined(PNG_READ_bKGD_SUPPORTED)
+PNG_EXTERN void png_handle_bKGD PNGARG((png_structp png_ptr, png_infop info_ptr,
+ png_uint_32 length));
+#endif
+
+#if defined(PNG_READ_cHRM_SUPPORTED)
+PNG_EXTERN void png_handle_cHRM PNGARG((png_structp png_ptr, png_infop info_ptr,
+ png_uint_32 length));
+#endif
+
+#if defined(PNG_READ_gAMA_SUPPORTED)
+PNG_EXTERN void png_handle_gAMA PNGARG((png_structp png_ptr, png_infop info_ptr,
+ png_uint_32 length));
+#endif
+
+#if defined(PNG_READ_hIST_SUPPORTED)
+PNG_EXTERN void png_handle_hIST PNGARG((png_structp png_ptr, png_infop info_ptr,
+ png_uint_32 length));
+#endif
+
+#if defined(PNG_READ_iCCP_SUPPORTED)
+extern void png_handle_iCCP PNGARG((png_structp png_ptr, png_infop info_ptr,
+ png_uint_32 length));
+#endif /* PNG_READ_iCCP_SUPPORTED */
+
+#if defined(PNG_READ_iTXt_SUPPORTED)
+PNG_EXTERN void png_handle_iTXt PNGARG((png_structp png_ptr, png_infop info_ptr,
+ png_uint_32 length));
+#endif
+
+#if defined(PNG_READ_oFFs_SUPPORTED)
+PNG_EXTERN void png_handle_oFFs PNGARG((png_structp png_ptr, png_infop info_ptr,
+ png_uint_32 length));
+#endif
+
+#if defined(PNG_READ_pCAL_SUPPORTED)
+PNG_EXTERN void png_handle_pCAL PNGARG((png_structp png_ptr, png_infop info_ptr,
+ png_uint_32 length));
+#endif
+
+#if defined(PNG_READ_pHYs_SUPPORTED)
+PNG_EXTERN void png_handle_pHYs PNGARG((png_structp png_ptr, png_infop info_ptr,
+ png_uint_32 length));
+#endif
+
+#if defined(PNG_READ_sBIT_SUPPORTED)
+PNG_EXTERN void png_handle_sBIT PNGARG((png_structp png_ptr, png_infop info_ptr,
+ png_uint_32 length));
+#endif
+
+#if defined(PNG_READ_sCAL_SUPPORTED)
+PNG_EXTERN void png_handle_sCAL PNGARG((png_structp png_ptr, png_infop info_ptr,
+ png_uint_32 length));
+#endif
+
+#if defined(PNG_READ_sPLT_SUPPORTED)
+extern void png_handle_sPLT PNGARG((png_structp png_ptr, png_infop info_ptr,
+ png_uint_32 length));
+#endif /* PNG_READ_sPLT_SUPPORTED */
+
+#if defined(PNG_READ_sRGB_SUPPORTED)
+PNG_EXTERN void png_handle_sRGB PNGARG((png_structp png_ptr, png_infop info_ptr,
+ png_uint_32 length));
+#endif
+
+#if defined(PNG_READ_tEXt_SUPPORTED)
+PNG_EXTERN void png_handle_tEXt PNGARG((png_structp png_ptr, png_infop info_ptr,
+ png_uint_32 length));
+#endif
+
+#if defined(PNG_READ_tIME_SUPPORTED)
+PNG_EXTERN void png_handle_tIME PNGARG((png_structp png_ptr, png_infop info_ptr,
+ png_uint_32 length));
+#endif
+
+#if defined(PNG_READ_tRNS_SUPPORTED)
+PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr,
+ png_uint_32 length));
+#endif
+
+#if defined(PNG_READ_zTXt_SUPPORTED)
+PNG_EXTERN void png_handle_zTXt PNGARG((png_structp png_ptr, png_infop info_ptr,
+ png_uint_32 length));
+#endif
+
+PNG_EXTERN void png_handle_unknown PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_uint_32 length));
+
+PNG_EXTERN void png_check_chunk_name PNGARG((png_structp png_ptr,
+ png_bytep chunk_name));
+
+/* handle the transformations for reading and writing */
+PNG_EXTERN void png_do_read_transformations PNGARG((png_structp png_ptr));
+PNG_EXTERN void png_do_write_transformations PNGARG((png_structp png_ptr));
+
+PNG_EXTERN void png_init_read_transformations PNGARG((png_structp png_ptr));
+
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
+PNG_EXTERN void png_push_read_chunk PNGARG((png_structp png_ptr,
+ png_infop info_ptr));
+PNG_EXTERN void png_push_read_sig PNGARG((png_structp png_ptr,
+ png_infop info_ptr));
+PNG_EXTERN void png_push_check_crc PNGARG((png_structp png_ptr));
+PNG_EXTERN void png_push_crc_skip PNGARG((png_structp png_ptr,
+ png_uint_32 length));
+PNG_EXTERN void png_push_crc_finish PNGARG((png_structp png_ptr));
+PNG_EXTERN void png_push_save_buffer PNGARG((png_structp png_ptr));
+PNG_EXTERN void png_push_restore_buffer PNGARG((png_structp png_ptr,
+ png_bytep buffer, png_size_t buffer_length));
+PNG_EXTERN void png_push_read_IDAT PNGARG((png_structp png_ptr));
+PNG_EXTERN void png_process_IDAT_data PNGARG((png_structp png_ptr,
+ png_bytep buffer, png_size_t buffer_length));
+PNG_EXTERN void png_push_process_row PNGARG((png_structp png_ptr));
+PNG_EXTERN void png_push_handle_unknown PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_uint_32 length));
+PNG_EXTERN void png_push_have_info PNGARG((png_structp png_ptr,
+ png_infop info_ptr));
+PNG_EXTERN void png_push_have_end PNGARG((png_structp png_ptr,
+ png_infop info_ptr));
+PNG_EXTERN void png_push_have_row PNGARG((png_structp png_ptr, png_bytep row));
+PNG_EXTERN void png_push_read_end PNGARG((png_structp png_ptr,
+ png_infop info_ptr));
+PNG_EXTERN void png_process_some_data PNGARG((png_structp png_ptr,
+ png_infop info_ptr));
+PNG_EXTERN void png_read_push_finish_row PNGARG((png_structp png_ptr));
+#if defined(PNG_READ_tEXt_SUPPORTED)
+PNG_EXTERN void png_push_handle_tEXt PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_uint_32 length));
+PNG_EXTERN void png_push_read_tEXt PNGARG((png_structp png_ptr,
+ png_infop info_ptr));
+#endif
+#if defined(PNG_READ_zTXt_SUPPORTED)
+PNG_EXTERN void png_push_handle_zTXt PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_uint_32 length));
+PNG_EXTERN void png_push_read_zTXt PNGARG((png_structp png_ptr,
+ png_infop info_ptr));
+#endif
+#if defined(PNG_READ_iTXt_SUPPORTED)
+PNG_EXTERN void png_push_handle_iTXt PNGARG((png_structp png_ptr,
+ png_infop info_ptr, png_uint_32 length));
+PNG_EXTERN void png_push_read_iTXt PNGARG((png_structp png_ptr,
+ png_infop info_ptr));
+#endif
+
+#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
+
+#ifdef PNG_MNG_FEATURES_SUPPORTED
+PNG_EXTERN void png_do_read_intrapixel PNGARG((png_row_infop row_info,
+ png_bytep row));
+PNG_EXTERN void png_do_write_intrapixel PNGARG((png_row_infop row_info,
+ png_bytep row));
+#endif
+
+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED)
+#if defined(PNG_MMX_CODE_SUPPORTED)
+/* png.c */ /* PRIVATE */
+PNG_EXTERN void png_init_mmx_flags PNGARG((png_structp png_ptr));
+#endif
+#endif
+
+#if defined(PNG_INCH_CONVERSIONS) && defined(PNG_FLOATING_POINT_SUPPORTED)
+PNG_EXTERN png_uint_32 png_get_pixels_per_inch PNGARG((png_structp png_ptr,
+png_infop info_ptr));
+
+PNG_EXTERN png_uint_32 png_get_x_pixels_per_inch PNGARG((png_structp png_ptr,
+png_infop info_ptr));
+
+PNG_EXTERN png_uint_32 png_get_y_pixels_per_inch PNGARG((png_structp png_ptr,
+png_infop info_ptr));
+
+PNG_EXTERN float png_get_x_offset_inches PNGARG((png_structp png_ptr,
+png_infop info_ptr));
+
+PNG_EXTERN float png_get_y_offset_inches PNGARG((png_structp png_ptr,
+png_infop info_ptr));
+
+#if defined(PNG_pHYs_SUPPORTED)
+PNG_EXTERN png_uint_32 png_get_pHYs_dpi PNGARG((png_structp png_ptr,
+png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type));
+#endif /* PNG_pHYs_SUPPORTED */
+#endif /* PNG_INCH_CONVERSIONS && PNG_FLOATING_POINT_SUPPORTED */
+
+/* Read the chunk header (length + type name) */
+PNG_EXTERN png_uint_32 png_read_chunk_header PNGARG((png_structp png_ptr));
+
+/* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */
+
+#endif /* PNG_INTERNAL */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* PNG_VERSION_INFO_ONLY */
+/* do not put anything past this line */
+#endif /* PNG_H */
--- /dev/null
+
+/* pngconf.h - machine configurable file for libpng
+ *
+ * libpng version 1.2.33 - October 31, 2008
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ */
+
+/* Any machine specific code is near the front of this file, so if you
+ * are configuring libpng for a machine, you may want to read the section
+ * starting here down to where it starts to typedef png_color, png_text,
+ * and png_info.
+ */
+
+#ifndef PNGCONF_H
+#define PNGCONF_H
+
+#define PNG_1_2_X
+
+/*
+ * PNG_USER_CONFIG has to be defined on the compiler command line. This
+ * includes the resource compiler for Windows DLL configurations.
+ */
+#ifdef PNG_USER_CONFIG
+# ifndef PNG_USER_PRIVATEBUILD
+# define PNG_USER_PRIVATEBUILD
+# endif
+#include "pngusr.h"
+#endif
+
+/* PNG_CONFIGURE_LIBPNG is set by the "configure" script. */
+#ifdef PNG_CONFIGURE_LIBPNG
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#endif
+
+/*
+ * Added at libpng-1.2.8
+ *
+ * If you create a private DLL you need to define in "pngusr.h" the followings:
+ * #define PNG_USER_PRIVATEBUILD <Describes by whom and why this version of
+ * the DLL was built>
+ * e.g. #define PNG_USER_PRIVATEBUILD "Build by MyCompany for xyz reasons."
+ * #define PNG_USER_DLLFNAME_POSTFIX <two-letter postfix that serve to
+ * distinguish your DLL from those of the official release. These
+ * correspond to the trailing letters that come after the version
+ * number and must match your private DLL name>
+ * e.g. // private DLL "libpng13gx.dll"
+ * #define PNG_USER_DLLFNAME_POSTFIX "gx"
+ *
+ * The following macros are also at your disposal if you want to complete the
+ * DLL VERSIONINFO structure.
+ * - PNG_USER_VERSIONINFO_COMMENTS
+ * - PNG_USER_VERSIONINFO_COMPANYNAME
+ * - PNG_USER_VERSIONINFO_LEGALTRADEMARKS
+ */
+
+#ifdef __STDC__
+#ifdef SPECIALBUILD
+# pragma message("PNG_LIBPNG_SPECIALBUILD (and deprecated SPECIALBUILD)\
+ are now LIBPNG reserved macros. Use PNG_USER_PRIVATEBUILD instead.")
+#endif
+
+#ifdef PRIVATEBUILD
+# pragma message("PRIVATEBUILD is deprecated.\
+ Use PNG_USER_PRIVATEBUILD instead.")
+# define PNG_USER_PRIVATEBUILD PRIVATEBUILD
+#endif
+#endif /* __STDC__ */
+
+#ifndef PNG_VERSION_INFO_ONLY
+
+/* End of material added to libpng-1.2.8 */
+
+/* Added at libpng-1.2.19, removed at libpng-1.2.20 because it caused trouble
+ Restored at libpng-1.2.21 */
+#if !defined(PNG_NO_WARN_UNINITIALIZED_ROW) && \
+ !defined(PNG_WARN_UNINITIALIZED_ROW)
+# define PNG_WARN_UNINITIALIZED_ROW 1
+#endif
+/* End of material added at libpng-1.2.19/1.2.21 */
+
+/* This is the size of the compression buffer, and thus the size of
+ * an IDAT chunk. Make this whatever size you feel is best for your
+ * machine. One of these will be allocated per png_struct. When this
+ * is full, it writes the data to the disk, and does some other
+ * calculations. Making this an extremely small size will slow
+ * the library down, but you may want to experiment to determine
+ * where it becomes significant, if you are concerned with memory
+ * usage. Note that zlib allocates at least 32Kb also. For readers,
+ * this describes the size of the buffer available to read the data in.
+ * Unless this gets smaller than the size of a row (compressed),
+ * it should not make much difference how big this is.
+ */
+
+#ifndef PNG_ZBUF_SIZE
+# define PNG_ZBUF_SIZE 8192
+#endif
+
+/* Enable if you want a write-only libpng */
+
+#ifndef PNG_NO_READ_SUPPORTED
+# define PNG_READ_SUPPORTED
+#endif
+
+/* Enable if you want a read-only libpng */
+
+#ifndef PNG_NO_WRITE_SUPPORTED
+# define PNG_WRITE_SUPPORTED
+#endif
+
+/* Enabled by default in 1.2.0. You can disable this if you don't need to
+ support PNGs that are embedded in MNG datastreams */
+#if !defined(PNG_1_0_X) && !defined(PNG_NO_MNG_FEATURES)
+# ifndef PNG_MNG_FEATURES_SUPPORTED
+# define PNG_MNG_FEATURES_SUPPORTED
+# endif
+#endif
+
+#ifndef PNG_NO_FLOATING_POINT_SUPPORTED
+# ifndef PNG_FLOATING_POINT_SUPPORTED
+# define PNG_FLOATING_POINT_SUPPORTED
+# endif
+#endif
+
+/* If you are running on a machine where you cannot allocate more
+ * than 64K of memory at once, uncomment this. While libpng will not
+ * normally need that much memory in a chunk (unless you load up a very
+ * large file), zlib needs to know how big of a chunk it can use, and
+ * libpng thus makes sure to check any memory allocation to verify it
+ * will fit into memory.
+#define PNG_MAX_MALLOC_64K
+ */
+#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K)
+# define PNG_MAX_MALLOC_64K
+#endif
+
+/* Special munging to support doing things the 'cygwin' way:
+ * 'Normal' png-on-win32 defines/defaults:
+ * PNG_BUILD_DLL -- building dll
+ * PNG_USE_DLL -- building an application, linking to dll
+ * (no define) -- building static library, or building an
+ * application and linking to the static lib
+ * 'Cygwin' defines/defaults:
+ * PNG_BUILD_DLL -- (ignored) building the dll
+ * (no define) -- (ignored) building an application, linking to the dll
+ * PNG_STATIC -- (ignored) building the static lib, or building an
+ * application that links to the static lib.
+ * ALL_STATIC -- (ignored) building various static libs, or building an
+ * application that links to the static libs.
+ * Thus,
+ * a cygwin user should define either PNG_BUILD_DLL or PNG_STATIC, and
+ * this bit of #ifdefs will define the 'correct' config variables based on
+ * that. If a cygwin user *wants* to define 'PNG_USE_DLL' that's okay, but
+ * unnecessary.
+ *
+ * Also, the precedence order is:
+ * ALL_STATIC (since we can't #undef something outside our namespace)
+ * PNG_BUILD_DLL
+ * PNG_STATIC
+ * (nothing) == PNG_USE_DLL
+ *
+ * CYGWIN (2002-01-20): The preceding is now obsolete. With the advent
+ * of auto-import in binutils, we no longer need to worry about
+ * __declspec(dllexport) / __declspec(dllimport) and friends. Therefore,
+ * we don't need to worry about PNG_STATIC or ALL_STATIC when it comes
+ * to __declspec() stuff. However, we DO need to worry about
+ * PNG_BUILD_DLL and PNG_STATIC because those change some defaults
+ * such as CONSOLE_IO and whether GLOBAL_ARRAYS are allowed.
+ */
+#if defined(__CYGWIN__)
+# if defined(ALL_STATIC)
+# if defined(PNG_BUILD_DLL)
+# undef PNG_BUILD_DLL
+# endif
+# if defined(PNG_USE_DLL)
+# undef PNG_USE_DLL
+# endif
+# if defined(PNG_DLL)
+# undef PNG_DLL
+# endif
+# if !defined(PNG_STATIC)
+# define PNG_STATIC
+# endif
+# else
+# if defined (PNG_BUILD_DLL)
+# if defined(PNG_STATIC)
+# undef PNG_STATIC
+# endif
+# if defined(PNG_USE_DLL)
+# undef PNG_USE_DLL
+# endif
+# if !defined(PNG_DLL)
+# define PNG_DLL
+# endif
+# else
+# if defined(PNG_STATIC)
+# if defined(PNG_USE_DLL)
+# undef PNG_USE_DLL
+# endif
+# if defined(PNG_DLL)
+# undef PNG_DLL
+# endif
+# else
+# if !defined(PNG_USE_DLL)
+# define PNG_USE_DLL
+# endif
+# if !defined(PNG_DLL)
+# define PNG_DLL
+# endif
+# endif
+# endif
+# endif
+#endif
+
+/* This protects us against compilers that run on a windowing system
+ * and thus don't have or would rather us not use the stdio types:
+ * stdin, stdout, and stderr. The only one currently used is stderr
+ * in png_error() and png_warning(). #defining PNG_NO_CONSOLE_IO will
+ * prevent these from being compiled and used. #defining PNG_NO_STDIO
+ * will also prevent these, plus will prevent the entire set of stdio
+ * macros and functions (FILE *, printf, etc.) from being compiled and used,
+ * unless (PNG_DEBUG > 0) has been #defined.
+ *
+ * #define PNG_NO_CONSOLE_IO
+ * #define PNG_NO_STDIO
+ */
+
+#if defined(_WIN32_WCE)
+# include <windows.h>
+ /* Console I/O functions are not supported on WindowsCE */
+# define PNG_NO_CONSOLE_IO
+# ifdef PNG_DEBUG
+# undef PNG_DEBUG
+# endif
+#endif
+
+#ifdef PNG_BUILD_DLL
+# ifndef PNG_CONSOLE_IO_SUPPORTED
+# ifndef PNG_NO_CONSOLE_IO
+# define PNG_NO_CONSOLE_IO
+# endif
+# endif
+#endif
+
+# ifdef PNG_NO_STDIO
+# ifndef PNG_NO_CONSOLE_IO
+# define PNG_NO_CONSOLE_IO
+# endif
+# ifdef PNG_DEBUG
+# if (PNG_DEBUG > 0)
+# include <stdio.h>
+# endif
+# endif
+# else
+# if !defined(_WIN32_WCE)
+/* "stdio.h" functions are not supported on WindowsCE */
+# include <stdio.h>
+# endif
+# endif
+
+/* This macro protects us against machines that don't have function
+ * prototypes (ie K&R style headers). If your compiler does not handle
+ * function prototypes, define this macro and use the included ansi2knr.
+ * I've always been able to use _NO_PROTO as the indicator, but you may
+ * need to drag the empty declaration out in front of here, or change the
+ * ifdef to suit your own needs.
+ */
+#ifndef PNGARG
+
+#ifdef OF /* zlib prototype munger */
+# define PNGARG(arglist) OF(arglist)
+#else
+
+#ifdef _NO_PROTO
+# define PNGARG(arglist) ()
+# ifndef PNG_TYPECAST_NULL
+# define PNG_TYPECAST_NULL
+# endif
+#else
+# define PNGARG(arglist) arglist
+#endif /* _NO_PROTO */
+
+
+#endif /* OF */
+
+#endif /* PNGARG */
+
+/* Try to determine if we are compiling on a Mac. Note that testing for
+ * just __MWERKS__ is not good enough, because the Codewarrior is now used
+ * on non-Mac platforms.
+ */
+#ifndef MACOS
+# if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \
+ defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC)
+# define MACOS
+# endif
+#endif
+
+/* enough people need this for various reasons to include it here */
+#if !defined(MACOS) && !defined(RISCOS) && !defined(_WIN32_WCE)
+# include <sys/types.h>
+#endif
+
+#if !defined(PNG_SETJMP_NOT_SUPPORTED) && !defined(PNG_NO_SETJMP_SUPPORTED)
+# define PNG_SETJMP_SUPPORTED
+#endif
+
+#ifdef PNG_SETJMP_SUPPORTED
+/* This is an attempt to force a single setjmp behaviour on Linux. If
+ * the X config stuff didn't define _BSD_SOURCE we wouldn't need this.
+ */
+
+# ifdef __linux__
+# ifdef _BSD_SOURCE
+# define PNG_SAVE_BSD_SOURCE
+# undef _BSD_SOURCE
+# endif
+# ifdef _SETJMP_H
+ /* If you encounter a compiler error here, see the explanation
+ * near the end of INSTALL.
+ */
+ __pngconf.h__ already includes setjmp.h;
+ __dont__ include it again.;
+# endif
+# endif /* __linux__ */
+
+ /* include setjmp.h for error handling */
+# include <setjmp.h>
+
+# ifdef __linux__
+# ifdef PNG_SAVE_BSD_SOURCE
+# ifndef _BSD_SOURCE
+# define _BSD_SOURCE
+# endif
+# undef PNG_SAVE_BSD_SOURCE
+# endif
+# endif /* __linux__ */
+#endif /* PNG_SETJMP_SUPPORTED */
+
+#ifdef BSD
+# include <strings.h>
+#else
+# include <string.h>
+#endif
+
+/* Other defines for things like memory and the like can go here. */
+#ifdef PNG_INTERNAL
+
+#include <stdlib.h>
+
+/* The functions exported by PNG_EXTERN are PNG_INTERNAL functions, which
+ * aren't usually used outside the library (as far as I know), so it is
+ * debatable if they should be exported at all. In the future, when it is
+ * possible to have run-time registry of chunk-handling functions, some of
+ * these will be made available again.
+#define PNG_EXTERN extern
+ */
+#define PNG_EXTERN
+
+/* Other defines specific to compilers can go here. Try to keep
+ * them inside an appropriate ifdef/endif pair for portability.
+ */
+
+#if defined(PNG_FLOATING_POINT_SUPPORTED)
+# if defined(MACOS)
+ /* We need to check that <math.h> hasn't already been included earlier
+ * as it seems it doesn't agree with <fp.h>, yet we should really use
+ * <fp.h> if possible.
+ */
+# if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__)
+# include <fp.h>
+# endif
+# else
+# include <math.h>
+# endif
+# if defined(_AMIGA) && defined(__SASC) && defined(_M68881)
+ /* Amiga SAS/C: We must include builtin FPU functions when compiling using
+ * MATH=68881
+ */
+# include <m68881.h>
+# endif
+#endif
+
+/* Codewarrior on NT has linking problems without this. */
+#if (defined(__MWERKS__) && defined(WIN32)) || defined(__STDC__)
+# define PNG_ALWAYS_EXTERN
+#endif
+
+/* This provides the non-ANSI (far) memory allocation routines. */
+#if defined(__TURBOC__) && defined(__MSDOS__)
+# include <mem.h>
+# include <alloc.h>
+#endif
+
+/* I have no idea why is this necessary... */
+#if defined(_MSC_VER) && (defined(WIN32) || defined(_Windows) || \
+ defined(_WINDOWS) || defined(_WIN32) || defined(__WIN32__))
+# include <malloc.h>
+#endif
+
+/* This controls how fine the dithering gets. As this allocates
+ * a largish chunk of memory (32K), those who are not as concerned
+ * with dithering quality can decrease some or all of these.
+ */
+#ifndef PNG_DITHER_RED_BITS
+# define PNG_DITHER_RED_BITS 5
+#endif
+#ifndef PNG_DITHER_GREEN_BITS
+# define PNG_DITHER_GREEN_BITS 5
+#endif
+#ifndef PNG_DITHER_BLUE_BITS
+# define PNG_DITHER_BLUE_BITS 5
+#endif
+
+/* This controls how fine the gamma correction becomes when you
+ * are only interested in 8 bits anyway. Increasing this value
+ * results in more memory being used, and more pow() functions
+ * being called to fill in the gamma tables. Don't set this value
+ * less then 8, and even that may not work (I haven't tested it).
+ */
+
+#ifndef PNG_MAX_GAMMA_8
+# define PNG_MAX_GAMMA_8 11
+#endif
+
+/* This controls how much a difference in gamma we can tolerate before
+ * we actually start doing gamma conversion.
+ */
+#ifndef PNG_GAMMA_THRESHOLD
+# define PNG_GAMMA_THRESHOLD 0.05
+#endif
+
+#endif /* PNG_INTERNAL */
+
+/* The following uses const char * instead of char * for error
+ * and warning message functions, so some compilers won't complain.
+ * If you do not want to use const, define PNG_NO_CONST here.
+ */
+
+#ifndef PNG_NO_CONST
+# define PNG_CONST const
+#else
+# define PNG_CONST
+#endif
+
+/* The following defines give you the ability to remove code from the
+ * library that you will not be using. I wish I could figure out how to
+ * automate this, but I can't do that without making it seriously hard
+ * on the users. So if you are not using an ability, change the #define
+ * to and #undef, and that part of the library will not be compiled. If
+ * your linker can't find a function, you may want to make sure the
+ * ability is defined here. Some of these depend upon some others being
+ * defined. I haven't figured out all the interactions here, so you may
+ * have to experiment awhile to get everything to compile. If you are
+ * creating or using a shared library, you probably shouldn't touch this,
+ * as it will affect the size of the structures, and this will cause bad
+ * things to happen if the library and/or application ever change.
+ */
+
+/* Any features you will not be using can be undef'ed here */
+
+/* GR-P, 0.96a: Set "*TRANSFORMS_SUPPORTED as default but allow user
+ * to turn it off with "*TRANSFORMS_NOT_SUPPORTED" or *PNG_NO_*_TRANSFORMS
+ * on the compile line, then pick and choose which ones to define without
+ * having to edit this file. It is safe to use the *TRANSFORMS_NOT_SUPPORTED
+ * if you only want to have a png-compliant reader/writer but don't need
+ * any of the extra transformations. This saves about 80 kbytes in a
+ * typical installation of the library. (PNG_NO_* form added in version
+ * 1.0.1c, for consistency)
+ */
+
+/* The size of the png_text structure changed in libpng-1.0.6 when
+ * iTXt support was added. iTXt support was turned off by default through
+ * libpng-1.2.x, to support old apps that malloc the png_text structure
+ * instead of calling png_set_text() and letting libpng malloc it. It
+ * was turned on by default in libpng-1.3.0.
+ */
+
+#if defined(PNG_1_0_X) || defined (PNG_1_2_X)
+# ifndef PNG_NO_iTXt_SUPPORTED
+# define PNG_NO_iTXt_SUPPORTED
+# endif
+# ifndef PNG_NO_READ_iTXt
+# define PNG_NO_READ_iTXt
+# endif
+# ifndef PNG_NO_WRITE_iTXt
+# define PNG_NO_WRITE_iTXt
+# endif
+#endif
+
+#if !defined(PNG_NO_iTXt_SUPPORTED)
+# if !defined(PNG_READ_iTXt_SUPPORTED) && !defined(PNG_NO_READ_iTXt)
+# define PNG_READ_iTXt
+# endif
+# if !defined(PNG_WRITE_iTXt_SUPPORTED) && !defined(PNG_NO_WRITE_iTXt)
+# define PNG_WRITE_iTXt
+# endif
+#endif
+
+/* The following support, added after version 1.0.0, can be turned off here en
+ * masse by defining PNG_LEGACY_SUPPORTED in case you need binary compatibility
+ * with old applications that require the length of png_struct and png_info
+ * to remain unchanged.
+ */
+
+#ifdef PNG_LEGACY_SUPPORTED
+# define PNG_NO_FREE_ME
+# define PNG_NO_READ_UNKNOWN_CHUNKS
+# define PNG_NO_WRITE_UNKNOWN_CHUNKS
+# define PNG_NO_READ_USER_CHUNKS
+# define PNG_NO_READ_iCCP
+# define PNG_NO_WRITE_iCCP
+# define PNG_NO_READ_iTXt
+# define PNG_NO_WRITE_iTXt
+# define PNG_NO_READ_sCAL
+# define PNG_NO_WRITE_sCAL
+# define PNG_NO_READ_sPLT
+# define PNG_NO_WRITE_sPLT
+# define PNG_NO_INFO_IMAGE
+# define PNG_NO_READ_RGB_TO_GRAY
+# define PNG_NO_READ_USER_TRANSFORM
+# define PNG_NO_WRITE_USER_TRANSFORM
+# define PNG_NO_USER_MEM
+# define PNG_NO_READ_EMPTY_PLTE
+# define PNG_NO_MNG_FEATURES
+# define PNG_NO_FIXED_POINT_SUPPORTED
+#endif
+
+/* Ignore attempt to turn off both floating and fixed point support */
+#if !defined(PNG_FLOATING_POINT_SUPPORTED) || \
+ !defined(PNG_NO_FIXED_POINT_SUPPORTED)
+# define PNG_FIXED_POINT_SUPPORTED
+#endif
+
+#ifndef PNG_NO_FREE_ME
+# define PNG_FREE_ME_SUPPORTED
+#endif
+
+#if defined(PNG_READ_SUPPORTED)
+
+#if !defined(PNG_READ_TRANSFORMS_NOT_SUPPORTED) && \
+ !defined(PNG_NO_READ_TRANSFORMS)
+# define PNG_READ_TRANSFORMS_SUPPORTED
+#endif
+
+#ifdef PNG_READ_TRANSFORMS_SUPPORTED
+# ifndef PNG_NO_READ_EXPAND
+# define PNG_READ_EXPAND_SUPPORTED
+# endif
+# ifndef PNG_NO_READ_SHIFT
+# define PNG_READ_SHIFT_SUPPORTED
+# endif
+# ifndef PNG_NO_READ_PACK
+# define PNG_READ_PACK_SUPPORTED
+# endif
+# ifndef PNG_NO_READ_BGR
+# define PNG_READ_BGR_SUPPORTED
+# endif
+# ifndef PNG_NO_READ_SWAP
+# define PNG_READ_SWAP_SUPPORTED
+# endif
+# ifndef PNG_NO_READ_PACKSWAP
+# define PNG_READ_PACKSWAP_SUPPORTED
+# endif
+# ifndef PNG_NO_READ_INVERT
+# define PNG_READ_INVERT_SUPPORTED
+# endif
+# ifndef PNG_NO_READ_DITHER
+# define PNG_READ_DITHER_SUPPORTED
+# endif
+# ifndef PNG_NO_READ_BACKGROUND
+# define PNG_READ_BACKGROUND_SUPPORTED
+# endif
+# ifndef PNG_NO_READ_16_TO_8
+# define PNG_READ_16_TO_8_SUPPORTED
+# endif
+# ifndef PNG_NO_READ_FILLER
+# define PNG_READ_FILLER_SUPPORTED
+# endif
+# ifndef PNG_NO_READ_GAMMA
+# define PNG_READ_GAMMA_SUPPORTED
+# endif
+# ifndef PNG_NO_READ_GRAY_TO_RGB
+# define PNG_READ_GRAY_TO_RGB_SUPPORTED
+# endif
+# ifndef PNG_NO_READ_SWAP_ALPHA
+# define PNG_READ_SWAP_ALPHA_SUPPORTED
+# endif
+# ifndef PNG_NO_READ_INVERT_ALPHA
+# define PNG_READ_INVERT_ALPHA_SUPPORTED
+# endif
+# ifndef PNG_NO_READ_STRIP_ALPHA
+# define PNG_READ_STRIP_ALPHA_SUPPORTED
+# endif
+# ifndef PNG_NO_READ_USER_TRANSFORM
+# define PNG_READ_USER_TRANSFORM_SUPPORTED
+# endif
+# ifndef PNG_NO_READ_RGB_TO_GRAY
+# define PNG_READ_RGB_TO_GRAY_SUPPORTED
+# endif
+#endif /* PNG_READ_TRANSFORMS_SUPPORTED */
+
+#if !defined(PNG_NO_PROGRESSIVE_READ) && \
+ !defined(PNG_PROGRESSIVE_READ_SUPPORTED) /* if you don't do progressive */
+# define PNG_PROGRESSIVE_READ_SUPPORTED /* reading. This is not talking */
+#endif /* about interlacing capability! You'll */
+ /* still have interlacing unless you change the following line: */
+
+#define PNG_READ_INTERLACING_SUPPORTED /* required in PNG-compliant decoders */
+
+#ifndef PNG_NO_READ_COMPOSITE_NODIV
+# ifndef PNG_NO_READ_COMPOSITED_NODIV /* libpng-1.0.x misspelling */
+# define PNG_READ_COMPOSITE_NODIV_SUPPORTED /* well tested on Intel, SGI */
+# endif
+#endif
+
+#if defined(PNG_1_0_X) || defined (PNG_1_2_X)
+/* Deprecated, will be removed from version 2.0.0.
+ Use PNG_MNG_FEATURES_SUPPORTED instead. */
+#ifndef PNG_NO_READ_EMPTY_PLTE
+# define PNG_READ_EMPTY_PLTE_SUPPORTED
+#endif
+#endif
+
+#endif /* PNG_READ_SUPPORTED */
+
+#if defined(PNG_WRITE_SUPPORTED)
+
+# if !defined(PNG_WRITE_TRANSFORMS_NOT_SUPPORTED) && \
+ !defined(PNG_NO_WRITE_TRANSFORMS)
+# define PNG_WRITE_TRANSFORMS_SUPPORTED
+#endif
+
+#ifdef PNG_WRITE_TRANSFORMS_SUPPORTED
+# ifndef PNG_NO_WRITE_SHIFT
+# define PNG_WRITE_SHIFT_SUPPORTED
+# endif
+# ifndef PNG_NO_WRITE_PACK
+# define PNG_WRITE_PACK_SUPPORTED
+# endif
+# ifndef PNG_NO_WRITE_BGR
+# define PNG_WRITE_BGR_SUPPORTED
+# endif
+# ifndef PNG_NO_WRITE_SWAP
+# define PNG_WRITE_SWAP_SUPPORTED
+# endif
+# ifndef PNG_NO_WRITE_PACKSWAP
+# define PNG_WRITE_PACKSWAP_SUPPORTED
+# endif
+# ifndef PNG_NO_WRITE_INVERT
+# define PNG_WRITE_INVERT_SUPPORTED
+# endif
+# ifndef PNG_NO_WRITE_FILLER
+# define PNG_WRITE_FILLER_SUPPORTED /* same as WRITE_STRIP_ALPHA */
+# endif
+# ifndef PNG_NO_WRITE_SWAP_ALPHA
+# define PNG_WRITE_SWAP_ALPHA_SUPPORTED
+# endif
+# ifndef PNG_NO_WRITE_INVERT_ALPHA
+# define PNG_WRITE_INVERT_ALPHA_SUPPORTED
+# endif
+# ifndef PNG_NO_WRITE_USER_TRANSFORM
+# define PNG_WRITE_USER_TRANSFORM_SUPPORTED
+# endif
+#endif /* PNG_WRITE_TRANSFORMS_SUPPORTED */
+
+#if !defined(PNG_NO_WRITE_INTERLACING_SUPPORTED) && \
+ !defined(PNG_WRITE_INTERLACING_SUPPORTED)
+#define PNG_WRITE_INTERLACING_SUPPORTED /* not required for PNG-compliant
+ encoders, but can cause trouble
+ if left undefined */
+#endif
+
+#if !defined(PNG_NO_WRITE_WEIGHTED_FILTER) && \
+ !defined(PNG_WRITE_WEIGHTED_FILTER) && \
+ defined(PNG_FLOATING_POINT_SUPPORTED)
+# define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
+#endif
+
+#ifndef PNG_NO_WRITE_FLUSH
+# define PNG_WRITE_FLUSH_SUPPORTED
+#endif
+
+#if defined(PNG_1_0_X) || defined (PNG_1_2_X)
+/* Deprecated, see PNG_MNG_FEATURES_SUPPORTED, above */
+#ifndef PNG_NO_WRITE_EMPTY_PLTE
+# define PNG_WRITE_EMPTY_PLTE_SUPPORTED
+#endif
+#endif
+
+#endif /* PNG_WRITE_SUPPORTED */
+
+#ifndef PNG_1_0_X
+# ifndef PNG_NO_ERROR_NUMBERS
+# define PNG_ERROR_NUMBERS_SUPPORTED
+# endif
+#endif /* PNG_1_0_X */
+
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
+ defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+# ifndef PNG_NO_USER_TRANSFORM_PTR
+# define PNG_USER_TRANSFORM_PTR_SUPPORTED
+# endif
+#endif
+
+#ifndef PNG_NO_STDIO
+# define PNG_TIME_RFC1123_SUPPORTED
+#endif
+
+/* This adds extra functions in pngget.c for accessing data from the
+ * info pointer (added in version 0.99)
+ * png_get_image_width()
+ * png_get_image_height()
+ * png_get_bit_depth()
+ * png_get_color_type()
+ * png_get_compression_type()
+ * png_get_filter_type()
+ * png_get_interlace_type()
+ * png_get_pixel_aspect_ratio()
+ * png_get_pixels_per_meter()
+ * png_get_x_offset_pixels()
+ * png_get_y_offset_pixels()
+ * png_get_x_offset_microns()
+ * png_get_y_offset_microns()
+ */
+#if !defined(PNG_NO_EASY_ACCESS) && !defined(PNG_EASY_ACCESS_SUPPORTED)
+# define PNG_EASY_ACCESS_SUPPORTED
+#endif
+
+/* PNG_ASSEMBLER_CODE was enabled by default in version 1.2.0
+ * and removed from version 1.2.20. The following will be removed
+ * from libpng-1.4.0
+*/
+
+#if defined(PNG_READ_SUPPORTED) && !defined(PNG_NO_OPTIMIZED_CODE)
+# ifndef PNG_OPTIMIZED_CODE_SUPPORTED
+# define PNG_OPTIMIZED_CODE_SUPPORTED
+# endif
+#endif
+
+#if defined(PNG_READ_SUPPORTED) && !defined(PNG_NO_ASSEMBLER_CODE)
+# ifndef PNG_ASSEMBLER_CODE_SUPPORTED
+# define PNG_ASSEMBLER_CODE_SUPPORTED
+# endif
+
+# if defined(__GNUC__) && defined(__x86_64__) && (__GNUC__ < 4)
+ /* work around 64-bit gcc compiler bugs in gcc-3.x */
+# if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE)
+# define PNG_NO_MMX_CODE
+# endif
+# endif
+
+# if defined(__APPLE__)
+# if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE)
+# define PNG_NO_MMX_CODE
+# endif
+# endif
+
+# if (defined(__MWERKS__) && ((__MWERKS__ < 0x0900) || macintosh))
+# if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE)
+# define PNG_NO_MMX_CODE
+# endif
+# endif
+
+# if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE)
+# define PNG_MMX_CODE_SUPPORTED
+# endif
+
+#endif
+/* end of obsolete code to be removed from libpng-1.4.0 */
+
+#if !defined(PNG_1_0_X)
+#if !defined(PNG_NO_USER_MEM) && !defined(PNG_USER_MEM_SUPPORTED)
+# define PNG_USER_MEM_SUPPORTED
+#endif
+#endif /* PNG_1_0_X */
+
+/* Added at libpng-1.2.6 */
+#if !defined(PNG_1_0_X)
+#ifndef PNG_SET_USER_LIMITS_SUPPORTED
+#if !defined(PNG_NO_SET_USER_LIMITS) && !defined(PNG_SET_USER_LIMITS_SUPPORTED)
+# define PNG_SET_USER_LIMITS_SUPPORTED
+#endif
+#endif
+#endif /* PNG_1_0_X */
+
+/* Added at libpng-1.0.16 and 1.2.6. To accept all valid PNGS no matter
+ * how large, set these limits to 0x7fffffffL
+ */
+#ifndef PNG_USER_WIDTH_MAX
+# define PNG_USER_WIDTH_MAX 1000000L
+#endif
+#ifndef PNG_USER_HEIGHT_MAX
+# define PNG_USER_HEIGHT_MAX 1000000L
+#endif
+
+/* These are currently experimental features, define them if you want */
+
+/* very little testing */
+/*
+#ifdef PNG_READ_SUPPORTED
+# ifndef PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED
+# define PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED
+# endif
+#endif
+*/
+
+/* This is only for PowerPC big-endian and 680x0 systems */
+/* some testing */
+/*
+#ifndef PNG_READ_BIG_ENDIAN_SUPPORTED
+# define PNG_READ_BIG_ENDIAN_SUPPORTED
+#endif
+*/
+
+/* Buggy compilers (e.g., gcc 2.7.2.2) need this */
+/*
+#define PNG_NO_POINTER_INDEXING
+*/
+
+/* These functions are turned off by default, as they will be phased out. */
+/*
+#define PNG_USELESS_TESTS_SUPPORTED
+#define PNG_CORRECT_PALETTE_SUPPORTED
+*/
+
+/* Any chunks you are not interested in, you can undef here. The
+ * ones that allocate memory may be expecially important (hIST,
+ * tEXt, zTXt, tRNS, pCAL). Others will just save time and make png_info
+ * a bit smaller.
+ */
+
+#if defined(PNG_READ_SUPPORTED) && \
+ !defined(PNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \
+ !defined(PNG_NO_READ_ANCILLARY_CHUNKS)
+# define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED
+#endif
+
+#if defined(PNG_WRITE_SUPPORTED) && \
+ !defined(PNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \
+ !defined(PNG_NO_WRITE_ANCILLARY_CHUNKS)
+# define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED
+#endif
+
+#ifdef PNG_READ_ANCILLARY_CHUNKS_SUPPORTED
+
+#ifdef PNG_NO_READ_TEXT
+# define PNG_NO_READ_iTXt
+# define PNG_NO_READ_tEXt
+# define PNG_NO_READ_zTXt
+#endif
+#ifndef PNG_NO_READ_bKGD
+# define PNG_READ_bKGD_SUPPORTED
+# define PNG_bKGD_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_cHRM
+# define PNG_READ_cHRM_SUPPORTED
+# define PNG_cHRM_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_gAMA
+# define PNG_READ_gAMA_SUPPORTED
+# define PNG_gAMA_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_hIST
+# define PNG_READ_hIST_SUPPORTED
+# define PNG_hIST_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_iCCP
+# define PNG_READ_iCCP_SUPPORTED
+# define PNG_iCCP_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_iTXt
+# ifndef PNG_READ_iTXt_SUPPORTED
+# define PNG_READ_iTXt_SUPPORTED
+# endif
+# ifndef PNG_iTXt_SUPPORTED
+# define PNG_iTXt_SUPPORTED
+# endif
+#endif
+#ifndef PNG_NO_READ_oFFs
+# define PNG_READ_oFFs_SUPPORTED
+# define PNG_oFFs_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_pCAL
+# define PNG_READ_pCAL_SUPPORTED
+# define PNG_pCAL_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_sCAL
+# define PNG_READ_sCAL_SUPPORTED
+# define PNG_sCAL_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_pHYs
+# define PNG_READ_pHYs_SUPPORTED
+# define PNG_pHYs_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_sBIT
+# define PNG_READ_sBIT_SUPPORTED
+# define PNG_sBIT_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_sPLT
+# define PNG_READ_sPLT_SUPPORTED
+# define PNG_sPLT_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_sRGB
+# define PNG_READ_sRGB_SUPPORTED
+# define PNG_sRGB_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_tEXt
+# define PNG_READ_tEXt_SUPPORTED
+# define PNG_tEXt_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_tIME
+# define PNG_READ_tIME_SUPPORTED
+# define PNG_tIME_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_tRNS
+# define PNG_READ_tRNS_SUPPORTED
+# define PNG_tRNS_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_zTXt
+# define PNG_READ_zTXt_SUPPORTED
+# define PNG_zTXt_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_UNKNOWN_CHUNKS
+# define PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
+# ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED
+# define PNG_UNKNOWN_CHUNKS_SUPPORTED
+# endif
+# ifndef PNG_NO_HANDLE_AS_UNKNOWN
+# define PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+# endif
+#endif
+#if !defined(PNG_NO_READ_USER_CHUNKS) && \
+ defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
+# define PNG_READ_USER_CHUNKS_SUPPORTED
+# define PNG_USER_CHUNKS_SUPPORTED
+# ifdef PNG_NO_READ_UNKNOWN_CHUNKS
+# undef PNG_NO_READ_UNKNOWN_CHUNKS
+# endif
+# ifdef PNG_NO_HANDLE_AS_UNKNOWN
+# undef PNG_NO_HANDLE_AS_UNKNOWN
+# endif
+#endif
+#ifndef PNG_NO_READ_OPT_PLTE
+# define PNG_READ_OPT_PLTE_SUPPORTED /* only affects support of the */
+#endif /* optional PLTE chunk in RGB and RGBA images */
+#if defined(PNG_READ_iTXt_SUPPORTED) || defined(PNG_READ_tEXt_SUPPORTED) || \
+ defined(PNG_READ_zTXt_SUPPORTED)
+# define PNG_READ_TEXT_SUPPORTED
+# define PNG_TEXT_SUPPORTED
+#endif
+
+#endif /* PNG_READ_ANCILLARY_CHUNKS_SUPPORTED */
+
+#ifdef PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED
+
+#ifdef PNG_NO_WRITE_TEXT
+# define PNG_NO_WRITE_iTXt
+# define PNG_NO_WRITE_tEXt
+# define PNG_NO_WRITE_zTXt
+#endif
+#ifndef PNG_NO_WRITE_bKGD
+# define PNG_WRITE_bKGD_SUPPORTED
+# ifndef PNG_bKGD_SUPPORTED
+# define PNG_bKGD_SUPPORTED
+# endif
+#endif
+#ifndef PNG_NO_WRITE_cHRM
+# define PNG_WRITE_cHRM_SUPPORTED
+# ifndef PNG_cHRM_SUPPORTED
+# define PNG_cHRM_SUPPORTED
+# endif
+#endif
+#ifndef PNG_NO_WRITE_gAMA
+# define PNG_WRITE_gAMA_SUPPORTED
+# ifndef PNG_gAMA_SUPPORTED
+# define PNG_gAMA_SUPPORTED
+# endif
+#endif
+#ifndef PNG_NO_WRITE_hIST
+# define PNG_WRITE_hIST_SUPPORTED
+# ifndef PNG_hIST_SUPPORTED
+# define PNG_hIST_SUPPORTED
+# endif
+#endif
+#ifndef PNG_NO_WRITE_iCCP
+# define PNG_WRITE_iCCP_SUPPORTED
+# ifndef PNG_iCCP_SUPPORTED
+# define PNG_iCCP_SUPPORTED
+# endif
+#endif
+#ifndef PNG_NO_WRITE_iTXt
+# ifndef PNG_WRITE_iTXt_SUPPORTED
+# define PNG_WRITE_iTXt_SUPPORTED
+# endif
+# ifndef PNG_iTXt_SUPPORTED
+# define PNG_iTXt_SUPPORTED
+# endif
+#endif
+#ifndef PNG_NO_WRITE_oFFs
+# define PNG_WRITE_oFFs_SUPPORTED
+# ifndef PNG_oFFs_SUPPORTED
+# define PNG_oFFs_SUPPORTED
+# endif
+#endif
+#ifndef PNG_NO_WRITE_pCAL
+# define PNG_WRITE_pCAL_SUPPORTED
+# ifndef PNG_pCAL_SUPPORTED
+# define PNG_pCAL_SUPPORTED
+# endif
+#endif
+#ifndef PNG_NO_WRITE_sCAL
+# define PNG_WRITE_sCAL_SUPPORTED
+# ifndef PNG_sCAL_SUPPORTED
+# define PNG_sCAL_SUPPORTED
+# endif
+#endif
+#ifndef PNG_NO_WRITE_pHYs
+# define PNG_WRITE_pHYs_SUPPORTED
+# ifndef PNG_pHYs_SUPPORTED
+# define PNG_pHYs_SUPPORTED
+# endif
+#endif
+#ifndef PNG_NO_WRITE_sBIT
+# define PNG_WRITE_sBIT_SUPPORTED
+# ifndef PNG_sBIT_SUPPORTED
+# define PNG_sBIT_SUPPORTED
+# endif
+#endif
+#ifndef PNG_NO_WRITE_sPLT
+# define PNG_WRITE_sPLT_SUPPORTED
+# ifndef PNG_sPLT_SUPPORTED
+# define PNG_sPLT_SUPPORTED
+# endif
+#endif
+#ifndef PNG_NO_WRITE_sRGB
+# define PNG_WRITE_sRGB_SUPPORTED
+# ifndef PNG_sRGB_SUPPORTED
+# define PNG_sRGB_SUPPORTED
+# endif
+#endif
+#ifndef PNG_NO_WRITE_tEXt
+# define PNG_WRITE_tEXt_SUPPORTED
+# ifndef PNG_tEXt_SUPPORTED
+# define PNG_tEXt_SUPPORTED
+# endif
+#endif
+#ifndef PNG_NO_WRITE_tIME
+# define PNG_WRITE_tIME_SUPPORTED
+# ifndef PNG_tIME_SUPPORTED
+# define PNG_tIME_SUPPORTED
+# endif
+#endif
+#ifndef PNG_NO_WRITE_tRNS
+# define PNG_WRITE_tRNS_SUPPORTED
+# ifndef PNG_tRNS_SUPPORTED
+# define PNG_tRNS_SUPPORTED
+# endif
+#endif
+#ifndef PNG_NO_WRITE_zTXt
+# define PNG_WRITE_zTXt_SUPPORTED
+# ifndef PNG_zTXt_SUPPORTED
+# define PNG_zTXt_SUPPORTED
+# endif
+#endif
+#ifndef PNG_NO_WRITE_UNKNOWN_CHUNKS
+# define PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
+# ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED
+# define PNG_UNKNOWN_CHUNKS_SUPPORTED
+# endif
+# ifndef PNG_NO_HANDLE_AS_UNKNOWN
+# ifndef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+# define PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+# endif
+# endif
+#endif
+#if defined(PNG_WRITE_iTXt_SUPPORTED) || defined(PNG_WRITE_tEXt_SUPPORTED) || \
+ defined(PNG_WRITE_zTXt_SUPPORTED)
+# define PNG_WRITE_TEXT_SUPPORTED
+# ifndef PNG_TEXT_SUPPORTED
+# define PNG_TEXT_SUPPORTED
+# endif
+#endif
+
+#endif /* PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED */
+
+/* Turn this off to disable png_read_png() and
+ * png_write_png() and leave the row_pointers member
+ * out of the info structure.
+ */
+#ifndef PNG_NO_INFO_IMAGE
+# define PNG_INFO_IMAGE_SUPPORTED
+#endif
+
+/* need the time information for reading tIME chunks */
+#if defined(PNG_tIME_SUPPORTED)
+# if !defined(_WIN32_WCE)
+ /* "time.h" functions are not supported on WindowsCE */
+# include <time.h>
+# endif
+#endif
+
+/* Some typedefs to get us started. These should be safe on most of the
+ * common platforms. The typedefs should be at least as large as the
+ * numbers suggest (a png_uint_32 must be at least 32 bits long), but they
+ * don't have to be exactly that size. Some compilers dislike passing
+ * unsigned shorts as function parameters, so you may be better off using
+ * unsigned int for png_uint_16. Likewise, for 64-bit systems, you may
+ * want to have unsigned int for png_uint_32 instead of unsigned long.
+ */
+
+typedef unsigned long png_uint_32;
+typedef long png_int_32;
+typedef unsigned short png_uint_16;
+typedef short png_int_16;
+typedef unsigned char png_byte;
+
+/* This is usually size_t. It is typedef'ed just in case you need it to
+ change (I'm not sure if you will or not, so I thought I'd be safe) */
+#ifdef PNG_SIZE_T
+ typedef PNG_SIZE_T png_size_t;
+# define png_sizeof(x) png_convert_size(sizeof(x))
+#else
+ typedef size_t png_size_t;
+# define png_sizeof(x) sizeof(x)
+#endif
+
+/* The following is needed for medium model support. It cannot be in the
+ * PNG_INTERNAL section. Needs modification for other compilers besides
+ * MSC. Model independent support declares all arrays and pointers to be
+ * large using the far keyword. The zlib version used must also support
+ * model independent data. As of version zlib 1.0.4, the necessary changes
+ * have been made in zlib. The USE_FAR_KEYWORD define triggers other
+ * changes that are needed. (Tim Wegner)
+ */
+
+/* Separate compiler dependencies (problem here is that zlib.h always
+ defines FAR. (SJT) */
+#ifdef __BORLANDC__
+# if defined(__LARGE__) || defined(__HUGE__) || defined(__COMPACT__)
+# define LDATA 1
+# else
+# define LDATA 0
+# endif
+ /* GRR: why is Cygwin in here? Cygwin is not Borland C... */
+# if !defined(__WIN32__) && !defined(__FLAT__) && !defined(__CYGWIN__)
+# define PNG_MAX_MALLOC_64K
+# if (LDATA != 1)
+# ifndef FAR
+# define FAR __far
+# endif
+# define USE_FAR_KEYWORD
+# endif /* LDATA != 1 */
+ /* Possibly useful for moving data out of default segment.
+ * Uncomment it if you want. Could also define FARDATA as
+ * const if your compiler supports it. (SJT)
+# define FARDATA FAR
+ */
+# endif /* __WIN32__, __FLAT__, __CYGWIN__ */
+#endif /* __BORLANDC__ */
+
+
+/* Suggest testing for specific compiler first before testing for
+ * FAR. The Watcom compiler defines both __MEDIUM__ and M_I86MM,
+ * making reliance oncertain keywords suspect. (SJT)
+ */
+
+/* MSC Medium model */
+#if defined(FAR)
+# if defined(M_I86MM)
+# define USE_FAR_KEYWORD
+# define FARDATA FAR
+# include <dos.h>
+# endif
+#endif
+
+/* SJT: default case */
+#ifndef FAR
+# define FAR
+#endif
+
+/* At this point FAR is always defined */
+#ifndef FARDATA
+# define FARDATA
+#endif
+
+/* Typedef for floating-point numbers that are converted
+ to fixed-point with a multiple of 100,000, e.g., int_gamma */
+typedef png_int_32 png_fixed_point;
+
+/* Add typedefs for pointers */
+typedef void FAR * png_voidp;
+typedef png_byte FAR * png_bytep;
+typedef png_uint_32 FAR * png_uint_32p;
+typedef png_int_32 FAR * png_int_32p;
+typedef png_uint_16 FAR * png_uint_16p;
+typedef png_int_16 FAR * png_int_16p;
+typedef PNG_CONST char FAR * png_const_charp;
+typedef char FAR * png_charp;
+typedef png_fixed_point FAR * png_fixed_point_p;
+
+#ifndef PNG_NO_STDIO
+#if defined(_WIN32_WCE)
+typedef HANDLE png_FILE_p;
+#else
+typedef FILE * png_FILE_p;
+#endif
+#endif
+
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+typedef double FAR * png_doublep;
+#endif
+
+/* Pointers to pointers; i.e. arrays */
+typedef png_byte FAR * FAR * png_bytepp;
+typedef png_uint_32 FAR * FAR * png_uint_32pp;
+typedef png_int_32 FAR * FAR * png_int_32pp;
+typedef png_uint_16 FAR * FAR * png_uint_16pp;
+typedef png_int_16 FAR * FAR * png_int_16pp;
+typedef PNG_CONST char FAR * FAR * png_const_charpp;
+typedef char FAR * FAR * png_charpp;
+typedef png_fixed_point FAR * FAR * png_fixed_point_pp;
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+typedef double FAR * FAR * png_doublepp;
+#endif
+
+/* Pointers to pointers to pointers; i.e., pointer to array */
+typedef char FAR * FAR * FAR * png_charppp;
+
+#if defined(PNG_1_0_X) || defined(PNG_1_2_X)
+/* SPC - Is this stuff deprecated? */
+/* It'll be removed as of libpng-1.3.0 - GR-P */
+/* libpng typedefs for types in zlib. If zlib changes
+ * or another compression library is used, then change these.
+ * Eliminates need to change all the source files.
+ */
+typedef charf * png_zcharp;
+typedef charf * FAR * png_zcharpp;
+typedef z_stream FAR * png_zstreamp;
+#endif /* (PNG_1_0_X) || defined(PNG_1_2_X) */
+
+/*
+ * Define PNG_BUILD_DLL if the module being built is a Windows
+ * LIBPNG DLL.
+ *
+ * Define PNG_USE_DLL if you want to *link* to the Windows LIBPNG DLL.
+ * It is equivalent to Microsoft predefined macro _DLL that is
+ * automatically defined when you compile using the share
+ * version of the CRT (C Run-Time library)
+ *
+ * The cygwin mods make this behavior a little different:
+ * Define PNG_BUILD_DLL if you are building a dll for use with cygwin
+ * Define PNG_STATIC if you are building a static library for use with cygwin,
+ * -or- if you are building an application that you want to link to the
+ * static library.
+ * PNG_USE_DLL is defined by default (no user action needed) unless one of
+ * the other flags is defined.
+ */
+
+#if !defined(PNG_DLL) && (defined(PNG_BUILD_DLL) || defined(PNG_USE_DLL))
+# define PNG_DLL
+#endif
+/* If CYGWIN, then disallow GLOBAL ARRAYS unless building a static lib.
+ * When building a static lib, default to no GLOBAL ARRAYS, but allow
+ * command-line override
+ */
+#if defined(__CYGWIN__)
+# if !defined(PNG_STATIC)
+# if defined(PNG_USE_GLOBAL_ARRAYS)
+# undef PNG_USE_GLOBAL_ARRAYS
+# endif
+# if !defined(PNG_USE_LOCAL_ARRAYS)
+# define PNG_USE_LOCAL_ARRAYS
+# endif
+# else
+# if defined(PNG_USE_LOCAL_ARRAYS) || defined(PNG_NO_GLOBAL_ARRAYS)
+# if defined(PNG_USE_GLOBAL_ARRAYS)
+# undef PNG_USE_GLOBAL_ARRAYS
+# endif
+# endif
+# endif
+# if !defined(PNG_USE_LOCAL_ARRAYS) && !defined(PNG_USE_GLOBAL_ARRAYS)
+# define PNG_USE_LOCAL_ARRAYS
+# endif
+#endif
+
+/* Do not use global arrays (helps with building DLL's)
+ * They are no longer used in libpng itself, since version 1.0.5c,
+ * but might be required for some pre-1.0.5c applications.
+ */
+#if !defined(PNG_USE_LOCAL_ARRAYS) && !defined(PNG_USE_GLOBAL_ARRAYS)
+# if defined(PNG_NO_GLOBAL_ARRAYS) || \
+ (defined(__GNUC__) && defined(PNG_DLL)) || defined(_MSC_VER)
+# define PNG_USE_LOCAL_ARRAYS
+# else
+# define PNG_USE_GLOBAL_ARRAYS
+# endif
+#endif
+
+#if defined(__CYGWIN__)
+# undef PNGAPI
+# define PNGAPI __cdecl
+# undef PNG_IMPEXP
+# define PNG_IMPEXP
+#endif
+
+/* If you define PNGAPI, e.g., with compiler option "-DPNGAPI=__stdcall",
+ * you may get warnings regarding the linkage of png_zalloc and png_zfree.
+ * Don't ignore those warnings; you must also reset the default calling
+ * convention in your compiler to match your PNGAPI, and you must build
+ * zlib and your applications the same way you build libpng.
+ */
+
+#if defined(__MINGW32__) && !defined(PNG_MODULEDEF)
+# ifndef PNG_NO_MODULEDEF
+# define PNG_NO_MODULEDEF
+# endif
+#endif
+
+#if !defined(PNG_IMPEXP) && defined(PNG_BUILD_DLL) && !defined(PNG_NO_MODULEDEF)
+# define PNG_IMPEXP
+#endif
+
+#if defined(PNG_DLL) || defined(_DLL) || defined(__DLL__ ) || \
+ (( defined(_Windows) || defined(_WINDOWS) || \
+ defined(WIN32) || defined(_WIN32) || defined(__WIN32__) ))
+
+# ifndef PNGAPI
+# if defined(__GNUC__) || (defined (_MSC_VER) && (_MSC_VER >= 800))
+# define PNGAPI __cdecl
+# else
+# define PNGAPI _cdecl
+# endif
+# endif
+
+# if !defined(PNG_IMPEXP) && (!defined(PNG_DLL) || \
+ 0 /* WINCOMPILER_WITH_NO_SUPPORT_FOR_DECLIMPEXP */)
+# define PNG_IMPEXP
+# endif
+
+# if !defined(PNG_IMPEXP)
+
+# define PNG_EXPORT_TYPE1(type,symbol) PNG_IMPEXP type PNGAPI symbol
+# define PNG_EXPORT_TYPE2(type,symbol) type PNG_IMPEXP PNGAPI symbol
+
+ /* Borland/Microsoft */
+# if defined(_MSC_VER) || defined(__BORLANDC__)
+# if (_MSC_VER >= 800) || (__BORLANDC__ >= 0x500)
+# define PNG_EXPORT PNG_EXPORT_TYPE1
+# else
+# define PNG_EXPORT PNG_EXPORT_TYPE2
+# if defined(PNG_BUILD_DLL)
+# define PNG_IMPEXP __export
+# else
+# define PNG_IMPEXP /*__import */ /* doesn't exist AFAIK in
+ VC++ */
+# endif /* Exists in Borland C++ for
+ C++ classes (== huge) */
+# endif
+# endif
+
+# if !defined(PNG_IMPEXP)
+# if defined(PNG_BUILD_DLL)
+# define PNG_IMPEXP __declspec(dllexport)
+# else
+# define PNG_IMPEXP __declspec(dllimport)
+# endif
+# endif
+# endif /* PNG_IMPEXP */
+#else /* !(DLL || non-cygwin WINDOWS) */
+# if (defined(__IBMC__) || defined(__IBMCPP__)) && defined(__OS2__)
+# ifndef PNGAPI
+# define PNGAPI _System
+# endif
+# else
+# if 0 /* ... other platforms, with other meanings */
+# endif
+# endif
+#endif
+
+#ifndef PNGAPI
+# define PNGAPI
+#endif
+#ifndef PNG_IMPEXP
+# define PNG_IMPEXP
+#endif
+
+#ifdef PNG_BUILDSYMS
+# ifndef PNG_EXPORT
+# define PNG_EXPORT(type,symbol) PNG_FUNCTION_EXPORT symbol END
+# endif
+# ifdef PNG_USE_GLOBAL_ARRAYS
+# ifndef PNG_EXPORT_VAR
+# define PNG_EXPORT_VAR(type) PNG_DATA_EXPORT
+# endif
+# endif
+#endif
+
+#ifndef PNG_EXPORT
+# define PNG_EXPORT(type,symbol) PNG_IMPEXP type PNGAPI symbol
+#endif
+
+#ifdef PNG_USE_GLOBAL_ARRAYS
+# ifndef PNG_EXPORT_VAR
+# define PNG_EXPORT_VAR(type) extern PNG_IMPEXP type
+# endif
+#endif
+
+/* User may want to use these so they are not in PNG_INTERNAL. Any library
+ * functions that are passed far data must be model independent.
+ */
+
+#ifndef PNG_ABORT
+# define PNG_ABORT() abort()
+#endif
+
+#ifdef PNG_SETJMP_SUPPORTED
+# define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf)
+#else
+# define png_jmpbuf(png_ptr) \
+ (LIBPNG_WAS_COMPILED_WITH__PNG_SETJMP_NOT_SUPPORTED)
+#endif
+
+#if defined(USE_FAR_KEYWORD) /* memory model independent fns */
+/* use this to make far-to-near assignments */
+# define CHECK 1
+# define NOCHECK 0
+# define CVT_PTR(ptr) (png_far_to_near(png_ptr,ptr,CHECK))
+# define CVT_PTR_NOCHECK(ptr) (png_far_to_near(png_ptr,ptr,NOCHECK))
+# define png_snprintf _fsnprintf /* Added to v 1.2.19 */
+# define png_strlen _fstrlen
+# define png_memcmp _fmemcmp /* SJT: added */
+# define png_memcpy _fmemcpy
+# define png_memset _fmemset
+#else /* use the usual functions */
+# define CVT_PTR(ptr) (ptr)
+# define CVT_PTR_NOCHECK(ptr) (ptr)
+# ifndef PNG_NO_SNPRINTF
+# ifdef _MSC_VER
+# define png_snprintf _snprintf /* Added to v 1.2.19 */
+# define png_snprintf2 _snprintf
+# define png_snprintf6 _snprintf
+# else
+# define png_snprintf snprintf /* Added to v 1.2.19 */
+# define png_snprintf2 snprintf
+# define png_snprintf6 snprintf
+# endif
+# else
+ /* You don't have or don't want to use snprintf(). Caution: Using
+ * sprintf instead of snprintf exposes your application to accidental
+ * or malevolent buffer overflows. If you don't have snprintf()
+ * as a general rule you should provide one (you can get one from
+ * Portable OpenSSH). */
+# define png_snprintf(s1,n,fmt,x1) sprintf(s1,fmt,x1)
+# define png_snprintf2(s1,n,fmt,x1,x2) sprintf(s1,fmt,x1,x2)
+# define png_snprintf6(s1,n,fmt,x1,x2,x3,x4,x5,x6) \
+ sprintf(s1,fmt,x1,x2,x3,x4,x5,x6)
+# endif
+# define png_strlen strlen
+# define png_memcmp memcmp /* SJT: added */
+# define png_memcpy memcpy
+# define png_memset memset
+#endif
+/* End of memory model independent support */
+
+/* Just a little check that someone hasn't tried to define something
+ * contradictory.
+ */
+#if (PNG_ZBUF_SIZE > 65536L) && defined(PNG_MAX_MALLOC_64K)
+# undef PNG_ZBUF_SIZE
+# define PNG_ZBUF_SIZE 65536L
+#endif
+
+/* Added at libpng-1.2.8 */
+#endif /* PNG_VERSION_INFO_ONLY */
+
+#endif /* PNGCONF_H */
--- /dev/null
+
+/* pngerror.c - stub functions for i/o and memory allocation
+ *
+ * Last changed in libpng 1.2.30 [August 15, 2008]
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * This file provides a location for all error handling. Users who
+ * need special error handling are expected to write replacement functions
+ * and use png_set_error_fn() to use those functions. See the instructions
+ * at each function.
+ */
+
+#define PNG_INTERNAL
+#include "png.h"
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
+
+static void /* PRIVATE */
+png_default_error PNGARG((png_structp png_ptr,
+ png_const_charp error_message));
+#ifndef PNG_NO_WARNINGS
+static void /* PRIVATE */
+png_default_warning PNGARG((png_structp png_ptr,
+ png_const_charp warning_message));
+#endif /* PNG_NO_WARNINGS */
+
+/* This function is called whenever there is a fatal error. This function
+ * should not be changed. If there is a need to handle errors differently,
+ * you should supply a replacement error function and use png_set_error_fn()
+ * to replace the error function at run-time.
+ */
+#ifndef PNG_NO_ERROR_TEXT
+void PNGAPI
+png_error(png_structp png_ptr, png_const_charp error_message)
+{
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED
+ char msg[16];
+ if (png_ptr != NULL)
+ {
+ if (png_ptr->flags&
+ (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
+ {
+ if (*error_message == '#')
+ {
+ /* Strip "#nnnn " from beginning of error message. */
+ int offset;
+ for (offset = 1; offset<15; offset++)
+ if (error_message[offset] == ' ')
+ break;
+ if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
+ {
+ int i;
+ for (i = 0; i < offset - 1; i++)
+ msg[i] = error_message[i + 1];
+ msg[i - 1] = '\0';
+ error_message = msg;
+ }
+ else
+ error_message += offset;
+ }
+ else
+ {
+ if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
+ {
+ msg[0] = '0';
+ msg[1] = '\0';
+ error_message = msg;
+ }
+ }
+ }
+ }
+#endif
+ if (png_ptr != NULL && png_ptr->error_fn != NULL)
+ (*(png_ptr->error_fn))(png_ptr, error_message);
+
+ /* If the custom handler doesn't exist, or if it returns,
+ use the default handler, which will not return. */
+ png_default_error(png_ptr, error_message);
+}
+#else
+void PNGAPI
+png_err(png_structp png_ptr)
+{
+ if (png_ptr != NULL && png_ptr->error_fn != NULL)
+ (*(png_ptr->error_fn))(png_ptr, '\0');
+
+ /* If the custom handler doesn't exist, or if it returns,
+ use the default handler, which will not return. */
+ png_default_error(png_ptr, '\0');
+}
+#endif /* PNG_NO_ERROR_TEXT */
+
+#ifndef PNG_NO_WARNINGS
+/* This function is called whenever there is a non-fatal error. This function
+ * should not be changed. If there is a need to handle warnings differently,
+ * you should supply a replacement warning function and use
+ * png_set_error_fn() to replace the warning function at run-time.
+ */
+void PNGAPI
+png_warning(png_structp png_ptr, png_const_charp warning_message)
+{
+ int offset = 0;
+ if (png_ptr != NULL)
+ {
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED
+ if (png_ptr->flags&
+ (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
+#endif
+ {
+ if (*warning_message == '#')
+ {
+ for (offset = 1; offset < 15; offset++)
+ if (warning_message[offset] == ' ')
+ break;
+ }
+ }
+ if (png_ptr != NULL && png_ptr->warning_fn != NULL)
+ (*(png_ptr->warning_fn))(png_ptr, warning_message + offset);
+ }
+ else
+ png_default_warning(png_ptr, warning_message + offset);
+}
+#endif /* PNG_NO_WARNINGS */
+
+
+/* These utilities are used internally to build an error message that relates
+ * to the current chunk. The chunk name comes from png_ptr->chunk_name,
+ * this is used to prefix the message. The message is limited in length
+ * to 63 bytes, the name characters are output as hex digits wrapped in []
+ * if the character is invalid.
+ */
+#define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))
+static PNG_CONST char png_digit[16] = {
+ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+ 'A', 'B', 'C', 'D', 'E', 'F'
+};
+
+#define PNG_MAX_ERROR_TEXT 64
+
+#if !defined(PNG_NO_WARNINGS) || !defined(PNG_NO_ERROR_TEXT)
+static void /* PRIVATE */
+png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp
+ error_message)
+{
+ int iout = 0, iin = 0;
+
+ while (iin < 4)
+ {
+ int c = png_ptr->chunk_name[iin++];
+ if (isnonalpha(c))
+ {
+ buffer[iout++] = '[';
+ buffer[iout++] = png_digit[(c & 0xf0) >> 4];
+ buffer[iout++] = png_digit[c & 0x0f];
+ buffer[iout++] = ']';
+ }
+ else
+ {
+ buffer[iout++] = (png_byte)c;
+ }
+ }
+
+ if (error_message == NULL)
+ buffer[iout] = '\0';
+ else
+ {
+ buffer[iout++] = ':';
+ buffer[iout++] = ' ';
+ png_memcpy(buffer + iout, error_message, PNG_MAX_ERROR_TEXT);
+ buffer[iout + PNG_MAX_ERROR_TEXT - 1] = '\0';
+ }
+}
+
+#ifdef PNG_READ_SUPPORTED
+void PNGAPI
+png_chunk_error(png_structp png_ptr, png_const_charp error_message)
+{
+ char msg[18+PNG_MAX_ERROR_TEXT];
+ if (png_ptr == NULL)
+ png_error(png_ptr, error_message);
+ else
+ {
+ png_format_buffer(png_ptr, msg, error_message);
+ png_error(png_ptr, msg);
+ }
+}
+#endif /* PNG_READ_SUPPORTED */
+#endif /* !defined(PNG_NO_WARNINGS) || !defined(PNG_NO_ERROR_TEXT) */
+
+#ifndef PNG_NO_WARNINGS
+void PNGAPI
+png_chunk_warning(png_structp png_ptr, png_const_charp warning_message)
+{
+ char msg[18+PNG_MAX_ERROR_TEXT];
+ if (png_ptr == NULL)
+ png_warning(png_ptr, warning_message);
+ else
+ {
+ png_format_buffer(png_ptr, msg, warning_message);
+ png_warning(png_ptr, msg);
+ }
+}
+#endif /* PNG_NO_WARNINGS */
+
+
+/* This is the default error handling function. Note that replacements for
+ * this function MUST NOT RETURN, or the program will likely crash. This
+ * function is used by default, or if the program supplies NULL for the
+ * error function pointer in png_set_error_fn().
+ */
+static void /* PRIVATE */
+png_default_error(png_structp png_ptr, png_const_charp error_message)
+{
+#ifndef PNG_NO_CONSOLE_IO
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED
+ if (*error_message == '#')
+ {
+ /* Strip "#nnnn " from beginning of warning message. */
+ int offset;
+ char error_number[16];
+ for (offset = 0; offset<15; offset++)
+ {
+ error_number[offset] = error_message[offset + 1];
+ if (error_message[offset] == ' ')
+ break;
+ }
+ if ((offset > 1) && (offset < 15))
+ {
+ error_number[offset - 1] = '\0';
+ fprintf(stderr, "libpng error no. %s: %s\n", error_number,
+ error_message + offset + 1);
+ }
+ else
+ fprintf(stderr, "libpng error: %s, offset=%d\n", error_message, offset);
+ }
+ else
+#endif
+ fprintf(stderr, "libpng error: %s\n", error_message);
+#endif
+
+#ifdef PNG_SETJMP_SUPPORTED
+ if (png_ptr)
+ {
+# ifdef USE_FAR_KEYWORD
+ {
+ jmp_buf jmpbuf;
+ png_memcpy(jmpbuf, png_ptr->jmpbuf, png_sizeof(jmp_buf));
+ longjmp(jmpbuf, 1);
+ }
+# else
+ longjmp(png_ptr->jmpbuf, 1);
+# endif
+ }
+#else
+ PNG_ABORT();
+#endif
+#ifdef PNG_NO_CONSOLE_IO
+ error_message = error_message; /* make compiler happy */
+#endif
+}
+
+#ifndef PNG_NO_WARNINGS
+/* This function is called when there is a warning, but the library thinks
+ * it can continue anyway. Replacement functions don't have to do anything
+ * here if you don't want them to. In the default configuration, png_ptr is
+ * not used, but it is passed in case it may be useful.
+ */
+static void /* PRIVATE */
+png_default_warning(png_structp png_ptr, png_const_charp warning_message)
+{
+#ifndef PNG_NO_CONSOLE_IO
+# ifdef PNG_ERROR_NUMBERS_SUPPORTED
+ if (*warning_message == '#')
+ {
+ int offset;
+ char warning_number[16];
+ for (offset = 0; offset < 15; offset++)
+ {
+ warning_number[offset] = warning_message[offset + 1];
+ if (warning_message[offset] == ' ')
+ break;
+ }
+ if ((offset > 1) && (offset < 15))
+ {
+ warning_number[offset + 1] = '\0';
+ fprintf(stderr, "libpng warning no. %s: %s\n", warning_number,
+ warning_message + offset);
+ }
+ else
+ fprintf(stderr, "libpng warning: %s\n", warning_message);
+ }
+ else
+# endif
+ fprintf(stderr, "libpng warning: %s\n", warning_message);
+#else
+ warning_message = warning_message; /* make compiler happy */
+#endif
+ png_ptr = png_ptr; /* make compiler happy */
+}
+#endif /* PNG_NO_WARNINGS */
+
+/* This function is called when the application wants to use another method
+ * of handling errors and warnings. Note that the error function MUST NOT
+ * return to the calling routine or serious problems will occur. The return
+ * method used in the default routine calls longjmp(png_ptr->jmpbuf, 1)
+ */
+void PNGAPI
+png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,
+ png_error_ptr error_fn, png_error_ptr warning_fn)
+{
+ if (png_ptr == NULL)
+ return;
+ png_ptr->error_ptr = error_ptr;
+ png_ptr->error_fn = error_fn;
+ png_ptr->warning_fn = warning_fn;
+}
+
+
+/* This function returns a pointer to the error_ptr associated with the user
+ * functions. The application should free any memory associated with this
+ * pointer before png_write_destroy and png_read_destroy are called.
+ */
+png_voidp PNGAPI
+png_get_error_ptr(png_structp png_ptr)
+{
+ if (png_ptr == NULL)
+ return NULL;
+ return ((png_voidp)png_ptr->error_ptr);
+}
+
+
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED
+void PNGAPI
+png_set_strip_error_numbers(png_structp png_ptr, png_uint_32 strip_mode)
+{
+ if (png_ptr != NULL)
+ {
+ png_ptr->flags &=
+ ((~(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode);
+ }
+}
+#endif
+#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
--- /dev/null
+
+/* pngget.c - retrieval of values from info struct
+ *
+ * Last changed in libpng 1.2.30 [August 15, 2008]
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ */
+
+#define PNG_INTERNAL
+#include "png.h"
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
+
+png_uint_32 PNGAPI
+png_get_valid(png_structp png_ptr, png_infop info_ptr, png_uint_32 flag)
+{
+ if (png_ptr != NULL && info_ptr != NULL)
+ return(info_ptr->valid & flag);
+ else
+ return(0);
+}
+
+png_uint_32 PNGAPI
+png_get_rowbytes(png_structp png_ptr, png_infop info_ptr)
+{
+ if (png_ptr != NULL && info_ptr != NULL)
+ return(info_ptr->rowbytes);
+ else
+ return(0);
+}
+
+#if defined(PNG_INFO_IMAGE_SUPPORTED)
+png_bytepp PNGAPI
+png_get_rows(png_structp png_ptr, png_infop info_ptr)
+{
+ if (png_ptr != NULL && info_ptr != NULL)
+ return(info_ptr->row_pointers);
+ else
+ return(0);
+}
+#endif
+
+#ifdef PNG_EASY_ACCESS_SUPPORTED
+/* easy access to info, added in libpng-0.99 */
+png_uint_32 PNGAPI
+png_get_image_width(png_structp png_ptr, png_infop info_ptr)
+{
+ if (png_ptr != NULL && info_ptr != NULL)
+ {
+ return info_ptr->width;
+ }
+ return (0);
+}
+
+png_uint_32 PNGAPI
+png_get_image_height(png_structp png_ptr, png_infop info_ptr)
+{
+ if (png_ptr != NULL && info_ptr != NULL)
+ {
+ return info_ptr->height;
+ }
+ return (0);
+}
+
+png_byte PNGAPI
+png_get_bit_depth(png_structp png_ptr, png_infop info_ptr)
+{
+ if (png_ptr != NULL && info_ptr != NULL)
+ {
+ return info_ptr->bit_depth;
+ }
+ return (0);
+}
+
+png_byte PNGAPI
+png_get_color_type(png_structp png_ptr, png_infop info_ptr)
+{
+ if (png_ptr != NULL && info_ptr != NULL)
+ {
+ return info_ptr->color_type;
+ }
+ return (0);
+}
+
+png_byte PNGAPI
+png_get_filter_type(png_structp png_ptr, png_infop info_ptr)
+{
+ if (png_ptr != NULL && info_ptr != NULL)
+ {
+ return info_ptr->filter_type;
+ }
+ return (0);
+}
+
+png_byte PNGAPI
+png_get_interlace_type(png_structp png_ptr, png_infop info_ptr)
+{
+ if (png_ptr != NULL && info_ptr != NULL)
+ {
+ return info_ptr->interlace_type;
+ }
+ return (0);
+}
+
+png_byte PNGAPI
+png_get_compression_type(png_structp png_ptr, png_infop info_ptr)
+{
+ if (png_ptr != NULL && info_ptr != NULL)
+ {
+ return info_ptr->compression_type;
+ }
+ return (0);
+}
+
+png_uint_32 PNGAPI
+png_get_x_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
+{
+ if (png_ptr != NULL && info_ptr != NULL)
+#if defined(PNG_pHYs_SUPPORTED)
+ if (info_ptr->valid & PNG_INFO_pHYs)
+ {
+ png_debug1(1, "in %s retrieval function\n", "png_get_x_pixels_per_meter");
+ if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER)
+ return (0);
+ else return (info_ptr->x_pixels_per_unit);
+ }
+#else
+ return (0);
+#endif
+ return (0);
+}
+
+png_uint_32 PNGAPI
+png_get_y_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
+{
+ if (png_ptr != NULL && info_ptr != NULL)
+#if defined(PNG_pHYs_SUPPORTED)
+ if (info_ptr->valid & PNG_INFO_pHYs)
+ {
+ png_debug1(1, "in %s retrieval function\n", "png_get_y_pixels_per_meter");
+ if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER)
+ return (0);
+ else return (info_ptr->y_pixels_per_unit);
+ }
+#else
+ return (0);
+#endif
+ return (0);
+}
+
+png_uint_32 PNGAPI
+png_get_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
+{
+ if (png_ptr != NULL && info_ptr != NULL)
+#if defined(PNG_pHYs_SUPPORTED)
+ if (info_ptr->valid & PNG_INFO_pHYs)
+ {
+ png_debug1(1, "in %s retrieval function\n", "png_get_pixels_per_meter");
+ if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER ||
+ info_ptr->x_pixels_per_unit != info_ptr->y_pixels_per_unit)
+ return (0);
+ else return (info_ptr->x_pixels_per_unit);
+ }
+#else
+ return (0);
+#endif
+ return (0);
+}
+
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+float PNGAPI
+png_get_pixel_aspect_ratio(png_structp png_ptr, png_infop info_ptr)
+ {
+ if (png_ptr != NULL && info_ptr != NULL)
+#if defined(PNG_pHYs_SUPPORTED)
+ if (info_ptr->valid & PNG_INFO_pHYs)
+ {
+ png_debug1(1, "in %s retrieval function\n", "png_get_aspect_ratio");
+ if (info_ptr->x_pixels_per_unit == 0)
+ return ((float)0.0);
+ else
+ return ((float)((float)info_ptr->y_pixels_per_unit
+ /(float)info_ptr->x_pixels_per_unit));
+ }
+#else
+ return (0.0);
+#endif
+ return ((float)0.0);
+}
+#endif
+
+png_int_32 PNGAPI
+png_get_x_offset_microns(png_structp png_ptr, png_infop info_ptr)
+{
+ if (png_ptr != NULL && info_ptr != NULL)
+#if defined(PNG_oFFs_SUPPORTED)
+ if (info_ptr->valid & PNG_INFO_oFFs)
+ {
+ png_debug1(1, "in %s retrieval function\n", "png_get_x_offset_microns");
+ if (info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)
+ return (0);
+ else return (info_ptr->x_offset);
+ }
+#else
+ return (0);
+#endif
+ return (0);
+}
+
+png_int_32 PNGAPI
+png_get_y_offset_microns(png_structp png_ptr, png_infop info_ptr)
+{
+ if (png_ptr != NULL && info_ptr != NULL)
+#if defined(PNG_oFFs_SUPPORTED)
+ if (info_ptr->valid & PNG_INFO_oFFs)
+ {
+ png_debug1(1, "in %s retrieval function\n", "png_get_y_offset_microns");
+ if (info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)
+ return (0);
+ else return (info_ptr->y_offset);
+ }
+#else
+ return (0);
+#endif
+ return (0);
+}
+
+png_int_32 PNGAPI
+png_get_x_offset_pixels(png_structp png_ptr, png_infop info_ptr)
+{
+ if (png_ptr != NULL && info_ptr != NULL)
+#if defined(PNG_oFFs_SUPPORTED)
+ if (info_ptr->valid & PNG_INFO_oFFs)
+ {
+ png_debug1(1, "in %s retrieval function\n", "png_get_x_offset_microns");
+ if (info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)
+ return (0);
+ else return (info_ptr->x_offset);
+ }
+#else
+ return (0);
+#endif
+ return (0);
+}
+
+png_int_32 PNGAPI
+png_get_y_offset_pixels(png_structp png_ptr, png_infop info_ptr)
+{
+ if (png_ptr != NULL && info_ptr != NULL)
+#if defined(PNG_oFFs_SUPPORTED)
+ if (info_ptr->valid & PNG_INFO_oFFs)
+ {
+ png_debug1(1, "in %s retrieval function\n", "png_get_y_offset_microns");
+ if (info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)
+ return (0);
+ else return (info_ptr->y_offset);
+ }
+#else
+ return (0);
+#endif
+ return (0);
+}
+
+#if defined(PNG_INCH_CONVERSIONS) && defined(PNG_FLOATING_POINT_SUPPORTED)
+png_uint_32 PNGAPI
+png_get_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)
+{
+ return ((png_uint_32)((float)png_get_pixels_per_meter(png_ptr, info_ptr)
+ *.0254 +.5));
+}
+
+png_uint_32 PNGAPI
+png_get_x_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)
+{
+ return ((png_uint_32)((float)png_get_x_pixels_per_meter(png_ptr, info_ptr)
+ *.0254 +.5));
+}
+
+png_uint_32 PNGAPI
+png_get_y_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)
+{
+ return ((png_uint_32)((float)png_get_y_pixels_per_meter(png_ptr, info_ptr)
+ *.0254 +.5));
+}
+
+float PNGAPI
+png_get_x_offset_inches(png_structp png_ptr, png_infop info_ptr)
+{
+ return ((float)png_get_x_offset_microns(png_ptr, info_ptr)
+ *.00003937);
+}
+
+float PNGAPI
+png_get_y_offset_inches(png_structp png_ptr, png_infop info_ptr)
+{
+ return ((float)png_get_y_offset_microns(png_ptr, info_ptr)
+ *.00003937);
+}
+
+#if defined(PNG_pHYs_SUPPORTED)
+png_uint_32 PNGAPI
+png_get_pHYs_dpi(png_structp png_ptr, png_infop info_ptr,
+ png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
+{
+ png_uint_32 retval = 0;
+
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
+ {
+ png_debug1(1, "in %s retrieval function\n", "pHYs");
+ if (res_x != NULL)
+ {
+ *res_x = info_ptr->x_pixels_per_unit;
+ retval |= PNG_INFO_pHYs;
+ }
+ if (res_y != NULL)
+ {
+ *res_y = info_ptr->y_pixels_per_unit;
+ retval |= PNG_INFO_pHYs;
+ }
+ if (unit_type != NULL)
+ {
+ *unit_type = (int)info_ptr->phys_unit_type;
+ retval |= PNG_INFO_pHYs;
+ if (*unit_type == 1)
+ {
+ if (res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50);
+ if (res_y != NULL) *res_y = (png_uint_32)(*res_y * .0254 + .50);
+ }
+ }
+ }
+ return (retval);
+}
+#endif /* PNG_pHYs_SUPPORTED */
+#endif /* PNG_INCH_CONVERSIONS && PNG_FLOATING_POINT_SUPPORTED */
+
+/* png_get_channels really belongs in here, too, but it's been around longer */
+
+#endif /* PNG_EASY_ACCESS_SUPPORTED */
+
+png_byte PNGAPI
+png_get_channels(png_structp png_ptr, png_infop info_ptr)
+{
+ if (png_ptr != NULL && info_ptr != NULL)
+ return(info_ptr->channels);
+ else
+ return (0);
+}
+
+png_bytep PNGAPI
+png_get_signature(png_structp png_ptr, png_infop info_ptr)
+{
+ if (png_ptr != NULL && info_ptr != NULL)
+ return(info_ptr->signature);
+ else
+ return (NULL);
+}
+
+#if defined(PNG_bKGD_SUPPORTED)
+png_uint_32 PNGAPI
+png_get_bKGD(png_structp png_ptr, png_infop info_ptr,
+ png_color_16p *background)
+{
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD)
+ && background != NULL)
+ {
+ png_debug1(1, "in %s retrieval function\n", "bKGD");
+ *background = &(info_ptr->background);
+ return (PNG_INFO_bKGD);
+ }
+ return (0);
+}
+#endif
+
+#if defined(PNG_cHRM_SUPPORTED)
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+png_uint_32 PNGAPI
+png_get_cHRM(png_structp png_ptr, png_infop info_ptr,
+ double *white_x, double *white_y, double *red_x, double *red_y,
+ double *green_x, double *green_y, double *blue_x, double *blue_y)
+{
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))
+ {
+ png_debug1(1, "in %s retrieval function\n", "cHRM");
+ if (white_x != NULL)
+ *white_x = (double)info_ptr->x_white;
+ if (white_y != NULL)
+ *white_y = (double)info_ptr->y_white;
+ if (red_x != NULL)
+ *red_x = (double)info_ptr->x_red;
+ if (red_y != NULL)
+ *red_y = (double)info_ptr->y_red;
+ if (green_x != NULL)
+ *green_x = (double)info_ptr->x_green;
+ if (green_y != NULL)
+ *green_y = (double)info_ptr->y_green;
+ if (blue_x != NULL)
+ *blue_x = (double)info_ptr->x_blue;
+ if (blue_y != NULL)
+ *blue_y = (double)info_ptr->y_blue;
+ return (PNG_INFO_cHRM);
+ }
+ return (0);
+}
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+png_uint_32 PNGAPI
+png_get_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,
+ png_fixed_point *white_x, png_fixed_point *white_y, png_fixed_point *red_x,
+ png_fixed_point *red_y, png_fixed_point *green_x, png_fixed_point *green_y,
+ png_fixed_point *blue_x, png_fixed_point *blue_y)
+{
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))
+ {
+ png_debug1(1, "in %s retrieval function\n", "cHRM");
+ if (white_x != NULL)
+ *white_x = info_ptr->int_x_white;
+ if (white_y != NULL)
+ *white_y = info_ptr->int_y_white;
+ if (red_x != NULL)
+ *red_x = info_ptr->int_x_red;
+ if (red_y != NULL)
+ *red_y = info_ptr->int_y_red;
+ if (green_x != NULL)
+ *green_x = info_ptr->int_x_green;
+ if (green_y != NULL)
+ *green_y = info_ptr->int_y_green;
+ if (blue_x != NULL)
+ *blue_x = info_ptr->int_x_blue;
+ if (blue_y != NULL)
+ *blue_y = info_ptr->int_y_blue;
+ return (PNG_INFO_cHRM);
+ }
+ return (0);
+}
+#endif
+#endif
+
+#if defined(PNG_gAMA_SUPPORTED)
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+png_uint_32 PNGAPI
+png_get_gAMA(png_structp png_ptr, png_infop info_ptr, double *file_gamma)
+{
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)
+ && file_gamma != NULL)
+ {
+ png_debug1(1, "in %s retrieval function\n", "gAMA");
+ *file_gamma = (double)info_ptr->gamma;
+ return (PNG_INFO_gAMA);
+ }
+ return (0);
+}
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+png_uint_32 PNGAPI
+png_get_gAMA_fixed(png_structp png_ptr, png_infop info_ptr,
+ png_fixed_point *int_file_gamma)
+{
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)
+ && int_file_gamma != NULL)
+ {
+ png_debug1(1, "in %s retrieval function\n", "gAMA");
+ *int_file_gamma = info_ptr->int_gamma;
+ return (PNG_INFO_gAMA);
+ }
+ return (0);
+}
+#endif
+#endif
+
+#if defined(PNG_sRGB_SUPPORTED)
+png_uint_32 PNGAPI
+png_get_sRGB(png_structp png_ptr, png_infop info_ptr, int *file_srgb_intent)
+{
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)
+ && file_srgb_intent != NULL)
+ {
+ png_debug1(1, "in %s retrieval function\n", "sRGB");
+ *file_srgb_intent = (int)info_ptr->srgb_intent;
+ return (PNG_INFO_sRGB);
+ }
+ return (0);
+}
+#endif
+
+#if defined(PNG_iCCP_SUPPORTED)
+png_uint_32 PNGAPI
+png_get_iCCP(png_structp png_ptr, png_infop info_ptr,
+ png_charpp name, int *compression_type,
+ png_charpp profile, png_uint_32 *proflen)
+{
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP)
+ && name != NULL && profile != NULL && proflen != NULL)
+ {
+ png_debug1(1, "in %s retrieval function\n", "iCCP");
+ *name = info_ptr->iccp_name;
+ *profile = info_ptr->iccp_profile;
+ /* compression_type is a dummy so the API won't have to change
+ if we introduce multiple compression types later. */
+ *proflen = (int)info_ptr->iccp_proflen;
+ *compression_type = (int)info_ptr->iccp_compression;
+ return (PNG_INFO_iCCP);
+ }
+ return (0);
+}
+#endif
+
+#if defined(PNG_sPLT_SUPPORTED)
+png_uint_32 PNGAPI
+png_get_sPLT(png_structp png_ptr, png_infop info_ptr,
+ png_sPLT_tpp spalettes)
+{
+ if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL)
+ {
+ *spalettes = info_ptr->splt_palettes;
+ return ((png_uint_32)info_ptr->splt_palettes_num);
+ }
+ return (0);
+}
+#endif
+
+#if defined(PNG_hIST_SUPPORTED)
+png_uint_32 PNGAPI
+png_get_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p *hist)
+{
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST)
+ && hist != NULL)
+ {
+ png_debug1(1, "in %s retrieval function\n", "hIST");
+ *hist = info_ptr->hist;
+ return (PNG_INFO_hIST);
+ }
+ return (0);
+}
+#endif
+
+png_uint_32 PNGAPI
+png_get_IHDR(png_structp png_ptr, png_infop info_ptr,
+ png_uint_32 *width, png_uint_32 *height, int *bit_depth,
+ int *color_type, int *interlace_type, int *compression_type,
+ int *filter_type)
+
+{
+ if (png_ptr != NULL && info_ptr != NULL && width != NULL && height != NULL &&
+ bit_depth != NULL && color_type != NULL)
+ {
+ png_debug1(1, "in %s retrieval function\n", "IHDR");
+ *width = info_ptr->width;
+ *height = info_ptr->height;
+ *bit_depth = info_ptr->bit_depth;
+ if (info_ptr->bit_depth < 1 || info_ptr->bit_depth > 16)
+ png_error(png_ptr, "Invalid bit depth");
+ *color_type = info_ptr->color_type;
+ if (info_ptr->color_type > 6)
+ png_error(png_ptr, "Invalid color type");
+ if (compression_type != NULL)
+ *compression_type = info_ptr->compression_type;
+ if (filter_type != NULL)
+ *filter_type = info_ptr->filter_type;
+ if (interlace_type != NULL)
+ *interlace_type = info_ptr->interlace_type;
+
+ /* check for potential overflow of rowbytes */
+ if (*width == 0 || *width > PNG_UINT_31_MAX)
+ png_error(png_ptr, "Invalid image width");
+ if (*height == 0 || *height > PNG_UINT_31_MAX)
+ png_error(png_ptr, "Invalid image height");
+ if (info_ptr->width > (PNG_UINT_32_MAX
+ >> 3) /* 8-byte RGBA pixels */
+ - 64 /* bigrowbuf hack */
+ - 1 /* filter byte */
+ - 7*8 /* rounding of width to multiple of 8 pixels */
+ - 8) /* extra max_pixel_depth pad */
+ {
+ png_warning(png_ptr,
+ "Width too large for libpng to process image data.");
+ }
+ return (1);
+ }
+ return (0);
+}
+
+#if defined(PNG_oFFs_SUPPORTED)
+png_uint_32 PNGAPI
+png_get_oFFs(png_structp png_ptr, png_infop info_ptr,
+ png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type)
+{
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)
+ && offset_x != NULL && offset_y != NULL && unit_type != NULL)
+ {
+ png_debug1(1, "in %s retrieval function\n", "oFFs");
+ *offset_x = info_ptr->x_offset;
+ *offset_y = info_ptr->y_offset;
+ *unit_type = (int)info_ptr->offset_unit_type;
+ return (PNG_INFO_oFFs);
+ }
+ return (0);
+}
+#endif
+
+#if defined(PNG_pCAL_SUPPORTED)
+png_uint_32 PNGAPI
+png_get_pCAL(png_structp png_ptr, png_infop info_ptr,
+ png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams,
+ png_charp *units, png_charpp *params)
+{
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL)
+ && purpose != NULL && X0 != NULL && X1 != NULL && type != NULL &&
+ nparams != NULL && units != NULL && params != NULL)
+ {
+ png_debug1(1, "in %s retrieval function\n", "pCAL");
+ *purpose = info_ptr->pcal_purpose;
+ *X0 = info_ptr->pcal_X0;
+ *X1 = info_ptr->pcal_X1;
+ *type = (int)info_ptr->pcal_type;
+ *nparams = (int)info_ptr->pcal_nparams;
+ *units = info_ptr->pcal_units;
+ *params = info_ptr->pcal_params;
+ return (PNG_INFO_pCAL);
+ }
+ return (0);
+}
+#endif
+
+#if defined(PNG_sCAL_SUPPORTED)
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+png_uint_32 PNGAPI
+png_get_sCAL(png_structp png_ptr, png_infop info_ptr,
+ int *unit, double *width, double *height)
+{
+ if (png_ptr != NULL && info_ptr != NULL &&
+ (info_ptr->valid & PNG_INFO_sCAL))
+ {
+ *unit = info_ptr->scal_unit;
+ *width = info_ptr->scal_pixel_width;
+ *height = info_ptr->scal_pixel_height;
+ return (PNG_INFO_sCAL);
+ }
+ return(0);
+}
+#else
+#ifdef PNG_FIXED_POINT_SUPPORTED
+png_uint_32 PNGAPI
+png_get_sCAL_s(png_structp png_ptr, png_infop info_ptr,
+ int *unit, png_charpp width, png_charpp height)
+{
+ if (png_ptr != NULL && info_ptr != NULL &&
+ (info_ptr->valid & PNG_INFO_sCAL))
+ {
+ *unit = info_ptr->scal_unit;
+ *width = info_ptr->scal_s_width;
+ *height = info_ptr->scal_s_height;
+ return (PNG_INFO_sCAL);
+ }
+ return(0);
+}
+#endif
+#endif
+#endif
+
+#if defined(PNG_pHYs_SUPPORTED)
+png_uint_32 PNGAPI
+png_get_pHYs(png_structp png_ptr, png_infop info_ptr,
+ png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
+{
+ png_uint_32 retval = 0;
+
+ if (png_ptr != NULL && info_ptr != NULL &&
+ (info_ptr->valid & PNG_INFO_pHYs))
+ {
+ png_debug1(1, "in %s retrieval function\n", "pHYs");
+ if (res_x != NULL)
+ {
+ *res_x = info_ptr->x_pixels_per_unit;
+ retval |= PNG_INFO_pHYs;
+ }
+ if (res_y != NULL)
+ {
+ *res_y = info_ptr->y_pixels_per_unit;
+ retval |= PNG_INFO_pHYs;
+ }
+ if (unit_type != NULL)
+ {
+ *unit_type = (int)info_ptr->phys_unit_type;
+ retval |= PNG_INFO_pHYs;
+ }
+ }
+ return (retval);
+}
+#endif
+
+png_uint_32 PNGAPI
+png_get_PLTE(png_structp png_ptr, png_infop info_ptr, png_colorp *palette,
+ int *num_palette)
+{
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_PLTE)
+ && palette != NULL)
+ {
+ png_debug1(1, "in %s retrieval function\n", "PLTE");
+ *palette = info_ptr->palette;
+ *num_palette = info_ptr->num_palette;
+ png_debug1(3, "num_palette = %d\n", *num_palette);
+ return (PNG_INFO_PLTE);
+ }
+ return (0);
+}
+
+#if defined(PNG_sBIT_SUPPORTED)
+png_uint_32 PNGAPI
+png_get_sBIT(png_structp png_ptr, png_infop info_ptr, png_color_8p *sig_bit)
+{
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT)
+ && sig_bit != NULL)
+ {
+ png_debug1(1, "in %s retrieval function\n", "sBIT");
+ *sig_bit = &(info_ptr->sig_bit);
+ return (PNG_INFO_sBIT);
+ }
+ return (0);
+}
+#endif
+
+#if defined(PNG_TEXT_SUPPORTED)
+png_uint_32 PNGAPI
+png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr,
+ int *num_text)
+{
+ if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0)
+ {
+ png_debug1(1, "in %s retrieval function\n",
+ (png_ptr->chunk_name[0] == '\0' ? "text"
+ : (png_const_charp)png_ptr->chunk_name));
+ if (text_ptr != NULL)
+ *text_ptr = info_ptr->text;
+ if (num_text != NULL)
+ *num_text = info_ptr->num_text;
+ return ((png_uint_32)info_ptr->num_text);
+ }
+ if (num_text != NULL)
+ *num_text = 0;
+ return(0);
+}
+#endif
+
+#if defined(PNG_tIME_SUPPORTED)
+png_uint_32 PNGAPI
+png_get_tIME(png_structp png_ptr, png_infop info_ptr, png_timep *mod_time)
+{
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME)
+ && mod_time != NULL)
+ {
+ png_debug1(1, "in %s retrieval function\n", "tIME");
+ *mod_time = &(info_ptr->mod_time);
+ return (PNG_INFO_tIME);
+ }
+ return (0);
+}
+#endif
+
+#if defined(PNG_tRNS_SUPPORTED)
+png_uint_32 PNGAPI
+png_get_tRNS(png_structp png_ptr, png_infop info_ptr,
+ png_bytep *trans, int *num_trans, png_color_16p *trans_values)
+{
+ png_uint_32 retval = 0;
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))
+ {
+ png_debug1(1, "in %s retrieval function\n", "tRNS");
+ if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+ {
+ if (trans != NULL)
+ {
+ *trans = info_ptr->trans;
+ retval |= PNG_INFO_tRNS;
+ }
+ if (trans_values != NULL)
+ *trans_values = &(info_ptr->trans_values);
+ }
+ else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */
+ {
+ if (trans_values != NULL)
+ {
+ *trans_values = &(info_ptr->trans_values);
+ retval |= PNG_INFO_tRNS;
+ }
+ if (trans != NULL)
+ *trans = NULL;
+ }
+ if (num_trans != NULL)
+ {
+ *num_trans = info_ptr->num_trans;
+ retval |= PNG_INFO_tRNS;
+ }
+ }
+ return (retval);
+}
+#endif
+
+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
+png_uint_32 PNGAPI
+png_get_unknown_chunks(png_structp png_ptr, png_infop info_ptr,
+ png_unknown_chunkpp unknowns)
+{
+ if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL)
+ {
+ *unknowns = info_ptr->unknown_chunks;
+ return ((png_uint_32)info_ptr->unknown_chunks_num);
+ }
+ return (0);
+}
+#endif
+
+#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
+png_byte PNGAPI
+png_get_rgb_to_gray_status (png_structp png_ptr)
+{
+ return (png_byte)(png_ptr? png_ptr->rgb_to_gray_status : 0);
+}
+#endif
+
+#if defined(PNG_USER_CHUNKS_SUPPORTED)
+png_voidp PNGAPI
+png_get_user_chunk_ptr(png_structp png_ptr)
+{
+ return (png_ptr? png_ptr->user_chunk_ptr : NULL);
+}
+#endif
+
+#ifdef PNG_WRITE_SUPPORTED
+png_uint_32 PNGAPI
+png_get_compression_buffer_size(png_structp png_ptr)
+{
+ return (png_uint_32)(png_ptr? png_ptr->zbuf_size : 0L);
+}
+#endif
+
+#ifdef PNG_ASSEMBLER_CODE_SUPPORTED
+#ifndef PNG_1_0_X
+/* this function was added to libpng 1.2.0 and should exist by default */
+png_uint_32 PNGAPI
+png_get_asm_flags (png_structp png_ptr)
+{
+ /* obsolete, to be removed from libpng-1.4.0 */
+ return (png_ptr? 0L: 0L);
+}
+
+/* this function was added to libpng 1.2.0 and should exist by default */
+png_uint_32 PNGAPI
+png_get_asm_flagmask (int flag_select)
+{
+ /* obsolete, to be removed from libpng-1.4.0 */
+ flag_select=flag_select;
+ return 0L;
+}
+
+ /* GRR: could add this: && defined(PNG_MMX_CODE_SUPPORTED) */
+/* this function was added to libpng 1.2.0 */
+png_uint_32 PNGAPI
+png_get_mmx_flagmask (int flag_select, int *compilerID)
+{
+ /* obsolete, to be removed from libpng-1.4.0 */
+ flag_select=flag_select;
+ *compilerID = -1; /* unknown (i.e., no asm/MMX code compiled) */
+ return 0L;
+}
+
+/* this function was added to libpng 1.2.0 */
+png_byte PNGAPI
+png_get_mmx_bitdepth_threshold (png_structp png_ptr)
+{
+ /* obsolete, to be removed from libpng-1.4.0 */
+ return (png_ptr? 0: 0);
+}
+
+/* this function was added to libpng 1.2.0 */
+png_uint_32 PNGAPI
+png_get_mmx_rowbytes_threshold (png_structp png_ptr)
+{
+ /* obsolete, to be removed from libpng-1.4.0 */
+ return (png_ptr? 0L: 0L);
+}
+#endif /* ?PNG_1_0_X */
+#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */
+
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED
+/* these functions were added to libpng 1.2.6 */
+png_uint_32 PNGAPI
+png_get_user_width_max (png_structp png_ptr)
+{
+ return (png_ptr? png_ptr->user_width_max : 0);
+}
+png_uint_32 PNGAPI
+png_get_user_height_max (png_structp png_ptr)
+{
+ return (png_ptr? png_ptr->user_height_max : 0);
+}
+#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */
+
+
+#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
--- /dev/null
+
+/* pngmem.c - stub functions for memory allocation
+ *
+ * Last changed in libpng 1.2.30 [August 15, 2008]
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * This file provides a location for all memory allocation. Users who
+ * need special memory handling are expected to supply replacement
+ * functions for png_malloc() and png_free(), and to use
+ * png_create_read_struct_2() and png_create_write_struct_2() to
+ * identify the replacement functions.
+ */
+
+#define PNG_INTERNAL
+#include "png.h"
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
+
+/* Borland DOS special memory handler */
+#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
+/* if you change this, be sure to change the one in png.h also */
+
+/* Allocate memory for a png_struct. The malloc and memset can be replaced
+ by a single call to calloc() if this is thought to improve performance. */
+png_voidp /* PRIVATE */
+png_create_struct(int type)
+{
+#ifdef PNG_USER_MEM_SUPPORTED
+ return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL));
+}
+
+/* Alternate version of png_create_struct, for use with user-defined malloc. */
+png_voidp /* PRIVATE */
+png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)
+{
+#endif /* PNG_USER_MEM_SUPPORTED */
+ png_size_t size;
+ png_voidp struct_ptr;
+
+ if (type == PNG_STRUCT_INFO)
+ size = png_sizeof(png_info);
+ else if (type == PNG_STRUCT_PNG)
+ size = png_sizeof(png_struct);
+ else
+ return (png_get_copyright(NULL));
+
+#ifdef PNG_USER_MEM_SUPPORTED
+ if (malloc_fn != NULL)
+ {
+ png_struct dummy_struct;
+ png_structp png_ptr = &dummy_struct;
+ png_ptr->mem_ptr=mem_ptr;
+ struct_ptr = (*(malloc_fn))(png_ptr, (png_uint_32)size);
+ }
+ else
+#endif /* PNG_USER_MEM_SUPPORTED */
+ struct_ptr = (png_voidp)farmalloc(size);
+ if (struct_ptr != NULL)
+ png_memset(struct_ptr, 0, size);
+ return (struct_ptr);
+}
+
+/* Free memory allocated by a png_create_struct() call */
+void /* PRIVATE */
+png_destroy_struct(png_voidp struct_ptr)
+{
+#ifdef PNG_USER_MEM_SUPPORTED
+ png_destroy_struct_2(struct_ptr, png_free_ptr_NULL, png_voidp_NULL);
+}
+
+/* Free memory allocated by a png_create_struct() call */
+void /* PRIVATE */
+png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,
+ png_voidp mem_ptr)
+{
+#endif
+ if (struct_ptr != NULL)
+ {
+#ifdef PNG_USER_MEM_SUPPORTED
+ if (free_fn != NULL)
+ {
+ png_struct dummy_struct;
+ png_structp png_ptr = &dummy_struct;
+ png_ptr->mem_ptr=mem_ptr;
+ (*(free_fn))(png_ptr, struct_ptr);
+ return;
+ }
+#endif /* PNG_USER_MEM_SUPPORTED */
+ farfree (struct_ptr);
+ }
+}
+
+/* Allocate memory. For reasonable files, size should never exceed
+ * 64K. However, zlib may allocate more then 64K if you don't tell
+ * it not to. See zconf.h and png.h for more information. zlib does
+ * need to allocate exactly 64K, so whatever you call here must
+ * have the ability to do that.
+ *
+ * Borland seems to have a problem in DOS mode for exactly 64K.
+ * It gives you a segment with an offset of 8 (perhaps to store its
+ * memory stuff). zlib doesn't like this at all, so we have to
+ * detect and deal with it. This code should not be needed in
+ * Windows or OS/2 modes, and only in 16 bit mode. This code has
+ * been updated by Alexander Lehmann for version 0.89 to waste less
+ * memory.
+ *
+ * Note that we can't use png_size_t for the "size" declaration,
+ * since on some systems a png_size_t is a 16-bit quantity, and as a
+ * result, we would be truncating potentially larger memory requests
+ * (which should cause a fatal error) and introducing major problems.
+ */
+
+png_voidp PNGAPI
+png_malloc(png_structp png_ptr, png_uint_32 size)
+{
+ png_voidp ret;
+
+ if (png_ptr == NULL || size == 0)
+ return (NULL);
+
+#ifdef PNG_USER_MEM_SUPPORTED
+ if (png_ptr->malloc_fn != NULL)
+ ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
+ else
+ ret = (png_malloc_default(png_ptr, size));
+ if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+ png_error(png_ptr, "Out of memory!");
+ return (ret);
+}
+
+png_voidp PNGAPI
+png_malloc_default(png_structp png_ptr, png_uint_32 size)
+{
+ png_voidp ret;
+#endif /* PNG_USER_MEM_SUPPORTED */
+
+ if (png_ptr == NULL || size == 0)
+ return (NULL);
+
+#ifdef PNG_MAX_MALLOC_64K
+ if (size > (png_uint_32)65536L)
+ {
+ png_warning(png_ptr, "Cannot Allocate > 64K");
+ ret = NULL;
+ }
+ else
+#endif
+
+ if (size != (size_t)size)
+ ret = NULL;
+ else if (size == (png_uint_32)65536L)
+ {
+ if (png_ptr->offset_table == NULL)
+ {
+ /* try to see if we need to do any of this fancy stuff */
+ ret = farmalloc(size);
+ if (ret == NULL || ((png_size_t)ret & 0xffff))
+ {
+ int num_blocks;
+ png_uint_32 total_size;
+ png_bytep table;
+ int i;
+ png_byte huge * hptr;
+
+ if (ret != NULL)
+ {
+ farfree(ret);
+ ret = NULL;
+ }
+
+ if (png_ptr->zlib_window_bits > 14)
+ num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14));
+ else
+ num_blocks = 1;
+ if (png_ptr->zlib_mem_level >= 7)
+ num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7));
+ else
+ num_blocks++;
+
+ total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks+16;
+
+ table = farmalloc(total_size);
+
+ if (table == NULL)
+ {
+#ifndef PNG_USER_MEM_SUPPORTED
+ if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+ png_error(png_ptr, "Out Of Memory."); /* Note "O" and "M" */
+ else
+ png_warning(png_ptr, "Out Of Memory.");
+#endif
+ return (NULL);
+ }
+
+ if ((png_size_t)table & 0xfff0)
+ {
+#ifndef PNG_USER_MEM_SUPPORTED
+ if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+ png_error(png_ptr,
+ "Farmalloc didn't return normalized pointer");
+ else
+ png_warning(png_ptr,
+ "Farmalloc didn't return normalized pointer");
+#endif
+ return (NULL);
+ }
+
+ png_ptr->offset_table = table;
+ png_ptr->offset_table_ptr = farmalloc(num_blocks *
+ png_sizeof(png_bytep));
+
+ if (png_ptr->offset_table_ptr == NULL)
+ {
+#ifndef PNG_USER_MEM_SUPPORTED
+ if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+ png_error(png_ptr, "Out Of memory."); /* Note "O" and "M" */
+ else
+ png_warning(png_ptr, "Out Of memory.");
+#endif
+ return (NULL);
+ }
+
+ hptr = (png_byte huge *)table;
+ if ((png_size_t)hptr & 0xf)
+ {
+ hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L);
+ hptr = hptr + 16L; /* "hptr += 16L" fails on Turbo C++ 3.0 */
+ }
+ for (i = 0; i < num_blocks; i++)
+ {
+ png_ptr->offset_table_ptr[i] = (png_bytep)hptr;
+ hptr = hptr + (png_uint_32)65536L; /* "+=" fails on TC++3.0 */
+ }
+
+ png_ptr->offset_table_number = num_blocks;
+ png_ptr->offset_table_count = 0;
+ png_ptr->offset_table_count_free = 0;
+ }
+ }
+
+ if (png_ptr->offset_table_count >= png_ptr->offset_table_number)
+ {
+#ifndef PNG_USER_MEM_SUPPORTED
+ if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+ png_error(png_ptr, "Out of Memory."); /* Note "o" and "M" */
+ else
+ png_warning(png_ptr, "Out of Memory.");
+#endif
+ return (NULL);
+ }
+
+ ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++];
+ }
+ else
+ ret = farmalloc(size);
+
+#ifndef PNG_USER_MEM_SUPPORTED
+ if (ret == NULL)
+ {
+ if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+ png_error(png_ptr, "Out of memory."); /* Note "o" and "m" */
+ else
+ png_warning(png_ptr, "Out of memory."); /* Note "o" and "m" */
+ }
+#endif
+
+ return (ret);
+}
+
+/* free a pointer allocated by png_malloc(). In the default
+ configuration, png_ptr is not used, but is passed in case it
+ is needed. If ptr is NULL, return without taking any action. */
+
+void PNGAPI
+png_free(png_structp png_ptr, png_voidp ptr)
+{
+ if (png_ptr == NULL || ptr == NULL)
+ return;
+
+#ifdef PNG_USER_MEM_SUPPORTED
+ if (png_ptr->free_fn != NULL)
+ {
+ (*(png_ptr->free_fn))(png_ptr, ptr);
+ return;
+ }
+ else png_free_default(png_ptr, ptr);
+}
+
+void PNGAPI
+png_free_default(png_structp png_ptr, png_voidp ptr)
+{
+#endif /* PNG_USER_MEM_SUPPORTED */
+
+ if (png_ptr == NULL || ptr == NULL) return;
+
+ if (png_ptr->offset_table != NULL)
+ {
+ int i;
+
+ for (i = 0; i < png_ptr->offset_table_count; i++)
+ {
+ if (ptr == png_ptr->offset_table_ptr[i])
+ {
+ ptr = NULL;
+ png_ptr->offset_table_count_free++;
+ break;
+ }
+ }
+ if (png_ptr->offset_table_count_free == png_ptr->offset_table_count)
+ {
+ farfree(png_ptr->offset_table);
+ farfree(png_ptr->offset_table_ptr);
+ png_ptr->offset_table = NULL;
+ png_ptr->offset_table_ptr = NULL;
+ }
+ }
+
+ if (ptr != NULL)
+ {
+ farfree(ptr);
+ }
+}
+
+#else /* Not the Borland DOS special memory handler */
+
+/* Allocate memory for a png_struct or a png_info. The malloc and
+ memset can be replaced by a single call to calloc() if this is thought
+ to improve performance noticably. */
+png_voidp /* PRIVATE */
+png_create_struct(int type)
+{
+#ifdef PNG_USER_MEM_SUPPORTED
+ return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL));
+}
+
+/* Allocate memory for a png_struct or a png_info. The malloc and
+ memset can be replaced by a single call to calloc() if this is thought
+ to improve performance noticably. */
+png_voidp /* PRIVATE */
+png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)
+{
+#endif /* PNG_USER_MEM_SUPPORTED */
+ png_size_t size;
+ png_voidp struct_ptr;
+
+ if (type == PNG_STRUCT_INFO)
+ size = png_sizeof(png_info);
+ else if (type == PNG_STRUCT_PNG)
+ size = png_sizeof(png_struct);
+ else
+ return (NULL);
+
+#ifdef PNG_USER_MEM_SUPPORTED
+ if (malloc_fn != NULL)
+ {
+ png_struct dummy_struct;
+ png_structp png_ptr = &dummy_struct;
+ png_ptr->mem_ptr=mem_ptr;
+ struct_ptr = (*(malloc_fn))(png_ptr, size);
+ if (struct_ptr != NULL)
+ png_memset(struct_ptr, 0, size);
+ return (struct_ptr);
+ }
+#endif /* PNG_USER_MEM_SUPPORTED */
+
+#if defined(__TURBOC__) && !defined(__FLAT__)
+ struct_ptr = (png_voidp)farmalloc(size);
+#else
+# if defined(_MSC_VER) && defined(MAXSEG_64K)
+ struct_ptr = (png_voidp)halloc(size, 1);
+# else
+ struct_ptr = (png_voidp)malloc(size);
+# endif
+#endif
+ if (struct_ptr != NULL)
+ png_memset(struct_ptr, 0, size);
+
+ return (struct_ptr);
+}
+
+
+/* Free memory allocated by a png_create_struct() call */
+void /* PRIVATE */
+png_destroy_struct(png_voidp struct_ptr)
+{
+#ifdef PNG_USER_MEM_SUPPORTED
+ png_destroy_struct_2(struct_ptr, png_free_ptr_NULL, png_voidp_NULL);
+}
+
+/* Free memory allocated by a png_create_struct() call */
+void /* PRIVATE */
+png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,
+ png_voidp mem_ptr)
+{
+#endif /* PNG_USER_MEM_SUPPORTED */
+ if (struct_ptr != NULL)
+ {
+#ifdef PNG_USER_MEM_SUPPORTED
+ if (free_fn != NULL)
+ {
+ png_struct dummy_struct;
+ png_structp png_ptr = &dummy_struct;
+ png_ptr->mem_ptr=mem_ptr;
+ (*(free_fn))(png_ptr, struct_ptr);
+ return;
+ }
+#endif /* PNG_USER_MEM_SUPPORTED */
+#if defined(__TURBOC__) && !defined(__FLAT__)
+ farfree(struct_ptr);
+#else
+# if defined(_MSC_VER) && defined(MAXSEG_64K)
+ hfree(struct_ptr);
+# else
+ free(struct_ptr);
+# endif
+#endif
+ }
+}
+
+/* Allocate memory. For reasonable files, size should never exceed
+ 64K. However, zlib may allocate more then 64K if you don't tell
+ it not to. See zconf.h and png.h for more information. zlib does
+ need to allocate exactly 64K, so whatever you call here must
+ have the ability to do that. */
+
+png_voidp PNGAPI
+png_malloc(png_structp png_ptr, png_uint_32 size)
+{
+ png_voidp ret;
+
+#ifdef PNG_USER_MEM_SUPPORTED
+ if (png_ptr == NULL || size == 0)
+ return (NULL);
+
+ if (png_ptr->malloc_fn != NULL)
+ ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
+ else
+ ret = (png_malloc_default(png_ptr, size));
+ if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+ png_error(png_ptr, "Out of Memory!");
+ return (ret);
+}
+
+png_voidp PNGAPI
+png_malloc_default(png_structp png_ptr, png_uint_32 size)
+{
+ png_voidp ret;
+#endif /* PNG_USER_MEM_SUPPORTED */
+
+ if (png_ptr == NULL || size == 0)
+ return (NULL);
+
+#ifdef PNG_MAX_MALLOC_64K
+ if (size > (png_uint_32)65536L)
+ {
+#ifndef PNG_USER_MEM_SUPPORTED
+ if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+ png_error(png_ptr, "Cannot Allocate > 64K");
+ else
+#endif
+ return NULL;
+ }
+#endif
+
+ /* Check for overflow */
+#if defined(__TURBOC__) && !defined(__FLAT__)
+ if (size != (unsigned long)size)
+ ret = NULL;
+ else
+ ret = farmalloc(size);
+#else
+# if defined(_MSC_VER) && defined(MAXSEG_64K)
+ if (size != (unsigned long)size)
+ ret = NULL;
+ else
+ ret = halloc(size, 1);
+# else
+ if (size != (size_t)size)
+ ret = NULL;
+ else
+ ret = malloc((size_t)size);
+# endif
+#endif
+
+#ifndef PNG_USER_MEM_SUPPORTED
+ if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+ png_error(png_ptr, "Out of Memory");
+#endif
+
+ return (ret);
+}
+
+/* Free a pointer allocated by png_malloc(). If ptr is NULL, return
+ without taking any action. */
+void PNGAPI
+png_free(png_structp png_ptr, png_voidp ptr)
+{
+ if (png_ptr == NULL || ptr == NULL)
+ return;
+
+#ifdef PNG_USER_MEM_SUPPORTED
+ if (png_ptr->free_fn != NULL)
+ {
+ (*(png_ptr->free_fn))(png_ptr, ptr);
+ return;
+ }
+ else png_free_default(png_ptr, ptr);
+}
+void PNGAPI
+png_free_default(png_structp png_ptr, png_voidp ptr)
+{
+ if (png_ptr == NULL || ptr == NULL)
+ return;
+
+#endif /* PNG_USER_MEM_SUPPORTED */
+
+#if defined(__TURBOC__) && !defined(__FLAT__)
+ farfree(ptr);
+#else
+# if defined(_MSC_VER) && defined(MAXSEG_64K)
+ hfree(ptr);
+# else
+ free(ptr);
+# endif
+#endif
+}
+
+#endif /* Not Borland DOS special memory handler */
+
+#if defined(PNG_1_0_X)
+# define png_malloc_warn png_malloc
+#else
+/* This function was added at libpng version 1.2.3. The png_malloc_warn()
+ * function will set up png_malloc() to issue a png_warning and return NULL
+ * instead of issuing a png_error, if it fails to allocate the requested
+ * memory.
+ */
+png_voidp PNGAPI
+png_malloc_warn(png_structp png_ptr, png_uint_32 size)
+{
+ png_voidp ptr;
+ png_uint_32 save_flags;
+ if (png_ptr == NULL) return (NULL);
+
+ save_flags = png_ptr->flags;
+ png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
+ ptr = (png_voidp)png_malloc((png_structp)png_ptr, size);
+ png_ptr->flags=save_flags;
+ return(ptr);
+}
+#endif
+
+png_voidp PNGAPI
+png_memcpy_check (png_structp png_ptr, png_voidp s1, png_voidp s2,
+ png_uint_32 length)
+{
+ png_size_t size;
+
+ size = (png_size_t)length;
+ if ((png_uint_32)size != length)
+ png_error(png_ptr, "Overflow in png_memcpy_check.");
+
+ return(png_memcpy (s1, s2, size));
+}
+
+png_voidp PNGAPI
+png_memset_check (png_structp png_ptr, png_voidp s1, int value,
+ png_uint_32 length)
+{
+ png_size_t size;
+
+ size = (png_size_t)length;
+ if ((png_uint_32)size != length)
+ png_error(png_ptr, "Overflow in png_memset_check.");
+
+ return (png_memset (s1, value, size));
+
+}
+
+#ifdef PNG_USER_MEM_SUPPORTED
+/* This function is called when the application wants to use another method
+ * of allocating and freeing memory.
+ */
+void PNGAPI
+png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr
+ malloc_fn, png_free_ptr free_fn)
+{
+ if (png_ptr != NULL)
+ {
+ png_ptr->mem_ptr = mem_ptr;
+ png_ptr->malloc_fn = malloc_fn;
+ png_ptr->free_fn = free_fn;
+ }
+}
+
+/* This function returns a pointer to the mem_ptr associated with the user
+ * functions. The application should free any memory associated with this
+ * pointer before png_write_destroy and png_read_destroy are called.
+ */
+png_voidp PNGAPI
+png_get_mem_ptr(png_structp png_ptr)
+{
+ if (png_ptr == NULL) return (NULL);
+ return ((png_voidp)png_ptr->mem_ptr);
+}
+#endif /* PNG_USER_MEM_SUPPORTED */
+#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
--- /dev/null
+
+/* pngpread.c - read a png file in push mode
+ *
+ * Last changed in libpng 1.2.32 [September 18, 2008]
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ */
+
+#define PNG_INTERNAL
+#include "png.h"
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
+
+/* push model modes */
+#define PNG_READ_SIG_MODE 0
+#define PNG_READ_CHUNK_MODE 1
+#define PNG_READ_IDAT_MODE 2
+#define PNG_SKIP_MODE 3
+#define PNG_READ_tEXt_MODE 4
+#define PNG_READ_zTXt_MODE 5
+#define PNG_READ_DONE_MODE 6
+#define PNG_READ_iTXt_MODE 7
+#define PNG_ERROR_MODE 8
+
+void PNGAPI
+png_process_data(png_structp png_ptr, png_infop info_ptr,
+ png_bytep buffer, png_size_t buffer_size)
+{
+ if (png_ptr == NULL || info_ptr == NULL) return;
+ png_push_restore_buffer(png_ptr, buffer, buffer_size);
+
+ while (png_ptr->buffer_size)
+ {
+ png_process_some_data(png_ptr, info_ptr);
+ }
+}
+
+/* What we do with the incoming data depends on what we were previously
+ * doing before we ran out of data...
+ */
+void /* PRIVATE */
+png_process_some_data(png_structp png_ptr, png_infop info_ptr)
+{
+ if (png_ptr == NULL) return;
+ switch (png_ptr->process_mode)
+ {
+ case PNG_READ_SIG_MODE:
+ {
+ png_push_read_sig(png_ptr, info_ptr);
+ break;
+ }
+ case PNG_READ_CHUNK_MODE:
+ {
+ png_push_read_chunk(png_ptr, info_ptr);
+ break;
+ }
+ case PNG_READ_IDAT_MODE:
+ {
+ png_push_read_IDAT(png_ptr);
+ break;
+ }
+#if defined(PNG_READ_tEXt_SUPPORTED)
+ case PNG_READ_tEXt_MODE:
+ {
+ png_push_read_tEXt(png_ptr, info_ptr);
+ break;
+ }
+#endif
+#if defined(PNG_READ_zTXt_SUPPORTED)
+ case PNG_READ_zTXt_MODE:
+ {
+ png_push_read_zTXt(png_ptr, info_ptr);
+ break;
+ }
+#endif
+#if defined(PNG_READ_iTXt_SUPPORTED)
+ case PNG_READ_iTXt_MODE:
+ {
+ png_push_read_iTXt(png_ptr, info_ptr);
+ break;
+ }
+#endif
+ case PNG_SKIP_MODE:
+ {
+ png_push_crc_finish(png_ptr);
+ break;
+ }
+ default:
+ {
+ png_ptr->buffer_size = 0;
+ break;
+ }
+ }
+}
+
+/* Read any remaining signature bytes from the stream and compare them with
+ * the correct PNG signature. It is possible that this routine is called
+ * with bytes already read from the signature, either because they have been
+ * checked by the calling application, or because of multiple calls to this
+ * routine.
+ */
+void /* PRIVATE */
+png_push_read_sig(png_structp png_ptr, png_infop info_ptr)
+{
+ png_size_t num_checked = png_ptr->sig_bytes,
+ num_to_check = 8 - num_checked;
+
+ if (png_ptr->buffer_size < num_to_check)
+ {
+ num_to_check = png_ptr->buffer_size;
+ }
+
+ png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]),
+ num_to_check);
+ png_ptr->sig_bytes = (png_byte)(png_ptr->sig_bytes + num_to_check);
+
+ if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))
+ {
+ if (num_checked < 4 &&
+ png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))
+ png_error(png_ptr, "Not a PNG file");
+ else
+ png_error(png_ptr, "PNG file corrupted by ASCII conversion");
+ }
+ else
+ {
+ if (png_ptr->sig_bytes >= 8)
+ {
+ png_ptr->process_mode = PNG_READ_CHUNK_MODE;
+ }
+ }
+}
+
+void /* PRIVATE */
+png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_CONST PNG_IHDR;
+ PNG_CONST PNG_IDAT;
+ PNG_CONST PNG_IEND;
+ PNG_CONST PNG_PLTE;
+#if defined(PNG_READ_bKGD_SUPPORTED)
+ PNG_CONST PNG_bKGD;
+#endif
+#if defined(PNG_READ_cHRM_SUPPORTED)
+ PNG_CONST PNG_cHRM;
+#endif
+#if defined(PNG_READ_gAMA_SUPPORTED)
+ PNG_CONST PNG_gAMA;
+#endif
+#if defined(PNG_READ_hIST_SUPPORTED)
+ PNG_CONST PNG_hIST;
+#endif
+#if defined(PNG_READ_iCCP_SUPPORTED)
+ PNG_CONST PNG_iCCP;
+#endif
+#if defined(PNG_READ_iTXt_SUPPORTED)
+ PNG_CONST PNG_iTXt;
+#endif
+#if defined(PNG_READ_oFFs_SUPPORTED)
+ PNG_CONST PNG_oFFs;
+#endif
+#if defined(PNG_READ_pCAL_SUPPORTED)
+ PNG_CONST PNG_pCAL;
+#endif
+#if defined(PNG_READ_pHYs_SUPPORTED)
+ PNG_CONST PNG_pHYs;
+#endif
+#if defined(PNG_READ_sBIT_SUPPORTED)
+ PNG_CONST PNG_sBIT;
+#endif
+#if defined(PNG_READ_sCAL_SUPPORTED)
+ PNG_CONST PNG_sCAL;
+#endif
+#if defined(PNG_READ_sRGB_SUPPORTED)
+ PNG_CONST PNG_sRGB;
+#endif
+#if defined(PNG_READ_sPLT_SUPPORTED)
+ PNG_CONST PNG_sPLT;
+#endif
+#if defined(PNG_READ_tEXt_SUPPORTED)
+ PNG_CONST PNG_tEXt;
+#endif
+#if defined(PNG_READ_tIME_SUPPORTED)
+ PNG_CONST PNG_tIME;
+#endif
+#if defined(PNG_READ_tRNS_SUPPORTED)
+ PNG_CONST PNG_tRNS;
+#endif
+#if defined(PNG_READ_zTXt_SUPPORTED)
+ PNG_CONST PNG_zTXt;
+#endif
+#endif /* PNG_USE_LOCAL_ARRAYS */
+ /* First we make sure we have enough data for the 4 byte chunk name
+ * and the 4 byte chunk length before proceeding with decoding the
+ * chunk data. To fully decode each of these chunks, we also make
+ * sure we have enough data in the buffer for the 4 byte CRC at the
+ * end of every chunk (except IDAT, which is handled separately).
+ */
+ if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))
+ {
+ png_byte chunk_length[4];
+
+ if (png_ptr->buffer_size < 8)
+ {
+ png_push_save_buffer(png_ptr);
+ return;
+ }
+
+ png_push_fill_buffer(png_ptr, chunk_length, 4);
+ png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);
+ png_reset_crc(png_ptr);
+ png_crc_read(png_ptr, png_ptr->chunk_name, 4);
+ png_check_chunk_name(png_ptr, png_ptr->chunk_name);
+ png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;
+ }
+
+ if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
+ if (png_ptr->mode & PNG_AFTER_IDAT)
+ png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
+
+ if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4))
+ {
+ if (png_ptr->push_length != 13)
+ png_error(png_ptr, "Invalid IHDR length");
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+ {
+ png_push_save_buffer(png_ptr);
+ return;
+ }
+ png_handle_IHDR(png_ptr, info_ptr, png_ptr->push_length);
+ }
+ else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4))
+ {
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+ {
+ png_push_save_buffer(png_ptr);
+ return;
+ }
+ png_handle_IEND(png_ptr, info_ptr, png_ptr->push_length);
+
+ png_ptr->process_mode = PNG_READ_DONE_MODE;
+ png_push_have_end(png_ptr, info_ptr);
+ }
+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+ else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name))
+ {
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+ {
+ png_push_save_buffer(png_ptr);
+ return;
+ }
+ if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
+ png_ptr->mode |= PNG_HAVE_IDAT;
+ png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length);
+ if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))
+ png_ptr->mode |= PNG_HAVE_PLTE;
+ else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
+ {
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))
+ png_error(png_ptr, "Missing IHDR before IDAT");
+ else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
+ !(png_ptr->mode & PNG_HAVE_PLTE))
+ png_error(png_ptr, "Missing PLTE before IDAT");
+ }
+ }
+#endif
+ else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))
+ {
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+ {
+ png_push_save_buffer(png_ptr);
+ return;
+ }
+ png_handle_PLTE(png_ptr, info_ptr, png_ptr->push_length);
+ }
+ else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
+ {
+ /* If we reach an IDAT chunk, this means we have read all of the
+ * header chunks, and we can start reading the image (or if this
+ * is called after the image has been read - we have an error).
+ */
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))
+ png_error(png_ptr, "Missing IHDR before IDAT");
+ else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
+ !(png_ptr->mode & PNG_HAVE_PLTE))
+ png_error(png_ptr, "Missing PLTE before IDAT");
+
+ if (png_ptr->mode & PNG_HAVE_IDAT)
+ {
+ if (!(png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))
+ if (png_ptr->push_length == 0)
+ return;
+
+ if (png_ptr->mode & PNG_AFTER_IDAT)
+ png_error(png_ptr, "Too many IDAT's found");
+ }
+
+ png_ptr->idat_size = png_ptr->push_length;
+ png_ptr->mode |= PNG_HAVE_IDAT;
+ png_ptr->process_mode = PNG_READ_IDAT_MODE;
+ png_push_have_info(png_ptr, info_ptr);
+ png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes;
+ png_ptr->zstream.next_out = png_ptr->row_buf;
+ return;
+ }
+#if defined(PNG_READ_gAMA_SUPPORTED)
+ else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4))
+ {
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+ {
+ png_push_save_buffer(png_ptr);
+ return;
+ }
+ png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length);
+ }
+#endif
+#if defined(PNG_READ_sBIT_SUPPORTED)
+ else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4))
+ {
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+ {
+ png_push_save_buffer(png_ptr);
+ return;
+ }
+ png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length);
+ }
+#endif
+#if defined(PNG_READ_cHRM_SUPPORTED)
+ else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4))
+ {
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+ {
+ png_push_save_buffer(png_ptr);
+ return;
+ }
+ png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length);
+ }
+#endif
+#if defined(PNG_READ_sRGB_SUPPORTED)
+ else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))
+ {
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+ {
+ png_push_save_buffer(png_ptr);
+ return;
+ }
+ png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length);
+ }
+#endif
+#if defined(PNG_READ_iCCP_SUPPORTED)
+ else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4))
+ {
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+ {
+ png_push_save_buffer(png_ptr);
+ return;
+ }
+ png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length);
+ }
+#endif
+#if defined(PNG_READ_sPLT_SUPPORTED)
+ else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4))
+ {
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+ {
+ png_push_save_buffer(png_ptr);
+ return;
+ }
+ png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length);
+ }
+#endif
+#if defined(PNG_READ_tRNS_SUPPORTED)
+ else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4))
+ {
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+ {
+ png_push_save_buffer(png_ptr);
+ return;
+ }
+ png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length);
+ }
+#endif
+#if defined(PNG_READ_bKGD_SUPPORTED)
+ else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4))
+ {
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+ {
+ png_push_save_buffer(png_ptr);
+ return;
+ }
+ png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length);
+ }
+#endif
+#if defined(PNG_READ_hIST_SUPPORTED)
+ else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4))
+ {
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+ {
+ png_push_save_buffer(png_ptr);
+ return;
+ }
+ png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length);
+ }
+#endif
+#if defined(PNG_READ_pHYs_SUPPORTED)
+ else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4))
+ {
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+ {
+ png_push_save_buffer(png_ptr);
+ return;
+ }
+ png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length);
+ }
+#endif
+#if defined(PNG_READ_oFFs_SUPPORTED)
+ else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4))
+ {
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+ {
+ png_push_save_buffer(png_ptr);
+ return;
+ }
+ png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length);
+ }
+#endif
+#if defined(PNG_READ_pCAL_SUPPORTED)
+ else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4))
+ {
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+ {
+ png_push_save_buffer(png_ptr);
+ return;
+ }
+ png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length);
+ }
+#endif
+#if defined(PNG_READ_sCAL_SUPPORTED)
+ else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4))
+ {
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+ {
+ png_push_save_buffer(png_ptr);
+ return;
+ }
+ png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length);
+ }
+#endif
+#if defined(PNG_READ_tIME_SUPPORTED)
+ else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4))
+ {
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+ {
+ png_push_save_buffer(png_ptr);
+ return;
+ }
+ png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length);
+ }
+#endif
+#if defined(PNG_READ_tEXt_SUPPORTED)
+ else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4))
+ {
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+ {
+ png_push_save_buffer(png_ptr);
+ return;
+ }
+ png_push_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length);
+ }
+#endif
+#if defined(PNG_READ_zTXt_SUPPORTED)
+ else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4))
+ {
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+ {
+ png_push_save_buffer(png_ptr);
+ return;
+ }
+ png_push_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length);
+ }
+#endif
+#if defined(PNG_READ_iTXt_SUPPORTED)
+ else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4))
+ {
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+ {
+ png_push_save_buffer(png_ptr);
+ return;
+ }
+ png_push_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length);
+ }
+#endif
+ else
+ {
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+ {
+ png_push_save_buffer(png_ptr);
+ return;
+ }
+ png_push_handle_unknown(png_ptr, info_ptr, png_ptr->push_length);
+ }
+
+ png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;
+}
+
+void /* PRIVATE */
+png_push_crc_skip(png_structp png_ptr, png_uint_32 skip)
+{
+ png_ptr->process_mode = PNG_SKIP_MODE;
+ png_ptr->skip_length = skip;
+}
+
+void /* PRIVATE */
+png_push_crc_finish(png_structp png_ptr)
+{
+ if (png_ptr->skip_length && png_ptr->save_buffer_size)
+ {
+ png_size_t save_size;
+
+ if (png_ptr->skip_length < (png_uint_32)png_ptr->save_buffer_size)
+ save_size = (png_size_t)png_ptr->skip_length;
+ else
+ save_size = png_ptr->save_buffer_size;
+
+ png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);
+
+ png_ptr->skip_length -= save_size;
+ png_ptr->buffer_size -= save_size;
+ png_ptr->save_buffer_size -= save_size;
+ png_ptr->save_buffer_ptr += save_size;
+ }
+ if (png_ptr->skip_length && png_ptr->current_buffer_size)
+ {
+ png_size_t save_size;
+
+ if (png_ptr->skip_length < (png_uint_32)png_ptr->current_buffer_size)
+ save_size = (png_size_t)png_ptr->skip_length;
+ else
+ save_size = png_ptr->current_buffer_size;
+
+ png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);
+
+ png_ptr->skip_length -= save_size;
+ png_ptr->buffer_size -= save_size;
+ png_ptr->current_buffer_size -= save_size;
+ png_ptr->current_buffer_ptr += save_size;
+ }
+ if (!png_ptr->skip_length)
+ {
+ if (png_ptr->buffer_size < 4)
+ {
+ png_push_save_buffer(png_ptr);
+ return;
+ }
+
+ png_crc_finish(png_ptr, 0);
+ png_ptr->process_mode = PNG_READ_CHUNK_MODE;
+ }
+}
+
+void PNGAPI
+png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)
+{
+ png_bytep ptr;
+
+ if (png_ptr == NULL) return;
+ ptr = buffer;
+ if (png_ptr->save_buffer_size)
+ {
+ png_size_t save_size;
+
+ if (length < png_ptr->save_buffer_size)
+ save_size = length;
+ else
+ save_size = png_ptr->save_buffer_size;
+
+ png_memcpy(ptr, png_ptr->save_buffer_ptr, save_size);
+ length -= save_size;
+ ptr += save_size;
+ png_ptr->buffer_size -= save_size;
+ png_ptr->save_buffer_size -= save_size;
+ png_ptr->save_buffer_ptr += save_size;
+ }
+ if (length && png_ptr->current_buffer_size)
+ {
+ png_size_t save_size;
+
+ if (length < png_ptr->current_buffer_size)
+ save_size = length;
+ else
+ save_size = png_ptr->current_buffer_size;
+
+ png_memcpy(ptr, png_ptr->current_buffer_ptr, save_size);
+ png_ptr->buffer_size -= save_size;
+ png_ptr->current_buffer_size -= save_size;
+ png_ptr->current_buffer_ptr += save_size;
+ }
+}
+
+void /* PRIVATE */
+png_push_save_buffer(png_structp png_ptr)
+{
+ if (png_ptr->save_buffer_size)
+ {
+ if (png_ptr->save_buffer_ptr != png_ptr->save_buffer)
+ {
+ png_size_t i, istop;
+ png_bytep sp;
+ png_bytep dp;
+
+ istop = png_ptr->save_buffer_size;
+ for (i = 0, sp = png_ptr->save_buffer_ptr, dp = png_ptr->save_buffer;
+ i < istop; i++, sp++, dp++)
+ {
+ *dp = *sp;
+ }
+ }
+ }
+ if (png_ptr->save_buffer_size + png_ptr->current_buffer_size >
+ png_ptr->save_buffer_max)
+ {
+ png_size_t new_max;
+ png_bytep old_buffer;
+
+ if (png_ptr->save_buffer_size > PNG_SIZE_MAX -
+ (png_ptr->current_buffer_size + 256))
+ {
+ png_error(png_ptr, "Potential overflow of save_buffer");
+ }
+ new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256;
+ old_buffer = png_ptr->save_buffer;
+ png_ptr->save_buffer = (png_bytep)png_malloc(png_ptr,
+ (png_uint_32)new_max);
+ png_memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size);
+ png_free(png_ptr, old_buffer);
+ png_ptr->save_buffer_max = new_max;
+ }
+ if (png_ptr->current_buffer_size)
+ {
+ png_memcpy(png_ptr->save_buffer + png_ptr->save_buffer_size,
+ png_ptr->current_buffer_ptr, png_ptr->current_buffer_size);
+ png_ptr->save_buffer_size += png_ptr->current_buffer_size;
+ png_ptr->current_buffer_size = 0;
+ }
+ png_ptr->save_buffer_ptr = png_ptr->save_buffer;
+ png_ptr->buffer_size = 0;
+}
+
+void /* PRIVATE */
+png_push_restore_buffer(png_structp png_ptr, png_bytep buffer,
+ png_size_t buffer_length)
+{
+ png_ptr->current_buffer = buffer;
+ png_ptr->current_buffer_size = buffer_length;
+ png_ptr->buffer_size = buffer_length + png_ptr->save_buffer_size;
+ png_ptr->current_buffer_ptr = png_ptr->current_buffer;
+}
+
+void /* PRIVATE */
+png_push_read_IDAT(png_structp png_ptr)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_CONST PNG_IDAT;
+#endif
+ if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))
+ {
+ png_byte chunk_length[4];
+
+ if (png_ptr->buffer_size < 8)
+ {
+ png_push_save_buffer(png_ptr);
+ return;
+ }
+
+ png_push_fill_buffer(png_ptr, chunk_length, 4);
+ png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);
+ png_reset_crc(png_ptr);
+ png_crc_read(png_ptr, png_ptr->chunk_name, 4);
+ png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;
+
+ if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
+ {
+ png_ptr->process_mode = PNG_READ_CHUNK_MODE;
+ if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
+ png_error(png_ptr, "Not enough compressed data");
+ return;
+ }
+
+ png_ptr->idat_size = png_ptr->push_length;
+ }
+ if (png_ptr->idat_size && png_ptr->save_buffer_size)
+ {
+ png_size_t save_size;
+
+ if (png_ptr->idat_size < (png_uint_32)png_ptr->save_buffer_size)
+ {
+ save_size = (png_size_t)png_ptr->idat_size;
+ /* check for overflow */
+ if ((png_uint_32)save_size != png_ptr->idat_size)
+ png_error(png_ptr, "save_size overflowed in pngpread");
+ }
+ else
+ save_size = png_ptr->save_buffer_size;
+
+ png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);
+ if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
+ png_process_IDAT_data(png_ptr, png_ptr->save_buffer_ptr, save_size);
+ png_ptr->idat_size -= save_size;
+ png_ptr->buffer_size -= save_size;
+ png_ptr->save_buffer_size -= save_size;
+ png_ptr->save_buffer_ptr += save_size;
+ }
+ if (png_ptr->idat_size && png_ptr->current_buffer_size)
+ {
+ png_size_t save_size;
+
+ if (png_ptr->idat_size < (png_uint_32)png_ptr->current_buffer_size)
+ {
+ save_size = (png_size_t)png_ptr->idat_size;
+ /* check for overflow */
+ if ((png_uint_32)save_size != png_ptr->idat_size)
+ png_error(png_ptr, "save_size overflowed in pngpread");
+ }
+ else
+ save_size = png_ptr->current_buffer_size;
+
+ png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);
+ if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
+ png_process_IDAT_data(png_ptr, png_ptr->current_buffer_ptr, save_size);
+
+ png_ptr->idat_size -= save_size;
+ png_ptr->buffer_size -= save_size;
+ png_ptr->current_buffer_size -= save_size;
+ png_ptr->current_buffer_ptr += save_size;
+ }
+ if (!png_ptr->idat_size)
+ {
+ if (png_ptr->buffer_size < 4)
+ {
+ png_push_save_buffer(png_ptr);
+ return;
+ }
+
+ png_crc_finish(png_ptr, 0);
+ png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;
+ png_ptr->mode |= PNG_AFTER_IDAT;
+ }
+}
+
+void /* PRIVATE */
+png_process_IDAT_data(png_structp png_ptr, png_bytep buffer,
+ png_size_t buffer_length)
+{
+ int ret;
+
+ if ((png_ptr->flags & PNG_FLAG_ZLIB_FINISHED) && buffer_length)
+ png_error(png_ptr, "Extra compression data");
+
+ png_ptr->zstream.next_in = buffer;
+ png_ptr->zstream.avail_in = (uInt)buffer_length;
+ for (;;)
+ {
+ ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
+ if (ret != Z_OK)
+ {
+ if (ret == Z_STREAM_END)
+ {
+ if (png_ptr->zstream.avail_in)
+ png_error(png_ptr, "Extra compressed data");
+ if (!(png_ptr->zstream.avail_out))
+ {
+ png_push_process_row(png_ptr);
+ }
+
+ png_ptr->mode |= PNG_AFTER_IDAT;
+ png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
+ break;
+ }
+ else if (ret == Z_BUF_ERROR)
+ break;
+ else
+ png_error(png_ptr, "Decompression Error");
+ }
+ if (!(png_ptr->zstream.avail_out))
+ {
+ if ((
+#if defined(PNG_READ_INTERLACING_SUPPORTED)
+ png_ptr->interlaced && png_ptr->pass > 6) ||
+ (!png_ptr->interlaced &&
+#endif
+ png_ptr->row_number == png_ptr->num_rows))
+ {
+ if (png_ptr->zstream.avail_in)
+ png_warning(png_ptr, "Too much data in IDAT chunks");
+ png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
+ break;
+ }
+ png_push_process_row(png_ptr);
+ png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes;
+ png_ptr->zstream.next_out = png_ptr->row_buf;
+ }
+ else
+ break;
+ }
+}
+
+void /* PRIVATE */
+png_push_process_row(png_structp png_ptr)
+{
+ png_ptr->row_info.color_type = png_ptr->color_type;
+ png_ptr->row_info.width = png_ptr->iwidth;
+ png_ptr->row_info.channels = png_ptr->channels;
+ png_ptr->row_info.bit_depth = png_ptr->bit_depth;
+ png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;
+
+ png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,
+ png_ptr->row_info.width);
+
+ png_read_filter_row(png_ptr, &(png_ptr->row_info),
+ png_ptr->row_buf + 1, png_ptr->prev_row + 1,
+ (int)(png_ptr->row_buf[0]));
+
+ png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf,
+ png_ptr->rowbytes + 1);
+
+ if (png_ptr->transformations || (png_ptr->flags&PNG_FLAG_STRIP_ALPHA))
+ png_do_read_transformations(png_ptr);
+
+#if defined(PNG_READ_INTERLACING_SUPPORTED)
+ /* blow up interlaced rows to full size */
+ if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
+ {
+ if (png_ptr->pass < 6)
+/* old interface (pre-1.0.9):
+ png_do_read_interlace(&(png_ptr->row_info),
+ png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations);
+ */
+ png_do_read_interlace(png_ptr);
+
+ switch (png_ptr->pass)
+ {
+ case 0:
+ {
+ int i;
+ for (i = 0; i < 8 && png_ptr->pass == 0; i++)
+ {
+ png_push_have_row(png_ptr, png_ptr->row_buf + 1);
+ png_read_push_finish_row(png_ptr); /* updates png_ptr->pass */
+ }
+ if (png_ptr->pass == 2) /* pass 1 might be empty */
+ {
+ for (i = 0; i < 4 && png_ptr->pass == 2; i++)
+ {
+ png_push_have_row(png_ptr, png_bytep_NULL);
+ png_read_push_finish_row(png_ptr);
+ }
+ }
+ if (png_ptr->pass == 4 && png_ptr->height <= 4)
+ {
+ for (i = 0; i < 2 && png_ptr->pass == 4; i++)
+ {
+ png_push_have_row(png_ptr, png_bytep_NULL);
+ png_read_push_finish_row(png_ptr);
+ }
+ }
+ if (png_ptr->pass == 6 && png_ptr->height <= 4)
+ {
+ png_push_have_row(png_ptr, png_bytep_NULL);
+ png_read_push_finish_row(png_ptr);
+ }
+ break;
+ }
+ case 1:
+ {
+ int i;
+ for (i = 0; i < 8 && png_ptr->pass == 1; i++)
+ {
+ png_push_have_row(png_ptr, png_ptr->row_buf + 1);
+ png_read_push_finish_row(png_ptr);
+ }
+ if (png_ptr->pass == 2) /* skip top 4 generated rows */
+ {
+ for (i = 0; i < 4 && png_ptr->pass == 2; i++)
+ {
+ png_push_have_row(png_ptr, png_bytep_NULL);
+ png_read_push_finish_row(png_ptr);
+ }
+ }
+ break;
+ }
+ case 2:
+ {
+ int i;
+ for (i = 0; i < 4 && png_ptr->pass == 2; i++)
+ {
+ png_push_have_row(png_ptr, png_ptr->row_buf + 1);
+ png_read_push_finish_row(png_ptr);
+ }
+ for (i = 0; i < 4 && png_ptr->pass == 2; i++)
+ {
+ png_push_have_row(png_ptr, png_bytep_NULL);
+ png_read_push_finish_row(png_ptr);
+ }
+ if (png_ptr->pass == 4) /* pass 3 might be empty */
+ {
+ for (i = 0; i < 2 && png_ptr->pass == 4; i++)
+ {
+ png_push_have_row(png_ptr, png_bytep_NULL);
+ png_read_push_finish_row(png_ptr);
+ }
+ }
+ break;
+ }
+ case 3:
+ {
+ int i;
+ for (i = 0; i < 4 && png_ptr->pass == 3; i++)
+ {
+ png_push_have_row(png_ptr, png_ptr->row_buf + 1);
+ png_read_push_finish_row(png_ptr);
+ }
+ if (png_ptr->pass == 4) /* skip top two generated rows */
+ {
+ for (i = 0; i < 2 && png_ptr->pass == 4; i++)
+ {
+ png_push_have_row(png_ptr, png_bytep_NULL);
+ png_read_push_finish_row(png_ptr);
+ }
+ }
+ break;
+ }
+ case 4:
+ {
+ int i;
+ for (i = 0; i < 2 && png_ptr->pass == 4; i++)
+ {
+ png_push_have_row(png_ptr, png_ptr->row_buf + 1);
+ png_read_push_finish_row(png_ptr);
+ }
+ for (i = 0; i < 2 && png_ptr->pass == 4; i++)
+ {
+ png_push_have_row(png_ptr, png_bytep_NULL);
+ png_read_push_finish_row(png_ptr);
+ }
+ if (png_ptr->pass == 6) /* pass 5 might be empty */
+ {
+ png_push_have_row(png_ptr, png_bytep_NULL);
+ png_read_push_finish_row(png_ptr);
+ }
+ break;
+ }
+ case 5:
+ {
+ int i;
+ for (i = 0; i < 2 && png_ptr->pass == 5; i++)
+ {
+ png_push_have_row(png_ptr, png_ptr->row_buf + 1);
+ png_read_push_finish_row(png_ptr);
+ }
+ if (png_ptr->pass == 6) /* skip top generated row */
+ {
+ png_push_have_row(png_ptr, png_bytep_NULL);
+ png_read_push_finish_row(png_ptr);
+ }
+ break;
+ }
+ case 6:
+ {
+ png_push_have_row(png_ptr, png_ptr->row_buf + 1);
+ png_read_push_finish_row(png_ptr);
+ if (png_ptr->pass != 6)
+ break;
+ png_push_have_row(png_ptr, png_bytep_NULL);
+ png_read_push_finish_row(png_ptr);
+ }
+ }
+ }
+ else
+#endif
+ {
+ png_push_have_row(png_ptr, png_ptr->row_buf + 1);
+ png_read_push_finish_row(png_ptr);
+ }
+}
+
+void /* PRIVATE */
+png_read_push_finish_row(png_structp png_ptr)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
+
+ /* start of interlace block */
+ PNG_CONST int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
+
+ /* offset to next interlace block */
+ PNG_CONST int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
+
+ /* start of interlace block in the y direction */
+ PNG_CONST int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
+
+ /* offset to next interlace block in the y direction */
+ PNG_CONST int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
+
+ /* Height of interlace block. This is not currently used - if you need
+ * it, uncomment it here and in png.h
+ PNG_CONST int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};
+ */
+#endif
+
+ png_ptr->row_number++;
+ if (png_ptr->row_number < png_ptr->num_rows)
+ return;
+
+ if (png_ptr->interlaced)
+ {
+ png_ptr->row_number = 0;
+ png_memset_check(png_ptr, png_ptr->prev_row, 0,
+ png_ptr->rowbytes + 1);
+ do
+ {
+ png_ptr->pass++;
+ if ((png_ptr->pass == 1 && png_ptr->width < 5) ||
+ (png_ptr->pass == 3 && png_ptr->width < 3) ||
+ (png_ptr->pass == 5 && png_ptr->width < 2))
+ png_ptr->pass++;
+
+ if (png_ptr->pass > 7)
+ png_ptr->pass--;
+ if (png_ptr->pass >= 7)
+ break;
+
+ png_ptr->iwidth = (png_ptr->width +
+ png_pass_inc[png_ptr->pass] - 1 -
+ png_pass_start[png_ptr->pass]) /
+ png_pass_inc[png_ptr->pass];
+
+ png_ptr->irowbytes = PNG_ROWBYTES(png_ptr->pixel_depth,
+ png_ptr->iwidth) + 1;
+
+ if (png_ptr->transformations & PNG_INTERLACE)
+ break;
+
+ png_ptr->num_rows = (png_ptr->height +
+ png_pass_yinc[png_ptr->pass] - 1 -
+ png_pass_ystart[png_ptr->pass]) /
+ png_pass_yinc[png_ptr->pass];
+
+ } while (png_ptr->iwidth == 0 || png_ptr->num_rows == 0);
+ }
+}
+
+#if defined(PNG_READ_tEXt_SUPPORTED)
+void /* PRIVATE */
+png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
+ length)
+{
+ if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
+ {
+ png_error(png_ptr, "Out of place tEXt");
+ info_ptr = info_ptr; /* to quiet some compiler warnings */
+ }
+
+#ifdef PNG_MAX_MALLOC_64K
+ png_ptr->skip_length = 0; /* This may not be necessary */
+
+ if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */
+ {
+ png_warning(png_ptr, "tEXt chunk too large to fit in memory");
+ png_ptr->skip_length = length - (png_uint_32)65535L;
+ length = (png_uint_32)65535L;
+ }
+#endif
+
+ png_ptr->current_text = (png_charp)png_malloc(png_ptr,
+ (png_uint_32)(length + 1));
+ png_ptr->current_text[length] = '\0';
+ png_ptr->current_text_ptr = png_ptr->current_text;
+ png_ptr->current_text_size = (png_size_t)length;
+ png_ptr->current_text_left = (png_size_t)length;
+ png_ptr->process_mode = PNG_READ_tEXt_MODE;
+}
+
+void /* PRIVATE */
+png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr)
+{
+ if (png_ptr->buffer_size && png_ptr->current_text_left)
+ {
+ png_size_t text_size;
+
+ if (png_ptr->buffer_size < png_ptr->current_text_left)
+ text_size = png_ptr->buffer_size;
+ else
+ text_size = png_ptr->current_text_left;
+ png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
+ png_ptr->current_text_left -= text_size;
+ png_ptr->current_text_ptr += text_size;
+ }
+ if (!(png_ptr->current_text_left))
+ {
+ png_textp text_ptr;
+ png_charp text;
+ png_charp key;
+ int ret;
+
+ if (png_ptr->buffer_size < 4)
+ {
+ png_push_save_buffer(png_ptr);
+ return;
+ }
+
+ png_push_crc_finish(png_ptr);
+
+#if defined(PNG_MAX_MALLOC_64K)
+ if (png_ptr->skip_length)
+ return;
+#endif
+
+ key = png_ptr->current_text;
+
+ for (text = key; *text; text++)
+ /* empty loop */ ;
+
+ if (text < key + png_ptr->current_text_size)
+ text++;
+
+ text_ptr = (png_textp)png_malloc(png_ptr,
+ (png_uint_32)png_sizeof(png_text));
+ text_ptr->compression = PNG_TEXT_COMPRESSION_NONE;
+ text_ptr->key = key;
+#ifdef PNG_iTXt_SUPPORTED
+ text_ptr->lang = NULL;
+ text_ptr->lang_key = NULL;
+#endif
+ text_ptr->text = text;
+
+ ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
+
+ png_free(png_ptr, key);
+ png_free(png_ptr, text_ptr);
+ png_ptr->current_text = NULL;
+
+ if (ret)
+ png_warning(png_ptr, "Insufficient memory to store text chunk.");
+ }
+}
+#endif
+
+#if defined(PNG_READ_zTXt_SUPPORTED)
+void /* PRIVATE */
+png_push_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
+ length)
+{
+ if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
+ {
+ png_error(png_ptr, "Out of place zTXt");
+ info_ptr = info_ptr; /* to quiet some compiler warnings */
+ }
+
+#ifdef PNG_MAX_MALLOC_64K
+ /* We can't handle zTXt chunks > 64K, since we don't have enough space
+ * to be able to store the uncompressed data. Actually, the threshold
+ * is probably around 32K, but it isn't as definite as 64K is.
+ */
+ if (length > (png_uint_32)65535L)
+ {
+ png_warning(png_ptr, "zTXt chunk too large to fit in memory");
+ png_push_crc_skip(png_ptr, length);
+ return;
+ }
+#endif
+
+ png_ptr->current_text = (png_charp)png_malloc(png_ptr,
+ (png_uint_32)(length + 1));
+ png_ptr->current_text[length] = '\0';
+ png_ptr->current_text_ptr = png_ptr->current_text;
+ png_ptr->current_text_size = (png_size_t)length;
+ png_ptr->current_text_left = (png_size_t)length;
+ png_ptr->process_mode = PNG_READ_zTXt_MODE;
+}
+
+void /* PRIVATE */
+png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
+{
+ if (png_ptr->buffer_size && png_ptr->current_text_left)
+ {
+ png_size_t text_size;
+
+ if (png_ptr->buffer_size < (png_uint_32)png_ptr->current_text_left)
+ text_size = png_ptr->buffer_size;
+ else
+ text_size = png_ptr->current_text_left;
+ png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
+ png_ptr->current_text_left -= text_size;
+ png_ptr->current_text_ptr += text_size;
+ }
+ if (!(png_ptr->current_text_left))
+ {
+ png_textp text_ptr;
+ png_charp text;
+ png_charp key;
+ int ret;
+ png_size_t text_size, key_size;
+
+ if (png_ptr->buffer_size < 4)
+ {
+ png_push_save_buffer(png_ptr);
+ return;
+ }
+
+ png_push_crc_finish(png_ptr);
+
+ key = png_ptr->current_text;
+
+ for (text = key; *text; text++)
+ /* empty loop */ ;
+
+ /* zTXt can't have zero text */
+ if (text >= key + png_ptr->current_text_size)
+ {
+ png_ptr->current_text = NULL;
+ png_free(png_ptr, key);
+ return;
+ }
+
+ text++;
+
+ if (*text != PNG_TEXT_COMPRESSION_zTXt) /* check compression byte */
+ {
+ png_ptr->current_text = NULL;
+ png_free(png_ptr, key);
+ return;
+ }
+
+ text++;
+
+ png_ptr->zstream.next_in = (png_bytep )text;
+ png_ptr->zstream.avail_in = (uInt)(png_ptr->current_text_size -
+ (text - key));
+ png_ptr->zstream.next_out = png_ptr->zbuf;
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+
+ key_size = text - key;
+ text_size = 0;
+ text = NULL;
+ ret = Z_STREAM_END;
+
+ while (png_ptr->zstream.avail_in)
+ {
+ ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
+ if (ret != Z_OK && ret != Z_STREAM_END)
+ {
+ inflateReset(&png_ptr->zstream);
+ png_ptr->zstream.avail_in = 0;
+ png_ptr->current_text = NULL;
+ png_free(png_ptr, key);
+ png_free(png_ptr, text);
+ return;
+ }
+ if (!(png_ptr->zstream.avail_out) || ret == Z_STREAM_END)
+ {
+ if (text == NULL)
+ {
+ text = (png_charp)png_malloc(png_ptr,
+ (png_uint_32)(png_ptr->zbuf_size
+ - png_ptr->zstream.avail_out + key_size + 1));
+ png_memcpy(text + key_size, png_ptr->zbuf,
+ png_ptr->zbuf_size - png_ptr->zstream.avail_out);
+ png_memcpy(text, key, key_size);
+ text_size = key_size + png_ptr->zbuf_size -
+ png_ptr->zstream.avail_out;
+ *(text + text_size) = '\0';
+ }
+ else
+ {
+ png_charp tmp;
+
+ tmp = text;
+ text = (png_charp)png_malloc(png_ptr, text_size +
+ (png_uint_32)(png_ptr->zbuf_size
+ - png_ptr->zstream.avail_out + 1));
+ png_memcpy(text, tmp, text_size);
+ png_free(png_ptr, tmp);
+ png_memcpy(text + text_size, png_ptr->zbuf,
+ png_ptr->zbuf_size - png_ptr->zstream.avail_out);
+ text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out;
+ *(text + text_size) = '\0';
+ }
+ if (ret != Z_STREAM_END)
+ {
+ png_ptr->zstream.next_out = png_ptr->zbuf;
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+ }
+ }
+ else
+ {
+ break;
+ }
+
+ if (ret == Z_STREAM_END)
+ break;
+ }
+
+ inflateReset(&png_ptr->zstream);
+ png_ptr->zstream.avail_in = 0;
+
+ if (ret != Z_STREAM_END)
+ {
+ png_ptr->current_text = NULL;
+ png_free(png_ptr, key);
+ png_free(png_ptr, text);
+ return;
+ }
+
+ png_ptr->current_text = NULL;
+ png_free(png_ptr, key);
+ key = text;
+ text += key_size;
+
+ text_ptr = (png_textp)png_malloc(png_ptr,
+ (png_uint_32)png_sizeof(png_text));
+ text_ptr->compression = PNG_TEXT_COMPRESSION_zTXt;
+ text_ptr->key = key;
+#ifdef PNG_iTXt_SUPPORTED
+ text_ptr->lang = NULL;
+ text_ptr->lang_key = NULL;
+#endif
+ text_ptr->text = text;
+
+ ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
+
+ png_free(png_ptr, key);
+ png_free(png_ptr, text_ptr);
+
+ if (ret)
+ png_warning(png_ptr, "Insufficient memory to store text chunk.");
+ }
+}
+#endif
+
+#if defined(PNG_READ_iTXt_SUPPORTED)
+void /* PRIVATE */
+png_push_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
+ length)
+{
+ if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
+ {
+ png_error(png_ptr, "Out of place iTXt");
+ info_ptr = info_ptr; /* to quiet some compiler warnings */
+ }
+
+#ifdef PNG_MAX_MALLOC_64K
+ png_ptr->skip_length = 0; /* This may not be necessary */
+
+ if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */
+ {
+ png_warning(png_ptr, "iTXt chunk too large to fit in memory");
+ png_ptr->skip_length = length - (png_uint_32)65535L;
+ length = (png_uint_32)65535L;
+ }
+#endif
+
+ png_ptr->current_text = (png_charp)png_malloc(png_ptr,
+ (png_uint_32)(length + 1));
+ png_ptr->current_text[length] = '\0';
+ png_ptr->current_text_ptr = png_ptr->current_text;
+ png_ptr->current_text_size = (png_size_t)length;
+ png_ptr->current_text_left = (png_size_t)length;
+ png_ptr->process_mode = PNG_READ_iTXt_MODE;
+}
+
+void /* PRIVATE */
+png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr)
+{
+
+ if (png_ptr->buffer_size && png_ptr->current_text_left)
+ {
+ png_size_t text_size;
+
+ if (png_ptr->buffer_size < png_ptr->current_text_left)
+ text_size = png_ptr->buffer_size;
+ else
+ text_size = png_ptr->current_text_left;
+ png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
+ png_ptr->current_text_left -= text_size;
+ png_ptr->current_text_ptr += text_size;
+ }
+ if (!(png_ptr->current_text_left))
+ {
+ png_textp text_ptr;
+ png_charp key;
+ int comp_flag;
+ png_charp lang;
+ png_charp lang_key;
+ png_charp text;
+ int ret;
+
+ if (png_ptr->buffer_size < 4)
+ {
+ png_push_save_buffer(png_ptr);
+ return;
+ }
+
+ png_push_crc_finish(png_ptr);
+
+#if defined(PNG_MAX_MALLOC_64K)
+ if (png_ptr->skip_length)
+ return;
+#endif
+
+ key = png_ptr->current_text;
+
+ for (lang = key; *lang; lang++)
+ /* empty loop */ ;
+
+ if (lang < key + png_ptr->current_text_size - 3)
+ lang++;
+
+ comp_flag = *lang++;
+ lang++; /* skip comp_type, always zero */
+
+ for (lang_key = lang; *lang_key; lang_key++)
+ /* empty loop */ ;
+ lang_key++; /* skip NUL separator */
+
+ text=lang_key;
+ if (lang_key < key + png_ptr->current_text_size - 1)
+ {
+ for (; *text; text++)
+ /* empty loop */ ;
+ }
+
+ if (text < key + png_ptr->current_text_size)
+ text++;
+
+ text_ptr = (png_textp)png_malloc(png_ptr,
+ (png_uint_32)png_sizeof(png_text));
+ text_ptr->compression = comp_flag + 2;
+ text_ptr->key = key;
+ text_ptr->lang = lang;
+ text_ptr->lang_key = lang_key;
+ text_ptr->text = text;
+ text_ptr->text_length = 0;
+ text_ptr->itxt_length = png_strlen(text);
+
+ ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
+
+ png_ptr->current_text = NULL;
+
+ png_free(png_ptr, text_ptr);
+ if (ret)
+ png_warning(png_ptr, "Insufficient memory to store iTXt chunk.");
+ }
+}
+#endif
+
+/* This function is called when we haven't found a handler for this
+ * chunk. If there isn't a problem with the chunk itself (ie a bad chunk
+ * name or a critical chunk), the chunk is (currently) silently ignored.
+ */
+void /* PRIVATE */
+png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32
+ length)
+{
+ png_uint_32 skip = 0;
+
+ if (!(png_ptr->chunk_name[0] & 0x20))
+ {
+#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
+ if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
+ PNG_HANDLE_CHUNK_ALWAYS
+#if defined(PNG_READ_USER_CHUNKS_SUPPORTED)
+ && png_ptr->read_user_chunk_fn == NULL
+#endif
+ )
+#endif
+ png_chunk_error(png_ptr, "unknown critical chunk");
+
+ info_ptr = info_ptr; /* to quiet some compiler warnings */
+ }
+
+#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
+ if (png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS)
+ {
+#ifdef PNG_MAX_MALLOC_64K
+ if (length > (png_uint_32)65535L)
+ {
+ png_warning(png_ptr, "unknown chunk too large to fit in memory");
+ skip = length - (png_uint_32)65535L;
+ length = (png_uint_32)65535L;
+ }
+#endif
+ png_memcpy((png_charp)png_ptr->unknown_chunk.name,
+ (png_charp)png_ptr->chunk_name,
+ png_sizeof(png_ptr->unknown_chunk.name));
+ png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name) - 1]
+ = '\0';
+
+ png_ptr->unknown_chunk.size = (png_size_t)length;
+ if (length == 0)
+ png_ptr->unknown_chunk.data = NULL;
+ else
+ {
+ png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr,
+ (png_uint_32)length);
+ png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length);
+ }
+#if defined(PNG_READ_USER_CHUNKS_SUPPORTED)
+ if (png_ptr->read_user_chunk_fn != NULL)
+ {
+ /* callback to user unknown chunk handler */
+ int ret;
+ ret = (*(png_ptr->read_user_chunk_fn))
+ (png_ptr, &png_ptr->unknown_chunk);
+ if (ret < 0)
+ png_chunk_error(png_ptr, "error in user chunk");
+ if (ret == 0)
+ {
+ if (!(png_ptr->chunk_name[0] & 0x20))
+ if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
+ PNG_HANDLE_CHUNK_ALWAYS)
+ png_chunk_error(png_ptr, "unknown critical chunk");
+ png_set_unknown_chunks(png_ptr, info_ptr,
+ &png_ptr->unknown_chunk, 1);
+ }
+ }
+ else
+#endif
+ png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1);
+ png_free(png_ptr, png_ptr->unknown_chunk.data);
+ png_ptr->unknown_chunk.data = NULL;
+ }
+ else
+#endif
+ skip=length;
+ png_push_crc_skip(png_ptr, skip);
+}
+
+void /* PRIVATE */
+png_push_have_info(png_structp png_ptr, png_infop info_ptr)
+{
+ if (png_ptr->info_fn != NULL)
+ (*(png_ptr->info_fn))(png_ptr, info_ptr);
+}
+
+void /* PRIVATE */
+png_push_have_end(png_structp png_ptr, png_infop info_ptr)
+{
+ if (png_ptr->end_fn != NULL)
+ (*(png_ptr->end_fn))(png_ptr, info_ptr);
+}
+
+void /* PRIVATE */
+png_push_have_row(png_structp png_ptr, png_bytep row)
+{
+ if (png_ptr->row_fn != NULL)
+ (*(png_ptr->row_fn))(png_ptr, row, png_ptr->row_number,
+ (int)png_ptr->pass);
+}
+
+void PNGAPI
+png_progressive_combine_row (png_structp png_ptr,
+ png_bytep old_row, png_bytep new_row)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_CONST int FARDATA png_pass_dsp_mask[7] =
+ {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};
+#endif
+ if (png_ptr == NULL) return;
+ if (new_row != NULL) /* new_row must == png_ptr->row_buf here. */
+ png_combine_row(png_ptr, old_row, png_pass_dsp_mask[png_ptr->pass]);
+}
+
+void PNGAPI
+png_set_progressive_read_fn(png_structp png_ptr, png_voidp progressive_ptr,
+ png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn,
+ png_progressive_end_ptr end_fn)
+{
+ if (png_ptr == NULL) return;
+ png_ptr->info_fn = info_fn;
+ png_ptr->row_fn = row_fn;
+ png_ptr->end_fn = end_fn;
+
+ png_set_read_fn(png_ptr, progressive_ptr, png_push_fill_buffer);
+}
+
+png_voidp PNGAPI
+png_get_progressive_ptr(png_structp png_ptr)
+{
+ if (png_ptr == NULL) return (NULL);
+ return png_ptr->io_ptr;
+}
+#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
--- /dev/null
+
+/* pngread.c - read a PNG file
+ *
+ * Last changed in libpng 1.2.30 [August 15, 2008]
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * This file contains routines that an application calls directly to
+ * read a PNG file or stream.
+ */
+
+#define PNG_INTERNAL
+#include "png.h"
+#if defined(PNG_READ_SUPPORTED)
+
+/* Create a PNG structure for reading, and allocate any memory needed. */
+png_structp PNGAPI
+png_create_read_struct(png_const_charp user_png_ver, png_voidp error_ptr,
+ png_error_ptr error_fn, png_error_ptr warn_fn)
+{
+
+#ifdef PNG_USER_MEM_SUPPORTED
+ return (png_create_read_struct_2(user_png_ver, error_ptr, error_fn,
+ warn_fn, png_voidp_NULL, png_malloc_ptr_NULL, png_free_ptr_NULL));
+}
+
+/* Alternate create PNG structure for reading, and allocate any memory needed. */
+png_structp PNGAPI
+png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
+ png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
+ png_malloc_ptr malloc_fn, png_free_ptr free_fn)
+{
+#endif /* PNG_USER_MEM_SUPPORTED */
+
+#ifdef PNG_SETJMP_SUPPORTED
+ volatile
+#endif
+ png_structp png_ptr;
+
+#ifdef PNG_SETJMP_SUPPORTED
+#ifdef USE_FAR_KEYWORD
+ jmp_buf jmpbuf;
+#endif
+#endif
+
+ int i;
+
+ png_debug(1, "in png_create_read_struct\n");
+#ifdef PNG_USER_MEM_SUPPORTED
+ png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,
+ (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr);
+#else
+ png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);
+#endif
+ if (png_ptr == NULL)
+ return (NULL);
+
+ /* added at libpng-1.2.6 */
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED
+ png_ptr->user_width_max=PNG_USER_WIDTH_MAX;
+ png_ptr->user_height_max=PNG_USER_HEIGHT_MAX;
+#endif
+
+#ifdef PNG_SETJMP_SUPPORTED
+#ifdef USE_FAR_KEYWORD
+ if (setjmp(jmpbuf))
+#else
+ if (setjmp(png_ptr->jmpbuf))
+#endif
+ {
+ png_free(png_ptr, png_ptr->zbuf);
+ png_ptr->zbuf = NULL;
+#ifdef PNG_USER_MEM_SUPPORTED
+ png_destroy_struct_2((png_voidp)png_ptr,
+ (png_free_ptr)free_fn, (png_voidp)mem_ptr);
+#else
+ png_destroy_struct((png_voidp)png_ptr);
+#endif
+ return (NULL);
+ }
+#ifdef USE_FAR_KEYWORD
+ png_memcpy(png_ptr->jmpbuf, jmpbuf, png_sizeof(jmp_buf));
+#endif
+#endif
+
+#ifdef PNG_USER_MEM_SUPPORTED
+ png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);
+#endif
+
+ png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);
+
+ if (user_png_ver)
+ {
+ i = 0;
+ do
+ {
+ if (user_png_ver[i] != png_libpng_ver[i])
+ png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
+ } while (png_libpng_ver[i++]);
+ }
+ else
+ png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
+
+
+ if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)
+ {
+ /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so
+ * we must recompile any applications that use any older library version.
+ * For versions after libpng 1.0, we will be compatible, so we need
+ * only check the first digit.
+ */
+ if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||
+ (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) ||
+ (user_png_ver[0] == '0' && user_png_ver[2] < '9'))
+ {
+#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)
+ char msg[80];
+ if (user_png_ver)
+ {
+ png_snprintf(msg, 80,
+ "Application was compiled with png.h from libpng-%.20s",
+ user_png_ver);
+ png_warning(png_ptr, msg);
+ }
+ png_snprintf(msg, 80,
+ "Application is running with png.c from libpng-%.20s",
+ png_libpng_ver);
+ png_warning(png_ptr, msg);
+#endif
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED
+ png_ptr->flags = 0;
+#endif
+ png_error(png_ptr,
+ "Incompatible libpng version in application and library");
+ }
+ }
+
+ /* initialize zbuf - compression buffer */
+ png_ptr->zbuf_size = PNG_ZBUF_SIZE;
+ png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
+ (png_uint_32)png_ptr->zbuf_size);
+ png_ptr->zstream.zalloc = png_zalloc;
+ png_ptr->zstream.zfree = png_zfree;
+ png_ptr->zstream.opaque = (voidpf)png_ptr;
+
+ switch (inflateInit(&png_ptr->zstream))
+ {
+ case Z_OK: /* Do nothing */ break;
+ case Z_MEM_ERROR:
+ case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory error"); break;
+ case Z_VERSION_ERROR: png_error(png_ptr, "zlib version error"); break;
+ default: png_error(png_ptr, "Unknown zlib error");
+ }
+
+ png_ptr->zstream.next_out = png_ptr->zbuf;
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+
+ png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL);
+
+#ifdef PNG_SETJMP_SUPPORTED
+/* Applications that neglect to set up their own setjmp() and then encounter
+ a png_error() will longjmp here. Since the jmpbuf is then meaningless we
+ abort instead of returning. */
+#ifdef USE_FAR_KEYWORD
+ if (setjmp(jmpbuf))
+ PNG_ABORT();
+ png_memcpy(png_ptr->jmpbuf, jmpbuf, png_sizeof(jmp_buf));
+#else
+ if (setjmp(png_ptr->jmpbuf))
+ PNG_ABORT();
+#endif
+#endif
+ return (png_ptr);
+}
+
+#if defined(PNG_1_0_X) || defined(PNG_1_2_X)
+/* Initialize PNG structure for reading, and allocate any memory needed.
+ This interface is deprecated in favour of the png_create_read_struct(),
+ and it will disappear as of libpng-1.3.0. */
+#undef png_read_init
+void PNGAPI
+png_read_init(png_structp png_ptr)
+{
+ /* We only come here via pre-1.0.7-compiled applications */
+ png_read_init_2(png_ptr, "1.0.6 or earlier", 0, 0);
+}
+
+void PNGAPI
+png_read_init_2(png_structp png_ptr, png_const_charp user_png_ver,
+ png_size_t png_struct_size, png_size_t png_info_size)
+{
+ /* We only come here via pre-1.0.12-compiled applications */
+ if (png_ptr == NULL) return;
+#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)
+ if (png_sizeof(png_struct) > png_struct_size ||
+ png_sizeof(png_info) > png_info_size)
+ {
+ char msg[80];
+ png_ptr->warning_fn = NULL;
+ if (user_png_ver)
+ {
+ png_snprintf(msg, 80,
+ "Application was compiled with png.h from libpng-%.20s",
+ user_png_ver);
+ png_warning(png_ptr, msg);
+ }
+ png_snprintf(msg, 80,
+ "Application is running with png.c from libpng-%.20s",
+ png_libpng_ver);
+ png_warning(png_ptr, msg);
+ }
+#endif
+ if (png_sizeof(png_struct) > png_struct_size)
+ {
+ png_ptr->error_fn = NULL;
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED
+ png_ptr->flags = 0;
+#endif
+ png_error(png_ptr,
+ "The png struct allocated by the application for reading is too small.");
+ }
+ if (png_sizeof(png_info) > png_info_size)
+ {
+ png_ptr->error_fn = NULL;
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED
+ png_ptr->flags = 0;
+#endif
+ png_error(png_ptr,
+ "The info struct allocated by application for reading is too small.");
+ }
+ png_read_init_3(&png_ptr, user_png_ver, png_struct_size);
+}
+#endif /* PNG_1_0_X || PNG_1_2_X */
+
+void PNGAPI
+png_read_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver,
+ png_size_t png_struct_size)
+{
+#ifdef PNG_SETJMP_SUPPORTED
+ jmp_buf tmp_jmp; /* to save current jump buffer */
+#endif
+
+ int i = 0;
+
+ png_structp png_ptr=*ptr_ptr;
+
+ if (png_ptr == NULL) return;
+
+ do
+ {
+ if (user_png_ver[i] != png_libpng_ver[i])
+ {
+#ifdef PNG_LEGACY_SUPPORTED
+ png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
+#else
+ png_ptr->warning_fn = NULL;
+ png_warning(png_ptr,
+ "Application uses deprecated png_read_init() and should be recompiled.");
+ break;
+#endif
+ }
+ } while (png_libpng_ver[i++]);
+
+ png_debug(1, "in png_read_init_3\n");
+
+#ifdef PNG_SETJMP_SUPPORTED
+ /* save jump buffer and error functions */
+ png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf));
+#endif
+
+ if (png_sizeof(png_struct) > png_struct_size)
+ {
+ png_destroy_struct(png_ptr);
+ *ptr_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);
+ png_ptr = *ptr_ptr;
+ }
+
+ /* reset all variables to 0 */
+ png_memset(png_ptr, 0, png_sizeof(png_struct));
+
+#ifdef PNG_SETJMP_SUPPORTED
+ /* restore jump buffer */
+ png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf));
+#endif
+
+ /* added at libpng-1.2.6 */
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED
+ png_ptr->user_width_max=PNG_USER_WIDTH_MAX;
+ png_ptr->user_height_max=PNG_USER_HEIGHT_MAX;
+#endif
+
+ /* initialize zbuf - compression buffer */
+ png_ptr->zbuf_size = PNG_ZBUF_SIZE;
+ png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
+ (png_uint_32)png_ptr->zbuf_size);
+ png_ptr->zstream.zalloc = png_zalloc;
+ png_ptr->zstream.zfree = png_zfree;
+ png_ptr->zstream.opaque = (voidpf)png_ptr;
+
+ switch (inflateInit(&png_ptr->zstream))
+ {
+ case Z_OK: /* Do nothing */ break;
+ case Z_MEM_ERROR:
+ case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory"); break;
+ case Z_VERSION_ERROR: png_error(png_ptr, "zlib version"); break;
+ default: png_error(png_ptr, "Unknown zlib error");
+ }
+
+ png_ptr->zstream.next_out = png_ptr->zbuf;
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+
+ png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL);
+}
+
+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED
+/* Read the information before the actual image data. This has been
+ * changed in v0.90 to allow reading a file that already has the magic
+ * bytes read from the stream. You can tell libpng how many bytes have
+ * been read from the beginning of the stream (up to the maximum of 8)
+ * via png_set_sig_bytes(), and we will only check the remaining bytes
+ * here. The application can then have access to the signature bytes we
+ * read if it is determined that this isn't a valid PNG file.
+ */
+void PNGAPI
+png_read_info(png_structp png_ptr, png_infop info_ptr)
+{
+ if (png_ptr == NULL || info_ptr == NULL) return;
+ png_debug(1, "in png_read_info\n");
+ /* If we haven't checked all of the PNG signature bytes, do so now. */
+ if (png_ptr->sig_bytes < 8)
+ {
+ png_size_t num_checked = png_ptr->sig_bytes,
+ num_to_check = 8 - num_checked;
+
+ png_read_data(png_ptr, &(info_ptr->signature[num_checked]), num_to_check);
+ png_ptr->sig_bytes = 8;
+
+ if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))
+ {
+ if (num_checked < 4 &&
+ png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))
+ png_error(png_ptr, "Not a PNG file");
+ else
+ png_error(png_ptr, "PNG file corrupted by ASCII conversion");
+ }
+ if (num_checked < 3)
+ png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;
+ }
+
+ for (;;)
+ {
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_CONST PNG_IHDR;
+ PNG_CONST PNG_IDAT;
+ PNG_CONST PNG_IEND;
+ PNG_CONST PNG_PLTE;
+#if defined(PNG_READ_bKGD_SUPPORTED)
+ PNG_CONST PNG_bKGD;
+#endif
+#if defined(PNG_READ_cHRM_SUPPORTED)
+ PNG_CONST PNG_cHRM;
+#endif
+#if defined(PNG_READ_gAMA_SUPPORTED)
+ PNG_CONST PNG_gAMA;
+#endif
+#if defined(PNG_READ_hIST_SUPPORTED)
+ PNG_CONST PNG_hIST;
+#endif
+#if defined(PNG_READ_iCCP_SUPPORTED)
+ PNG_CONST PNG_iCCP;
+#endif
+#if defined(PNG_READ_iTXt_SUPPORTED)
+ PNG_CONST PNG_iTXt;
+#endif
+#if defined(PNG_READ_oFFs_SUPPORTED)
+ PNG_CONST PNG_oFFs;
+#endif
+#if defined(PNG_READ_pCAL_SUPPORTED)
+ PNG_CONST PNG_pCAL;
+#endif
+#if defined(PNG_READ_pHYs_SUPPORTED)
+ PNG_CONST PNG_pHYs;
+#endif
+#if defined(PNG_READ_sBIT_SUPPORTED)
+ PNG_CONST PNG_sBIT;
+#endif
+#if defined(PNG_READ_sCAL_SUPPORTED)
+ PNG_CONST PNG_sCAL;
+#endif
+#if defined(PNG_READ_sPLT_SUPPORTED)
+ PNG_CONST PNG_sPLT;
+#endif
+#if defined(PNG_READ_sRGB_SUPPORTED)
+ PNG_CONST PNG_sRGB;
+#endif
+#if defined(PNG_READ_tEXt_SUPPORTED)
+ PNG_CONST PNG_tEXt;
+#endif
+#if defined(PNG_READ_tIME_SUPPORTED)
+ PNG_CONST PNG_tIME;
+#endif
+#if defined(PNG_READ_tRNS_SUPPORTED)
+ PNG_CONST PNG_tRNS;
+#endif
+#if defined(PNG_READ_zTXt_SUPPORTED)
+ PNG_CONST PNG_zTXt;
+#endif
+#endif /* PNG_USE_LOCAL_ARRAYS */
+ png_uint_32 length = png_read_chunk_header(png_ptr);
+ PNG_CONST png_bytep chunk_name = png_ptr->chunk_name;
+
+ /* This should be a binary subdivision search or a hash for
+ * matching the chunk name rather than a linear search.
+ */
+ if (!png_memcmp(chunk_name, png_IDAT, 4))
+ if (png_ptr->mode & PNG_AFTER_IDAT)
+ png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
+
+ if (!png_memcmp(chunk_name, png_IHDR, 4))
+ png_handle_IHDR(png_ptr, info_ptr, length);
+ else if (!png_memcmp(chunk_name, png_IEND, 4))
+ png_handle_IEND(png_ptr, info_ptr, length);
+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+ else if (png_handle_as_unknown(png_ptr, chunk_name))
+ {
+ if (!png_memcmp(chunk_name, png_IDAT, 4))
+ png_ptr->mode |= PNG_HAVE_IDAT;
+ png_handle_unknown(png_ptr, info_ptr, length);
+ if (!png_memcmp(chunk_name, png_PLTE, 4))
+ png_ptr->mode |= PNG_HAVE_PLTE;
+ else if (!png_memcmp(chunk_name, png_IDAT, 4))
+ {
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))
+ png_error(png_ptr, "Missing IHDR before IDAT");
+ else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
+ !(png_ptr->mode & PNG_HAVE_PLTE))
+ png_error(png_ptr, "Missing PLTE before IDAT");
+ break;
+ }
+ }
+#endif
+ else if (!png_memcmp(chunk_name, png_PLTE, 4))
+ png_handle_PLTE(png_ptr, info_ptr, length);
+ else if (!png_memcmp(chunk_name, png_IDAT, 4))
+ {
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))
+ png_error(png_ptr, "Missing IHDR before IDAT");
+ else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
+ !(png_ptr->mode & PNG_HAVE_PLTE))
+ png_error(png_ptr, "Missing PLTE before IDAT");
+
+ png_ptr->idat_size = length;
+ png_ptr->mode |= PNG_HAVE_IDAT;
+ break;
+ }
+#if defined(PNG_READ_bKGD_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_bKGD, 4))
+ png_handle_bKGD(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_cHRM_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_cHRM, 4))
+ png_handle_cHRM(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_gAMA_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_gAMA, 4))
+ png_handle_gAMA(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_hIST_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_hIST, 4))
+ png_handle_hIST(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_oFFs_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_oFFs, 4))
+ png_handle_oFFs(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_pCAL_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_pCAL, 4))
+ png_handle_pCAL(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_sCAL_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_sCAL, 4))
+ png_handle_sCAL(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_pHYs_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_pHYs, 4))
+ png_handle_pHYs(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_sBIT_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_sBIT, 4))
+ png_handle_sBIT(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_sRGB_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_sRGB, 4))
+ png_handle_sRGB(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_iCCP_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_iCCP, 4))
+ png_handle_iCCP(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_sPLT_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_sPLT, 4))
+ png_handle_sPLT(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_tEXt_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_tEXt, 4))
+ png_handle_tEXt(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_tIME_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_tIME, 4))
+ png_handle_tIME(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_tRNS_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_tRNS, 4))
+ png_handle_tRNS(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_zTXt_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_zTXt, 4))
+ png_handle_zTXt(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_iTXt_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_iTXt, 4))
+ png_handle_iTXt(png_ptr, info_ptr, length);
+#endif
+ else
+ png_handle_unknown(png_ptr, info_ptr, length);
+ }
+}
+#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */
+
+/* optional call to update the users info_ptr structure */
+void PNGAPI
+png_read_update_info(png_structp png_ptr, png_infop info_ptr)
+{
+ png_debug(1, "in png_read_update_info\n");
+ if (png_ptr == NULL) return;
+ if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
+ png_read_start_row(png_ptr);
+ else
+ png_warning(png_ptr,
+ "Ignoring extra png_read_update_info() call; row buffer not reallocated");
+ png_read_transform_info(png_ptr, info_ptr);
+}
+
+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED
+/* Initialize palette, background, etc, after transformations
+ * are set, but before any reading takes place. This allows
+ * the user to obtain a gamma-corrected palette, for example.
+ * If the user doesn't call this, we will do it ourselves.
+ */
+void PNGAPI
+png_start_read_image(png_structp png_ptr)
+{
+ png_debug(1, "in png_start_read_image\n");
+ if (png_ptr == NULL) return;
+ if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
+ png_read_start_row(png_ptr);
+}
+#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */
+
+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED
+void PNGAPI
+png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_CONST PNG_IDAT;
+ PNG_CONST int png_pass_dsp_mask[7] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55,
+ 0xff};
+ PNG_CONST int png_pass_mask[7] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};
+#endif
+ int ret;
+ if (png_ptr == NULL) return;
+ png_debug2(1, "in png_read_row (row %lu, pass %d)\n",
+ png_ptr->row_number, png_ptr->pass);
+ if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
+ png_read_start_row(png_ptr);
+ if (png_ptr->row_number == 0 && png_ptr->pass == 0)
+ {
+ /* check for transforms that have been set but were defined out */
+#if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED)
+ if (png_ptr->transformations & PNG_INVERT_MONO)
+ png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined.");
+#endif
+#if defined(PNG_WRITE_FILLER_SUPPORTED) && !defined(PNG_READ_FILLER_SUPPORTED)
+ if (png_ptr->transformations & PNG_FILLER)
+ png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined.");
+#endif
+#if defined(PNG_WRITE_PACKSWAP_SUPPORTED) && !defined(PNG_READ_PACKSWAP_SUPPORTED)
+ if (png_ptr->transformations & PNG_PACKSWAP)
+ png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined.");
+#endif
+#if defined(PNG_WRITE_PACK_SUPPORTED) && !defined(PNG_READ_PACK_SUPPORTED)
+ if (png_ptr->transformations & PNG_PACK)
+ png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined.");
+#endif
+#if defined(PNG_WRITE_SHIFT_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED)
+ if (png_ptr->transformations & PNG_SHIFT)
+ png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined.");
+#endif
+#if defined(PNG_WRITE_BGR_SUPPORTED) && !defined(PNG_READ_BGR_SUPPORTED)
+ if (png_ptr->transformations & PNG_BGR)
+ png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined.");
+#endif
+#if defined(PNG_WRITE_SWAP_SUPPORTED) && !defined(PNG_READ_SWAP_SUPPORTED)
+ if (png_ptr->transformations & PNG_SWAP_BYTES)
+ png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined.");
+#endif
+ }
+
+#if defined(PNG_READ_INTERLACING_SUPPORTED)
+ /* if interlaced and we do not need a new row, combine row and return */
+ if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
+ {
+ switch (png_ptr->pass)
+ {
+ case 0:
+ if (png_ptr->row_number & 0x07)
+ {
+ if (dsp_row != NULL)
+ png_combine_row(png_ptr, dsp_row,
+ png_pass_dsp_mask[png_ptr->pass]);
+ png_read_finish_row(png_ptr);
+ return;
+ }
+ break;
+ case 1:
+ if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)
+ {
+ if (dsp_row != NULL)
+ png_combine_row(png_ptr, dsp_row,
+ png_pass_dsp_mask[png_ptr->pass]);
+ png_read_finish_row(png_ptr);
+ return;
+ }
+ break;
+ case 2:
+ if ((png_ptr->row_number & 0x07) != 4)
+ {
+ if (dsp_row != NULL && (png_ptr->row_number & 4))
+ png_combine_row(png_ptr, dsp_row,
+ png_pass_dsp_mask[png_ptr->pass]);
+ png_read_finish_row(png_ptr);
+ return;
+ }
+ break;
+ case 3:
+ if ((png_ptr->row_number & 3) || png_ptr->width < 3)
+ {
+ if (dsp_row != NULL)
+ png_combine_row(png_ptr, dsp_row,
+ png_pass_dsp_mask[png_ptr->pass]);
+ png_read_finish_row(png_ptr);
+ return;
+ }
+ break;
+ case 4:
+ if ((png_ptr->row_number & 3) != 2)
+ {
+ if (dsp_row != NULL && (png_ptr->row_number & 2))
+ png_combine_row(png_ptr, dsp_row,
+ png_pass_dsp_mask[png_ptr->pass]);
+ png_read_finish_row(png_ptr);
+ return;
+ }
+ break;
+ case 5:
+ if ((png_ptr->row_number & 1) || png_ptr->width < 2)
+ {
+ if (dsp_row != NULL)
+ png_combine_row(png_ptr, dsp_row,
+ png_pass_dsp_mask[png_ptr->pass]);
+ png_read_finish_row(png_ptr);
+ return;
+ }
+ break;
+ case 6:
+ if (!(png_ptr->row_number & 1))
+ {
+ png_read_finish_row(png_ptr);
+ return;
+ }
+ break;
+ }
+ }
+#endif
+
+ if (!(png_ptr->mode & PNG_HAVE_IDAT))
+ png_error(png_ptr, "Invalid attempt to read row data");
+
+ png_ptr->zstream.next_out = png_ptr->row_buf;
+ png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes;
+ do
+ {
+ if (!(png_ptr->zstream.avail_in))
+ {
+ while (!png_ptr->idat_size)
+ {
+ png_crc_finish(png_ptr, 0);
+
+ png_ptr->idat_size = png_read_chunk_header(png_ptr);
+ if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
+ png_error(png_ptr, "Not enough image data");
+ }
+ png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size;
+ png_ptr->zstream.next_in = png_ptr->zbuf;
+ if (png_ptr->zbuf_size > png_ptr->idat_size)
+ png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size;
+ png_crc_read(png_ptr, png_ptr->zbuf,
+ (png_size_t)png_ptr->zstream.avail_in);
+ png_ptr->idat_size -= png_ptr->zstream.avail_in;
+ }
+ ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
+ if (ret == Z_STREAM_END)
+ {
+ if (png_ptr->zstream.avail_out || png_ptr->zstream.avail_in ||
+ png_ptr->idat_size)
+ png_error(png_ptr, "Extra compressed data");
+ png_ptr->mode |= PNG_AFTER_IDAT;
+ png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
+ break;
+ }
+ if (ret != Z_OK)
+ png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :
+ "Decompression error");
+
+ } while (png_ptr->zstream.avail_out);
+
+ png_ptr->row_info.color_type = png_ptr->color_type;
+ png_ptr->row_info.width = png_ptr->iwidth;
+ png_ptr->row_info.channels = png_ptr->channels;
+ png_ptr->row_info.bit_depth = png_ptr->bit_depth;
+ png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;
+ png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,
+ png_ptr->row_info.width);
+
+ if (png_ptr->row_buf[0])
+ png_read_filter_row(png_ptr, &(png_ptr->row_info),
+ png_ptr->row_buf + 1, png_ptr->prev_row + 1,
+ (int)(png_ptr->row_buf[0]));
+
+ png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf,
+ png_ptr->rowbytes + 1);
+
+#if defined(PNG_MNG_FEATURES_SUPPORTED)
+ if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
+ (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))
+ {
+ /* Intrapixel differencing */
+ png_do_read_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1);
+ }
+#endif
+
+
+ if (png_ptr->transformations || (png_ptr->flags&PNG_FLAG_STRIP_ALPHA))
+ png_do_read_transformations(png_ptr);
+
+#if defined(PNG_READ_INTERLACING_SUPPORTED)
+ /* blow up interlaced rows to full size */
+ if (png_ptr->interlaced &&
+ (png_ptr->transformations & PNG_INTERLACE))
+ {
+ if (png_ptr->pass < 6)
+/* old interface (pre-1.0.9):
+ png_do_read_interlace(&(png_ptr->row_info),
+ png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations);
+ */
+ png_do_read_interlace(png_ptr);
+
+ if (dsp_row != NULL)
+ png_combine_row(png_ptr, dsp_row,
+ png_pass_dsp_mask[png_ptr->pass]);
+ if (row != NULL)
+ png_combine_row(png_ptr, row,
+ png_pass_mask[png_ptr->pass]);
+ }
+ else
+#endif
+ {
+ if (row != NULL)
+ png_combine_row(png_ptr, row, 0xff);
+ if (dsp_row != NULL)
+ png_combine_row(png_ptr, dsp_row, 0xff);
+ }
+ png_read_finish_row(png_ptr);
+
+ if (png_ptr->read_row_fn != NULL)
+ (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
+}
+#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */
+
+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED
+/* Read one or more rows of image data. If the image is interlaced,
+ * and png_set_interlace_handling() has been called, the rows need to
+ * contain the contents of the rows from the previous pass. If the
+ * image has alpha or transparency, and png_handle_alpha()[*] has been
+ * called, the rows contents must be initialized to the contents of the
+ * screen.
+ *
+ * "row" holds the actual image, and pixels are placed in it
+ * as they arrive. If the image is displayed after each pass, it will
+ * appear to "sparkle" in. "display_row" can be used to display a
+ * "chunky" progressive image, with finer detail added as it becomes
+ * available. If you do not want this "chunky" display, you may pass
+ * NULL for display_row. If you do not want the sparkle display, and
+ * you have not called png_handle_alpha(), you may pass NULL for rows.
+ * If you have called png_handle_alpha(), and the image has either an
+ * alpha channel or a transparency chunk, you must provide a buffer for
+ * rows. In this case, you do not have to provide a display_row buffer
+ * also, but you may. If the image is not interlaced, or if you have
+ * not called png_set_interlace_handling(), the display_row buffer will
+ * be ignored, so pass NULL to it.
+ *
+ * [*] png_handle_alpha() does not exist yet, as of this version of libpng
+ */
+
+void PNGAPI
+png_read_rows(png_structp png_ptr, png_bytepp row,
+ png_bytepp display_row, png_uint_32 num_rows)
+{
+ png_uint_32 i;
+ png_bytepp rp;
+ png_bytepp dp;
+
+ png_debug(1, "in png_read_rows\n");
+ if (png_ptr == NULL) return;
+ rp = row;
+ dp = display_row;
+ if (rp != NULL && dp != NULL)
+ for (i = 0; i < num_rows; i++)
+ {
+ png_bytep rptr = *rp++;
+ png_bytep dptr = *dp++;
+
+ png_read_row(png_ptr, rptr, dptr);
+ }
+ else if (rp != NULL)
+ for (i = 0; i < num_rows; i++)
+ {
+ png_bytep rptr = *rp;
+ png_read_row(png_ptr, rptr, png_bytep_NULL);
+ rp++;
+ }
+ else if (dp != NULL)
+ for (i = 0; i < num_rows; i++)
+ {
+ png_bytep dptr = *dp;
+ png_read_row(png_ptr, png_bytep_NULL, dptr);
+ dp++;
+ }
+}
+#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */
+
+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED
+/* Read the entire image. If the image has an alpha channel or a tRNS
+ * chunk, and you have called png_handle_alpha()[*], you will need to
+ * initialize the image to the current image that PNG will be overlaying.
+ * We set the num_rows again here, in case it was incorrectly set in
+ * png_read_start_row() by a call to png_read_update_info() or
+ * png_start_read_image() if png_set_interlace_handling() wasn't called
+ * prior to either of these functions like it should have been. You can
+ * only call this function once. If you desire to have an image for
+ * each pass of a interlaced image, use png_read_rows() instead.
+ *
+ * [*] png_handle_alpha() does not exist yet, as of this version of libpng
+ */
+void PNGAPI
+png_read_image(png_structp png_ptr, png_bytepp image)
+{
+ png_uint_32 i, image_height;
+ int pass, j;
+ png_bytepp rp;
+
+ png_debug(1, "in png_read_image\n");
+ if (png_ptr == NULL) return;
+
+#ifdef PNG_READ_INTERLACING_SUPPORTED
+ pass = png_set_interlace_handling(png_ptr);
+#else
+ if (png_ptr->interlaced)
+ png_error(png_ptr,
+ "Cannot read interlaced image -- interlace handler disabled.");
+ pass = 1;
+#endif
+
+
+ image_height=png_ptr->height;
+ png_ptr->num_rows = image_height; /* Make sure this is set correctly */
+
+ for (j = 0; j < pass; j++)
+ {
+ rp = image;
+ for (i = 0; i < image_height; i++)
+ {
+ png_read_row(png_ptr, *rp, png_bytep_NULL);
+ rp++;
+ }
+ }
+}
+#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */
+
+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED
+/* Read the end of the PNG file. Will not read past the end of the
+ * file, will verify the end is accurate, and will read any comments
+ * or time information at the end of the file, if info is not NULL.
+ */
+void PNGAPI
+png_read_end(png_structp png_ptr, png_infop info_ptr)
+{
+ png_debug(1, "in png_read_end\n");
+ if (png_ptr == NULL) return;
+ png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */
+
+ do
+ {
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_CONST PNG_IHDR;
+ PNG_CONST PNG_IDAT;
+ PNG_CONST PNG_IEND;
+ PNG_CONST PNG_PLTE;
+#if defined(PNG_READ_bKGD_SUPPORTED)
+ PNG_CONST PNG_bKGD;
+#endif
+#if defined(PNG_READ_cHRM_SUPPORTED)
+ PNG_CONST PNG_cHRM;
+#endif
+#if defined(PNG_READ_gAMA_SUPPORTED)
+ PNG_CONST PNG_gAMA;
+#endif
+#if defined(PNG_READ_hIST_SUPPORTED)
+ PNG_CONST PNG_hIST;
+#endif
+#if defined(PNG_READ_iCCP_SUPPORTED)
+ PNG_CONST PNG_iCCP;
+#endif
+#if defined(PNG_READ_iTXt_SUPPORTED)
+ PNG_CONST PNG_iTXt;
+#endif
+#if defined(PNG_READ_oFFs_SUPPORTED)
+ PNG_CONST PNG_oFFs;
+#endif
+#if defined(PNG_READ_pCAL_SUPPORTED)
+ PNG_CONST PNG_pCAL;
+#endif
+#if defined(PNG_READ_pHYs_SUPPORTED)
+ PNG_CONST PNG_pHYs;
+#endif
+#if defined(PNG_READ_sBIT_SUPPORTED)
+ PNG_CONST PNG_sBIT;
+#endif
+#if defined(PNG_READ_sCAL_SUPPORTED)
+ PNG_CONST PNG_sCAL;
+#endif
+#if defined(PNG_READ_sPLT_SUPPORTED)
+ PNG_CONST PNG_sPLT;
+#endif
+#if defined(PNG_READ_sRGB_SUPPORTED)
+ PNG_CONST PNG_sRGB;
+#endif
+#if defined(PNG_READ_tEXt_SUPPORTED)
+ PNG_CONST PNG_tEXt;
+#endif
+#if defined(PNG_READ_tIME_SUPPORTED)
+ PNG_CONST PNG_tIME;
+#endif
+#if defined(PNG_READ_tRNS_SUPPORTED)
+ PNG_CONST PNG_tRNS;
+#endif
+#if defined(PNG_READ_zTXt_SUPPORTED)
+ PNG_CONST PNG_zTXt;
+#endif
+#endif /* PNG_USE_LOCAL_ARRAYS */
+ png_uint_32 length = png_read_chunk_header(png_ptr);
+ PNG_CONST png_bytep chunk_name = png_ptr->chunk_name;
+
+ if (!png_memcmp(chunk_name, png_IHDR, 4))
+ png_handle_IHDR(png_ptr, info_ptr, length);
+ else if (!png_memcmp(chunk_name, png_IEND, 4))
+ png_handle_IEND(png_ptr, info_ptr, length);
+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+ else if (png_handle_as_unknown(png_ptr, chunk_name))
+ {
+ if (!png_memcmp(chunk_name, png_IDAT, 4))
+ {
+ if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))
+ png_error(png_ptr, "Too many IDAT's found");
+ }
+ png_handle_unknown(png_ptr, info_ptr, length);
+ if (!png_memcmp(chunk_name, png_PLTE, 4))
+ png_ptr->mode |= PNG_HAVE_PLTE;
+ }
+#endif
+ else if (!png_memcmp(chunk_name, png_IDAT, 4))
+ {
+ /* Zero length IDATs are legal after the last IDAT has been
+ * read, but not after other chunks have been read.
+ */
+ if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))
+ png_error(png_ptr, "Too many IDAT's found");
+ png_crc_finish(png_ptr, length);
+ }
+ else if (!png_memcmp(chunk_name, png_PLTE, 4))
+ png_handle_PLTE(png_ptr, info_ptr, length);
+#if defined(PNG_READ_bKGD_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_bKGD, 4))
+ png_handle_bKGD(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_cHRM_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_cHRM, 4))
+ png_handle_cHRM(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_gAMA_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_gAMA, 4))
+ png_handle_gAMA(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_hIST_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_hIST, 4))
+ png_handle_hIST(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_oFFs_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_oFFs, 4))
+ png_handle_oFFs(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_pCAL_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_pCAL, 4))
+ png_handle_pCAL(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_sCAL_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_sCAL, 4))
+ png_handle_sCAL(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_pHYs_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_pHYs, 4))
+ png_handle_pHYs(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_sBIT_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_sBIT, 4))
+ png_handle_sBIT(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_sRGB_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_sRGB, 4))
+ png_handle_sRGB(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_iCCP_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_iCCP, 4))
+ png_handle_iCCP(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_sPLT_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_sPLT, 4))
+ png_handle_sPLT(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_tEXt_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_tEXt, 4))
+ png_handle_tEXt(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_tIME_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_tIME, 4))
+ png_handle_tIME(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_tRNS_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_tRNS, 4))
+ png_handle_tRNS(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_zTXt_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_zTXt, 4))
+ png_handle_zTXt(png_ptr, info_ptr, length);
+#endif
+#if defined(PNG_READ_iTXt_SUPPORTED)
+ else if (!png_memcmp(chunk_name, png_iTXt, 4))
+ png_handle_iTXt(png_ptr, info_ptr, length);
+#endif
+ else
+ png_handle_unknown(png_ptr, info_ptr, length);
+ } while (!(png_ptr->mode & PNG_HAVE_IEND));
+}
+#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */
+
+/* free all memory used by the read */
+void PNGAPI
+png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
+ png_infopp end_info_ptr_ptr)
+{
+ png_structp png_ptr = NULL;
+ png_infop info_ptr = NULL, end_info_ptr = NULL;
+#ifdef PNG_USER_MEM_SUPPORTED
+ png_free_ptr free_fn = NULL;
+ png_voidp mem_ptr = NULL;
+#endif
+
+ png_debug(1, "in png_destroy_read_struct\n");
+ if (png_ptr_ptr != NULL)
+ png_ptr = *png_ptr_ptr;
+ if (png_ptr == NULL)
+ return;
+
+#ifdef PNG_USER_MEM_SUPPORTED
+ free_fn = png_ptr->free_fn;
+ mem_ptr = png_ptr->mem_ptr;
+#endif
+
+ if (info_ptr_ptr != NULL)
+ info_ptr = *info_ptr_ptr;
+
+ if (end_info_ptr_ptr != NULL)
+ end_info_ptr = *end_info_ptr_ptr;
+
+ png_read_destroy(png_ptr, info_ptr, end_info_ptr);
+
+ if (info_ptr != NULL)
+ {
+#if defined(PNG_TEXT_SUPPORTED)
+ png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, -1);
+#endif
+
+#ifdef PNG_USER_MEM_SUPPORTED
+ png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn,
+ (png_voidp)mem_ptr);
+#else
+ png_destroy_struct((png_voidp)info_ptr);
+#endif
+ *info_ptr_ptr = NULL;
+ }
+
+ if (end_info_ptr != NULL)
+ {
+#if defined(PNG_READ_TEXT_SUPPORTED)
+ png_free_data(png_ptr, end_info_ptr, PNG_FREE_TEXT, -1);
+#endif
+#ifdef PNG_USER_MEM_SUPPORTED
+ png_destroy_struct_2((png_voidp)end_info_ptr, (png_free_ptr)free_fn,
+ (png_voidp)mem_ptr);
+#else
+ png_destroy_struct((png_voidp)end_info_ptr);
+#endif
+ *end_info_ptr_ptr = NULL;
+ }
+
+ if (png_ptr != NULL)
+ {
+#ifdef PNG_USER_MEM_SUPPORTED
+ png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn,
+ (png_voidp)mem_ptr);
+#else
+ png_destroy_struct((png_voidp)png_ptr);
+#endif
+ *png_ptr_ptr = NULL;
+ }
+}
+
+/* free all memory used by the read (old method) */
+void /* PRIVATE */
+png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr)
+{
+#ifdef PNG_SETJMP_SUPPORTED
+ jmp_buf tmp_jmp;
+#endif
+ png_error_ptr error_fn;
+ png_error_ptr warning_fn;
+ png_voidp error_ptr;
+#ifdef PNG_USER_MEM_SUPPORTED
+ png_free_ptr free_fn;
+#endif
+
+ png_debug(1, "in png_read_destroy\n");
+ if (info_ptr != NULL)
+ png_info_destroy(png_ptr, info_ptr);
+
+ if (end_info_ptr != NULL)
+ png_info_destroy(png_ptr, end_info_ptr);
+
+ png_free(png_ptr, png_ptr->zbuf);
+ png_free(png_ptr, png_ptr->big_row_buf);
+ png_free(png_ptr, png_ptr->prev_row);
+ png_free(png_ptr, png_ptr->chunkdata);
+#if defined(PNG_READ_DITHER_SUPPORTED)
+ png_free(png_ptr, png_ptr->palette_lookup);
+ png_free(png_ptr, png_ptr->dither_index);
+#endif
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+ png_free(png_ptr, png_ptr->gamma_table);
+#endif
+#if defined(PNG_READ_BACKGROUND_SUPPORTED)
+ png_free(png_ptr, png_ptr->gamma_from_1);
+ png_free(png_ptr, png_ptr->gamma_to_1);
+#endif
+#ifdef PNG_FREE_ME_SUPPORTED
+ if (png_ptr->free_me & PNG_FREE_PLTE)
+ png_zfree(png_ptr, png_ptr->palette);
+ png_ptr->free_me &= ~PNG_FREE_PLTE;
+#else
+ if (png_ptr->flags & PNG_FLAG_FREE_PLTE)
+ png_zfree(png_ptr, png_ptr->palette);
+ png_ptr->flags &= ~PNG_FLAG_FREE_PLTE;
+#endif
+#if defined(PNG_tRNS_SUPPORTED) || \
+ defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+#ifdef PNG_FREE_ME_SUPPORTED
+ if (png_ptr->free_me & PNG_FREE_TRNS)
+ png_free(png_ptr, png_ptr->trans);
+ png_ptr->free_me &= ~PNG_FREE_TRNS;
+#else
+ if (png_ptr->flags & PNG_FLAG_FREE_TRNS)
+ png_free(png_ptr, png_ptr->trans);
+ png_ptr->flags &= ~PNG_FLAG_FREE_TRNS;
+#endif
+#endif
+#if defined(PNG_READ_hIST_SUPPORTED)
+#ifdef PNG_FREE_ME_SUPPORTED
+ if (png_ptr->free_me & PNG_FREE_HIST)
+ png_free(png_ptr, png_ptr->hist);
+ png_ptr->free_me &= ~PNG_FREE_HIST;
+#else
+ if (png_ptr->flags & PNG_FLAG_FREE_HIST)
+ png_free(png_ptr, png_ptr->hist);
+ png_ptr->flags &= ~PNG_FLAG_FREE_HIST;
+#endif
+#endif
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+ if (png_ptr->gamma_16_table != NULL)
+ {
+ int i;
+ int istop = (1 << (8 - png_ptr->gamma_shift));
+ for (i = 0; i < istop; i++)
+ {
+ png_free(png_ptr, png_ptr->gamma_16_table[i]);
+ }
+ png_free(png_ptr, png_ptr->gamma_16_table);
+ }
+#if defined(PNG_READ_BACKGROUND_SUPPORTED)
+ if (png_ptr->gamma_16_from_1 != NULL)
+ {
+ int i;
+ int istop = (1 << (8 - png_ptr->gamma_shift));
+ for (i = 0; i < istop; i++)
+ {
+ png_free(png_ptr, png_ptr->gamma_16_from_1[i]);
+ }
+ png_free(png_ptr, png_ptr->gamma_16_from_1);
+ }
+ if (png_ptr->gamma_16_to_1 != NULL)
+ {
+ int i;
+ int istop = (1 << (8 - png_ptr->gamma_shift));
+ for (i = 0; i < istop; i++)
+ {
+ png_free(png_ptr, png_ptr->gamma_16_to_1[i]);
+ }
+ png_free(png_ptr, png_ptr->gamma_16_to_1);
+ }
+#endif
+#endif
+#if defined(PNG_TIME_RFC1123_SUPPORTED)
+ png_free(png_ptr, png_ptr->time_buffer);
+#endif
+
+ inflateEnd(&png_ptr->zstream);
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
+ png_free(png_ptr, png_ptr->save_buffer);
+#endif
+
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
+#ifdef PNG_TEXT_SUPPORTED
+ png_free(png_ptr, png_ptr->current_text);
+#endif /* PNG_TEXT_SUPPORTED */
+#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
+
+ /* Save the important info out of the png_struct, in case it is
+ * being used again.
+ */
+#ifdef PNG_SETJMP_SUPPORTED
+ png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf));
+#endif
+
+ error_fn = png_ptr->error_fn;
+ warning_fn = png_ptr->warning_fn;
+ error_ptr = png_ptr->error_ptr;
+#ifdef PNG_USER_MEM_SUPPORTED
+ free_fn = png_ptr->free_fn;
+#endif
+
+ png_memset(png_ptr, 0, png_sizeof(png_struct));
+
+ png_ptr->error_fn = error_fn;
+ png_ptr->warning_fn = warning_fn;
+ png_ptr->error_ptr = error_ptr;
+#ifdef PNG_USER_MEM_SUPPORTED
+ png_ptr->free_fn = free_fn;
+#endif
+
+#ifdef PNG_SETJMP_SUPPORTED
+ png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf));
+#endif
+
+}
+
+void PNGAPI
+png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn)
+{
+ if (png_ptr == NULL) return;
+ png_ptr->read_row_fn = read_row_fn;
+}
+
+
+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED
+#if defined(PNG_INFO_IMAGE_SUPPORTED)
+void PNGAPI
+png_read_png(png_structp png_ptr, png_infop info_ptr,
+ int transforms,
+ voidp params)
+{
+ int row;
+
+ if (png_ptr == NULL) return;
+#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
+ /* invert the alpha channel from opacity to transparency
+ */
+ if (transforms & PNG_TRANSFORM_INVERT_ALPHA)
+ png_set_invert_alpha(png_ptr);
+#endif
+
+ /* png_read_info() gives us all of the information from the
+ * PNG file before the first IDAT (image data chunk).
+ */
+ png_read_info(png_ptr, info_ptr);
+ if (info_ptr->height > PNG_UINT_32_MAX/png_sizeof(png_bytep))
+ png_error(png_ptr, "Image is too high to process with png_read_png()");
+
+ /* -------------- image transformations start here ------------------- */
+
+#if defined(PNG_READ_16_TO_8_SUPPORTED)
+ /* tell libpng to strip 16 bit/color files down to 8 bits per color
+ */
+ if (transforms & PNG_TRANSFORM_STRIP_16)
+ png_set_strip_16(png_ptr);
+#endif
+
+#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
+ /* Strip alpha bytes from the input data without combining with
+ * the background (not recommended).
+ */
+ if (transforms & PNG_TRANSFORM_STRIP_ALPHA)
+ png_set_strip_alpha(png_ptr);
+#endif
+
+#if defined(PNG_READ_PACK_SUPPORTED) && !defined(PNG_READ_EXPAND_SUPPORTED)
+ /* Extract multiple pixels with bit depths of 1, 2, or 4 from a single
+ * byte into separate bytes (useful for paletted and grayscale images).
+ */
+ if (transforms & PNG_TRANSFORM_PACKING)
+ png_set_packing(png_ptr);
+#endif
+
+#if defined(PNG_READ_PACKSWAP_SUPPORTED)
+ /* Change the order of packed pixels to least significant bit first
+ * (not useful if you are using png_set_packing).
+ */
+ if (transforms & PNG_TRANSFORM_PACKSWAP)
+ png_set_packswap(png_ptr);
+#endif
+
+#if defined(PNG_READ_EXPAND_SUPPORTED)
+ /* Expand paletted colors into true RGB triplets
+ * Expand grayscale images to full 8 bits from 1, 2, or 4 bits/pixel
+ * Expand paletted or RGB images with transparency to full alpha
+ * channels so the data will be available as RGBA quartets.
+ */
+ if (transforms & PNG_TRANSFORM_EXPAND)
+ if ((png_ptr->bit_depth < 8) ||
+ (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) ||
+ (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)))
+ png_set_expand(png_ptr);
+#endif
+
+ /* We don't handle background color or gamma transformation or dithering.
+ */
+
+#if defined(PNG_READ_INVERT_SUPPORTED)
+ /* invert monochrome files to have 0 as white and 1 as black
+ */
+ if (transforms & PNG_TRANSFORM_INVERT_MONO)
+ png_set_invert_mono(png_ptr);
+#endif
+
+#if defined(PNG_READ_SHIFT_SUPPORTED)
+ /* If you want to shift the pixel values from the range [0,255] or
+ * [0,65535] to the original [0,7] or [0,31], or whatever range the
+ * colors were originally in:
+ */
+ if ((transforms & PNG_TRANSFORM_SHIFT)
+ && png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT))
+ {
+ png_color_8p sig_bit;
+
+ png_get_sBIT(png_ptr, info_ptr, &sig_bit);
+ png_set_shift(png_ptr, sig_bit);
+ }
+#endif
+
+#if defined(PNG_READ_BGR_SUPPORTED)
+ /* flip the RGB pixels to BGR (or RGBA to BGRA)
+ */
+ if (transforms & PNG_TRANSFORM_BGR)
+ png_set_bgr(png_ptr);
+#endif
+
+#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)
+ /* swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR)
+ */
+ if (transforms & PNG_TRANSFORM_SWAP_ALPHA)
+ png_set_swap_alpha(png_ptr);
+#endif
+
+#if defined(PNG_READ_SWAP_SUPPORTED)
+ /* swap bytes of 16 bit files to least significant byte first
+ */
+ if (transforms & PNG_TRANSFORM_SWAP_ENDIAN)
+ png_set_swap(png_ptr);
+#endif
+
+ /* We don't handle adding filler bytes */
+
+ /* Optional call to gamma correct and add the background to the palette
+ * and update info structure. REQUIRED if you are expecting libpng to
+ * update the palette for you (i.e., you selected such a transform above).
+ */
+ png_read_update_info(png_ptr, info_ptr);
+
+ /* -------------- image transformations end here ------------------- */
+
+#ifdef PNG_FREE_ME_SUPPORTED
+ png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);
+#endif
+ if (info_ptr->row_pointers == NULL)
+ {
+ info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr,
+ info_ptr->height * png_sizeof(png_bytep));
+#ifdef PNG_FREE_ME_SUPPORTED
+ info_ptr->free_me |= PNG_FREE_ROWS;
+#endif
+ for (row = 0; row < (int)info_ptr->height; row++)
+ {
+ info_ptr->row_pointers[row] = (png_bytep)png_malloc(png_ptr,
+ png_get_rowbytes(png_ptr, info_ptr));
+ }
+ }
+
+ png_read_image(png_ptr, info_ptr->row_pointers);
+ info_ptr->valid |= PNG_INFO_IDAT;
+
+ /* read rest of file, and get additional chunks in info_ptr - REQUIRED */
+ png_read_end(png_ptr, info_ptr);
+
+ transforms = transforms; /* quiet compiler warnings */
+ params = params;
+
+}
+#endif /* PNG_INFO_IMAGE_SUPPORTED */
+#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */
+#endif /* PNG_READ_SUPPORTED */
--- /dev/null
+
+/* pngrio.c - functions for data input
+ *
+ * Last changed in libpng 1.2.30 [August 15, 2008]
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * This file provides a location for all input. Users who need
+ * special handling are expected to write a function that has the same
+ * arguments as this and performs a similar function, but that possibly
+ * has a different input method. Note that you shouldn't change this
+ * function, but rather write a replacement function and then make
+ * libpng use it at run time with png_set_read_fn(...).
+ */
+
+#define PNG_INTERNAL
+#include "png.h"
+#if defined(PNG_READ_SUPPORTED)
+
+/* Read the data from whatever input you are using. The default routine
+ reads from a file pointer. Note that this routine sometimes gets called
+ with very small lengths, so you should implement some kind of simple
+ buffering if you are using unbuffered reads. This should never be asked
+ to read more then 64K on a 16 bit machine. */
+void /* PRIVATE */
+png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+ png_debug1(4, "reading %d bytes\n", (int)length);
+ if (png_ptr->read_data_fn != NULL)
+ (*(png_ptr->read_data_fn))(png_ptr, data, length);
+ else
+ png_error(png_ptr, "Call to NULL read function");
+}
+
+#if !defined(PNG_NO_STDIO)
+/* This is the function that does the actual reading of data. If you are
+ not reading from a standard C stream, you should create a replacement
+ read_data function and use it at run time with png_set_read_fn(), rather
+ than changing the library. */
+#ifndef USE_FAR_KEYWORD
+void PNGAPI
+png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+ png_size_t check;
+
+ if (png_ptr == NULL) return;
+ /* fread() returns 0 on error, so it is OK to store this in a png_size_t
+ * instead of an int, which is what fread() actually returns.
+ */
+#if defined(_WIN32_WCE)
+ if ( !ReadFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) )
+ check = 0;
+#else
+ check = (png_size_t)fread(data, (png_size_t)1, length,
+ (png_FILE_p)png_ptr->io_ptr);
+#endif
+
+ if (check != length)
+ png_error(png_ptr, "Read Error");
+}
+#else
+/* this is the model-independent version. Since the standard I/O library
+ can't handle far buffers in the medium and small models, we have to copy
+ the data.
+*/
+
+#define NEAR_BUF_SIZE 1024
+#define MIN(a,b) (a <= b ? a : b)
+
+static void PNGAPI
+png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+ int check;
+ png_byte *n_data;
+ png_FILE_p io_ptr;
+
+ if (png_ptr == NULL) return;
+ /* Check if data really is near. If so, use usual code. */
+ n_data = (png_byte *)CVT_PTR_NOCHECK(data);
+ io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);
+ if ((png_bytep)n_data == data)
+ {
+#if defined(_WIN32_WCE)
+ if ( !ReadFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) )
+ check = 0;
+#else
+ check = fread(n_data, 1, length, io_ptr);
+#endif
+ }
+ else
+ {
+ png_byte buf[NEAR_BUF_SIZE];
+ png_size_t read, remaining, err;
+ check = 0;
+ remaining = length;
+ do
+ {
+ read = MIN(NEAR_BUF_SIZE, remaining);
+#if defined(_WIN32_WCE)
+ if ( !ReadFile((HANDLE)(io_ptr), buf, read, &err, NULL) )
+ err = 0;
+#else
+ err = fread(buf, (png_size_t)1, read, io_ptr);
+#endif
+ png_memcpy(data, buf, read); /* copy far buffer to near buffer */
+ if (err != read)
+ break;
+ else
+ check += err;
+ data += read;
+ remaining -= read;
+ }
+ while (remaining != 0);
+ }
+ if ((png_uint_32)check != (png_uint_32)length)
+ png_error(png_ptr, "read Error");
+}
+#endif
+#endif
+
+/* This function allows the application to supply a new input function
+ for libpng if standard C streams aren't being used.
+
+ This function takes as its arguments:
+ png_ptr - pointer to a png input data structure
+ io_ptr - pointer to user supplied structure containing info about
+ the input functions. May be NULL.
+ read_data_fn - pointer to a new input function that takes as its
+ arguments a pointer to a png_struct, a pointer to
+ a location where input data can be stored, and a 32-bit
+ unsigned int that is the number of bytes to be read.
+ To exit and output any fatal error messages the new write
+ function should call png_error(png_ptr, "Error msg"). */
+void PNGAPI
+png_set_read_fn(png_structp png_ptr, png_voidp io_ptr,
+ png_rw_ptr read_data_fn)
+{
+ if (png_ptr == NULL) return;
+ png_ptr->io_ptr = io_ptr;
+
+#if !defined(PNG_NO_STDIO)
+ if (read_data_fn != NULL)
+ png_ptr->read_data_fn = read_data_fn;
+ else
+ png_ptr->read_data_fn = png_default_read_data;
+#else
+ png_ptr->read_data_fn = read_data_fn;
+#endif
+
+ /* It is an error to write to a read device */
+ if (png_ptr->write_data_fn != NULL)
+ {
+ png_ptr->write_data_fn = NULL;
+ png_warning(png_ptr,
+ "It's an error to set both read_data_fn and write_data_fn in the ");
+ png_warning(png_ptr,
+ "same structure. Resetting write_data_fn to NULL.");
+ }
+
+#if defined(PNG_WRITE_FLUSH_SUPPORTED)
+ png_ptr->output_flush_fn = NULL;
+#endif
+}
+#endif /* PNG_READ_SUPPORTED */
--- /dev/null
+
+/* pngrtran.c - transforms the data in a row for PNG readers
+ *
+ * Last changed in libpng 1.2.30 [August 15, 2008]
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * This file contains functions optionally called by an application
+ * in order to tell libpng how to handle data when reading a PNG.
+ * Transformations that are used in both reading and writing are
+ * in pngtrans.c.
+ */
+
+#define PNG_INTERNAL
+#include "png.h"
+#if defined(PNG_READ_SUPPORTED)
+
+/* Set the action on getting a CRC error for an ancillary or critical chunk. */
+void PNGAPI
+png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action)
+{
+ png_debug(1, "in png_set_crc_action\n");
+ /* Tell libpng how we react to CRC errors in critical chunks */
+ if (png_ptr == NULL) return;
+ switch (crit_action)
+ {
+ case PNG_CRC_NO_CHANGE: /* leave setting as is */
+ break;
+ case PNG_CRC_WARN_USE: /* warn/use data */
+ png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
+ png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE;
+ break;
+ case PNG_CRC_QUIET_USE: /* quiet/use data */
+ png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
+ png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE |
+ PNG_FLAG_CRC_CRITICAL_IGNORE;
+ break;
+ case PNG_CRC_WARN_DISCARD: /* not a valid action for critical data */
+ png_warning(png_ptr,
+ "Can't discard critical data on CRC error.");
+ case PNG_CRC_ERROR_QUIT: /* error/quit */
+ case PNG_CRC_DEFAULT:
+ default:
+ png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
+ break;
+ }
+
+ switch (ancil_action)
+ {
+ case PNG_CRC_NO_CHANGE: /* leave setting as is */
+ break;
+ case PNG_CRC_WARN_USE: /* warn/use data */
+ png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
+ png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE;
+ break;
+ case PNG_CRC_QUIET_USE: /* quiet/use data */
+ png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
+ png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE |
+ PNG_FLAG_CRC_ANCILLARY_NOWARN;
+ break;
+ case PNG_CRC_ERROR_QUIT: /* error/quit */
+ png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
+ png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_NOWARN;
+ break;
+ case PNG_CRC_WARN_DISCARD: /* warn/discard data */
+ case PNG_CRC_DEFAULT:
+ default:
+ png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
+ break;
+ }
+}
+
+#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \
+ defined(PNG_FLOATING_POINT_SUPPORTED)
+/* handle alpha and tRNS via a background color */
+void PNGAPI
+png_set_background(png_structp png_ptr,
+ png_color_16p background_color, int background_gamma_code,
+ int need_expand, double background_gamma)
+{
+ png_debug(1, "in png_set_background\n");
+ if (png_ptr == NULL) return;
+ if (background_gamma_code == PNG_BACKGROUND_GAMMA_UNKNOWN)
+ {
+ png_warning(png_ptr, "Application must supply a known background gamma");
+ return;
+ }
+
+ png_ptr->transformations |= PNG_BACKGROUND;
+ png_memcpy(&(png_ptr->background), background_color,
+ png_sizeof(png_color_16));
+ png_ptr->background_gamma = (float)background_gamma;
+ png_ptr->background_gamma_type = (png_byte)(background_gamma_code);
+ png_ptr->transformations |= (need_expand ? PNG_BACKGROUND_EXPAND : 0);
+}
+#endif
+
+#if defined(PNG_READ_16_TO_8_SUPPORTED)
+/* strip 16 bit depth files to 8 bit depth */
+void PNGAPI
+png_set_strip_16(png_structp png_ptr)
+{
+ png_debug(1, "in png_set_strip_16\n");
+ if (png_ptr == NULL) return;
+ png_ptr->transformations |= PNG_16_TO_8;
+}
+#endif
+
+#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
+void PNGAPI
+png_set_strip_alpha(png_structp png_ptr)
+{
+ png_debug(1, "in png_set_strip_alpha\n");
+ if (png_ptr == NULL) return;
+ png_ptr->flags |= PNG_FLAG_STRIP_ALPHA;
+}
+#endif
+
+#if defined(PNG_READ_DITHER_SUPPORTED)
+/* Dither file to 8 bit. Supply a palette, the current number
+ * of elements in the palette, the maximum number of elements
+ * allowed, and a histogram if possible. If the current number
+ * of colors is greater then the maximum number, the palette will be
+ * modified to fit in the maximum number. "full_dither" indicates
+ * whether we need a dithering cube set up for RGB images, or if we
+ * simply are reducing the number of colors in a paletted image.
+ */
+
+typedef struct png_dsort_struct
+{
+ struct png_dsort_struct FAR * next;
+ png_byte left;
+ png_byte right;
+} png_dsort;
+typedef png_dsort FAR * png_dsortp;
+typedef png_dsort FAR * FAR * png_dsortpp;
+
+void PNGAPI
+png_set_dither(png_structp png_ptr, png_colorp palette,
+ int num_palette, int maximum_colors, png_uint_16p histogram,
+ int full_dither)
+{
+ png_debug(1, "in png_set_dither\n");
+ if (png_ptr == NULL) return;
+ png_ptr->transformations |= PNG_DITHER;
+
+ if (!full_dither)
+ {
+ int i;
+
+ png_ptr->dither_index = (png_bytep)png_malloc(png_ptr,
+ (png_uint_32)(num_palette * png_sizeof(png_byte)));
+ for (i = 0; i < num_palette; i++)
+ png_ptr->dither_index[i] = (png_byte)i;
+ }
+
+ if (num_palette > maximum_colors)
+ {
+ if (histogram != NULL)
+ {
+ /* This is easy enough, just throw out the least used colors.
+ Perhaps not the best solution, but good enough. */
+
+ int i;
+
+ /* initialize an array to sort colors */
+ png_ptr->dither_sort = (png_bytep)png_malloc(png_ptr,
+ (png_uint_32)(num_palette * png_sizeof(png_byte)));
+
+ /* initialize the dither_sort array */
+ for (i = 0; i < num_palette; i++)
+ png_ptr->dither_sort[i] = (png_byte)i;
+
+ /* Find the least used palette entries by starting a
+ bubble sort, and running it until we have sorted
+ out enough colors. Note that we don't care about
+ sorting all the colors, just finding which are
+ least used. */
+
+ for (i = num_palette - 1; i >= maximum_colors; i--)
+ {
+ int done; /* to stop early if the list is pre-sorted */
+ int j;
+
+ done = 1;
+ for (j = 0; j < i; j++)
+ {
+ if (histogram[png_ptr->dither_sort[j]]
+ < histogram[png_ptr->dither_sort[j + 1]])
+ {
+ png_byte t;
+
+ t = png_ptr->dither_sort[j];
+ png_ptr->dither_sort[j] = png_ptr->dither_sort[j + 1];
+ png_ptr->dither_sort[j + 1] = t;
+ done = 0;
+ }
+ }
+ if (done)
+ break;
+ }
+
+ /* swap the palette around, and set up a table, if necessary */
+ if (full_dither)
+ {
+ int j = num_palette;
+
+ /* put all the useful colors within the max, but don't
+ move the others */
+ for (i = 0; i < maximum_colors; i++)
+ {
+ if ((int)png_ptr->dither_sort[i] >= maximum_colors)
+ {
+ do
+ j--;
+ while ((int)png_ptr->dither_sort[j] >= maximum_colors);
+ palette[i] = palette[j];
+ }
+ }
+ }
+ else
+ {
+ int j = num_palette;
+
+ /* move all the used colors inside the max limit, and
+ develop a translation table */
+ for (i = 0; i < maximum_colors; i++)
+ {
+ /* only move the colors we need to */
+ if ((int)png_ptr->dither_sort[i] >= maximum_colors)
+ {
+ png_color tmp_color;
+
+ do
+ j--;
+ while ((int)png_ptr->dither_sort[j] >= maximum_colors);
+
+ tmp_color = palette[j];
+ palette[j] = palette[i];
+ palette[i] = tmp_color;
+ /* indicate where the color went */
+ png_ptr->dither_index[j] = (png_byte)i;
+ png_ptr->dither_index[i] = (png_byte)j;
+ }
+ }
+
+ /* find closest color for those colors we are not using */
+ for (i = 0; i < num_palette; i++)
+ {
+ if ((int)png_ptr->dither_index[i] >= maximum_colors)
+ {
+ int min_d, k, min_k, d_index;
+
+ /* find the closest color to one we threw out */
+ d_index = png_ptr->dither_index[i];
+ min_d = PNG_COLOR_DIST(palette[d_index], palette[0]);
+ for (k = 1, min_k = 0; k < maximum_colors; k++)
+ {
+ int d;
+
+ d = PNG_COLOR_DIST(palette[d_index], palette[k]);
+
+ if (d < min_d)
+ {
+ min_d = d;
+ min_k = k;
+ }
+ }
+ /* point to closest color */
+ png_ptr->dither_index[i] = (png_byte)min_k;
+ }
+ }
+ }
+ png_free(png_ptr, png_ptr->dither_sort);
+ png_ptr->dither_sort = NULL;
+ }
+ else
+ {
+ /* This is much harder to do simply (and quickly). Perhaps
+ we need to go through a median cut routine, but those
+ don't always behave themselves with only a few colors
+ as input. So we will just find the closest two colors,
+ and throw out one of them (chosen somewhat randomly).
+ [We don't understand this at all, so if someone wants to
+ work on improving it, be our guest - AED, GRP]
+ */
+ int i;
+ int max_d;
+ int num_new_palette;
+ png_dsortp t;
+ png_dsortpp hash;
+
+ t = NULL;
+
+ /* initialize palette index arrays */
+ png_ptr->index_to_palette = (png_bytep)png_malloc(png_ptr,
+ (png_uint_32)(num_palette * png_sizeof(png_byte)));
+ png_ptr->palette_to_index = (png_bytep)png_malloc(png_ptr,
+ (png_uint_32)(num_palette * png_sizeof(png_byte)));
+
+ /* initialize the sort array */
+ for (i = 0; i < num_palette; i++)
+ {
+ png_ptr->index_to_palette[i] = (png_byte)i;
+ png_ptr->palette_to_index[i] = (png_byte)i;
+ }
+
+ hash = (png_dsortpp)png_malloc(png_ptr, (png_uint_32)(769 *
+ png_sizeof(png_dsortp)));
+ for (i = 0; i < 769; i++)
+ hash[i] = NULL;
+/* png_memset(hash, 0, 769 * png_sizeof(png_dsortp)); */
+
+ num_new_palette = num_palette;
+
+ /* initial wild guess at how far apart the farthest pixel
+ pair we will be eliminating will be. Larger
+ numbers mean more areas will be allocated, Smaller
+ numbers run the risk of not saving enough data, and
+ having to do this all over again.
+
+ I have not done extensive checking on this number.
+ */
+ max_d = 96;
+
+ while (num_new_palette > maximum_colors)
+ {
+ for (i = 0; i < num_new_palette - 1; i++)
+ {
+ int j;
+
+ for (j = i + 1; j < num_new_palette; j++)
+ {
+ int d;
+
+ d = PNG_COLOR_DIST(palette[i], palette[j]);
+
+ if (d <= max_d)
+ {
+
+ t = (png_dsortp)png_malloc_warn(png_ptr,
+ (png_uint_32)(png_sizeof(png_dsort)));
+ if (t == NULL)
+ break;
+ t->next = hash[d];
+ t->left = (png_byte)i;
+ t->right = (png_byte)j;
+ hash[d] = t;
+ }
+ }
+ if (t == NULL)
+ break;
+ }
+
+ if (t != NULL)
+ for (i = 0; i <= max_d; i++)
+ {
+ if (hash[i] != NULL)
+ {
+ png_dsortp p;
+
+ for (p = hash[i]; p; p = p->next)
+ {
+ if ((int)png_ptr->index_to_palette[p->left]
+ < num_new_palette &&
+ (int)png_ptr->index_to_palette[p->right]
+ < num_new_palette)
+ {
+ int j, next_j;
+
+ if (num_new_palette & 0x01)
+ {
+ j = p->left;
+ next_j = p->right;
+ }
+ else
+ {
+ j = p->right;
+ next_j = p->left;
+ }
+
+ num_new_palette--;
+ palette[png_ptr->index_to_palette[j]]
+ = palette[num_new_palette];
+ if (!full_dither)
+ {
+ int k;
+
+ for (k = 0; k < num_palette; k++)
+ {
+ if (png_ptr->dither_index[k] ==
+ png_ptr->index_to_palette[j])
+ png_ptr->dither_index[k] =
+ png_ptr->index_to_palette[next_j];
+ if ((int)png_ptr->dither_index[k] ==
+ num_new_palette)
+ png_ptr->dither_index[k] =
+ png_ptr->index_to_palette[j];
+ }
+ }
+
+ png_ptr->index_to_palette[png_ptr->palette_to_index
+ [num_new_palette]] = png_ptr->index_to_palette[j];
+ png_ptr->palette_to_index[png_ptr->index_to_palette[j]]
+ = png_ptr->palette_to_index[num_new_palette];
+
+ png_ptr->index_to_palette[j] = (png_byte)num_new_palette;
+ png_ptr->palette_to_index[num_new_palette] = (png_byte)j;
+ }
+ if (num_new_palette <= maximum_colors)
+ break;
+ }
+ if (num_new_palette <= maximum_colors)
+ break;
+ }
+ }
+
+ for (i = 0; i < 769; i++)
+ {
+ if (hash[i] != NULL)
+ {
+ png_dsortp p = hash[i];
+ while (p)
+ {
+ t = p->next;
+ png_free(png_ptr, p);
+ p = t;
+ }
+ }
+ hash[i] = 0;
+ }
+ max_d += 96;
+ }
+ png_free(png_ptr, hash);
+ png_free(png_ptr, png_ptr->palette_to_index);
+ png_free(png_ptr, png_ptr->index_to_palette);
+ png_ptr->palette_to_index = NULL;
+ png_ptr->index_to_palette = NULL;
+ }
+ num_palette = maximum_colors;
+ }
+ if (png_ptr->palette == NULL)
+ {
+ png_ptr->palette = palette;
+ }
+ png_ptr->num_palette = (png_uint_16)num_palette;
+
+ if (full_dither)
+ {
+ int i;
+ png_bytep distance;
+ int total_bits = PNG_DITHER_RED_BITS + PNG_DITHER_GREEN_BITS +
+ PNG_DITHER_BLUE_BITS;
+ int num_red = (1 << PNG_DITHER_RED_BITS);
+ int num_green = (1 << PNG_DITHER_GREEN_BITS);
+ int num_blue = (1 << PNG_DITHER_BLUE_BITS);
+ png_size_t num_entries = ((png_size_t)1 << total_bits);
+
+ png_ptr->palette_lookup = (png_bytep )png_malloc(png_ptr,
+ (png_uint_32)(num_entries * png_sizeof(png_byte)));
+
+ png_memset(png_ptr->palette_lookup, 0, num_entries *
+ png_sizeof(png_byte));
+
+ distance = (png_bytep)png_malloc(png_ptr, (png_uint_32)(num_entries *
+ png_sizeof(png_byte)));
+
+ png_memset(distance, 0xff, num_entries * png_sizeof(png_byte));
+
+ for (i = 0; i < num_palette; i++)
+ {
+ int ir, ig, ib;
+ int r = (palette[i].red >> (8 - PNG_DITHER_RED_BITS));
+ int g = (palette[i].green >> (8 - PNG_DITHER_GREEN_BITS));
+ int b = (palette[i].blue >> (8 - PNG_DITHER_BLUE_BITS));
+
+ for (ir = 0; ir < num_red; ir++)
+ {
+ /* int dr = abs(ir - r); */
+ int dr = ((ir > r) ? ir - r : r - ir);
+ int index_r = (ir << (PNG_DITHER_BLUE_BITS + PNG_DITHER_GREEN_BITS));
+
+ for (ig = 0; ig < num_green; ig++)
+ {
+ /* int dg = abs(ig - g); */
+ int dg = ((ig > g) ? ig - g : g - ig);
+ int dt = dr + dg;
+ int dm = ((dr > dg) ? dr : dg);
+ int index_g = index_r | (ig << PNG_DITHER_BLUE_BITS);
+
+ for (ib = 0; ib < num_blue; ib++)
+ {
+ int d_index = index_g | ib;
+ /* int db = abs(ib - b); */
+ int db = ((ib > b) ? ib - b : b - ib);
+ int dmax = ((dm > db) ? dm : db);
+ int d = dmax + dt + db;
+
+ if (d < (int)distance[d_index])
+ {
+ distance[d_index] = (png_byte)d;
+ png_ptr->palette_lookup[d_index] = (png_byte)i;
+ }
+ }
+ }
+ }
+ }
+
+ png_free(png_ptr, distance);
+ }
+}
+#endif
+
+#if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)
+/* Transform the image from the file_gamma to the screen_gamma. We
+ * only do transformations on images where the file_gamma and screen_gamma
+ * are not close reciprocals, otherwise it slows things down slightly, and
+ * also needlessly introduces small errors.
+ *
+ * We will turn off gamma transformation later if no semitransparent entries
+ * are present in the tRNS array for palette images. We can't do it here
+ * because we don't necessarily have the tRNS chunk yet.
+ */
+void PNGAPI
+png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma)
+{
+ png_debug(1, "in png_set_gamma\n");
+ if (png_ptr == NULL) return;
+ if ((fabs(scrn_gamma * file_gamma - 1.0) > PNG_GAMMA_THRESHOLD) ||
+ (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) ||
+ (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE))
+ png_ptr->transformations |= PNG_GAMMA;
+ png_ptr->gamma = (float)file_gamma;
+ png_ptr->screen_gamma = (float)scrn_gamma;
+}
+#endif
+
+#if defined(PNG_READ_EXPAND_SUPPORTED)
+/* Expand paletted images to RGB, expand grayscale images of
+ * less than 8-bit depth to 8-bit depth, and expand tRNS chunks
+ * to alpha channels.
+ */
+void PNGAPI
+png_set_expand(png_structp png_ptr)
+{
+ png_debug(1, "in png_set_expand\n");
+ if (png_ptr == NULL) return;
+ png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
+ png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
+}
+
+/* GRR 19990627: the following three functions currently are identical
+ * to png_set_expand(). However, it is entirely reasonable that someone
+ * might wish to expand an indexed image to RGB but *not* expand a single,
+ * fully transparent palette entry to a full alpha channel--perhaps instead
+ * convert tRNS to the grayscale/RGB format (16-bit RGB value), or replace
+ * the transparent color with a particular RGB value, or drop tRNS entirely.
+ * IOW, a future version of the library may make the transformations flag
+ * a bit more fine-grained, with separate bits for each of these three
+ * functions.
+ *
+ * More to the point, these functions make it obvious what libpng will be
+ * doing, whereas "expand" can (and does) mean any number of things.
+ *
+ * GRP 20060307: In libpng-1.4.0, png_set_gray_1_2_4_to_8() was modified
+ * to expand only the sample depth but not to expand the tRNS to alpha.
+ */
+
+/* Expand paletted images to RGB. */
+void PNGAPI
+png_set_palette_to_rgb(png_structp png_ptr)
+{
+ png_debug(1, "in png_set_palette_to_rgb\n");
+ if (png_ptr == NULL) return;
+ png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
+ png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
+}
+
+#if !defined(PNG_1_0_X)
+/* Expand grayscale images of less than 8-bit depth to 8 bits. */
+void PNGAPI
+png_set_expand_gray_1_2_4_to_8(png_structp png_ptr)
+{
+ png_debug(1, "in png_set_expand_gray_1_2_4_to_8\n");
+ if (png_ptr == NULL) return;
+ png_ptr->transformations |= PNG_EXPAND;
+ png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
+}
+#endif
+
+#if defined(PNG_1_0_X) || defined(PNG_1_2_X)
+/* Expand grayscale images of less than 8-bit depth to 8 bits. */
+/* Deprecated as of libpng-1.2.9 */
+void PNGAPI
+png_set_gray_1_2_4_to_8(png_structp png_ptr)
+{
+ png_debug(1, "in png_set_gray_1_2_4_to_8\n");
+ if (png_ptr == NULL) return;
+ png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
+}
+#endif
+
+
+/* Expand tRNS chunks to alpha channels. */
+void PNGAPI
+png_set_tRNS_to_alpha(png_structp png_ptr)
+{
+ png_debug(1, "in png_set_tRNS_to_alpha\n");
+ png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
+ png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
+}
+#endif /* defined(PNG_READ_EXPAND_SUPPORTED) */
+
+#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
+void PNGAPI
+png_set_gray_to_rgb(png_structp png_ptr)
+{
+ png_debug(1, "in png_set_gray_to_rgb\n");
+ png_ptr->transformations |= PNG_GRAY_TO_RGB;
+ png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
+}
+#endif
+
+#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
+#if defined(PNG_FLOATING_POINT_SUPPORTED)
+/* Convert a RGB image to a grayscale of the same width. This allows us,
+ * for example, to convert a 24 bpp RGB image into an 8 bpp grayscale image.
+ */
+
+void PNGAPI
+png_set_rgb_to_gray(png_structp png_ptr, int error_action, double red,
+ double green)
+{
+ int red_fixed = (int)((float)red*100000.0 + 0.5);
+ int green_fixed = (int)((float)green*100000.0 + 0.5);
+ if (png_ptr == NULL) return;
+ png_set_rgb_to_gray_fixed(png_ptr, error_action, red_fixed, green_fixed);
+}
+#endif
+
+void PNGAPI
+png_set_rgb_to_gray_fixed(png_structp png_ptr, int error_action,
+ png_fixed_point red, png_fixed_point green)
+{
+ png_debug(1, "in png_set_rgb_to_gray\n");
+ if (png_ptr == NULL) return;
+ switch(error_action)
+ {
+ case 1: png_ptr->transformations |= PNG_RGB_TO_GRAY;
+ break;
+ case 2: png_ptr->transformations |= PNG_RGB_TO_GRAY_WARN;
+ break;
+ case 3: png_ptr->transformations |= PNG_RGB_TO_GRAY_ERR;
+ }
+ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+#if defined(PNG_READ_EXPAND_SUPPORTED)
+ png_ptr->transformations |= PNG_EXPAND;
+#else
+ {
+ png_warning(png_ptr,
+ "Cannot do RGB_TO_GRAY without EXPAND_SUPPORTED.");
+ png_ptr->transformations &= ~PNG_RGB_TO_GRAY;
+ }
+#endif
+ {
+ png_uint_16 red_int, green_int;
+ if (red < 0 || green < 0)
+ {
+ red_int = 6968; /* .212671 * 32768 + .5 */
+ green_int = 23434; /* .715160 * 32768 + .5 */
+ }
+ else if (red + green < 100000L)
+ {
+ red_int = (png_uint_16)(((png_uint_32)red*32768L)/100000L);
+ green_int = (png_uint_16)(((png_uint_32)green*32768L)/100000L);
+ }
+ else
+ {
+ png_warning(png_ptr, "ignoring out of range rgb_to_gray coefficients");
+ red_int = 6968;
+ green_int = 23434;
+ }
+ png_ptr->rgb_to_gray_red_coeff = red_int;
+ png_ptr->rgb_to_gray_green_coeff = green_int;
+ png_ptr->rgb_to_gray_blue_coeff =
+ (png_uint_16)(32768 - red_int - green_int);
+ }
+}
+#endif
+
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
+ defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \
+ defined(PNG_LEGACY_SUPPORTED)
+void PNGAPI
+png_set_read_user_transform_fn(png_structp png_ptr, png_user_transform_ptr
+ read_user_transform_fn)
+{
+ png_debug(1, "in png_set_read_user_transform_fn\n");
+ if (png_ptr == NULL) return;
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
+ png_ptr->transformations |= PNG_USER_TRANSFORM;
+ png_ptr->read_user_transform_fn = read_user_transform_fn;
+#endif
+#ifdef PNG_LEGACY_SUPPORTED
+ if (read_user_transform_fn)
+ png_warning(png_ptr,
+ "This version of libpng does not support user transforms");
+#endif
+}
+#endif
+
+/* Initialize everything needed for the read. This includes modifying
+ * the palette.
+ */
+void /* PRIVATE */
+png_init_read_transformations(png_structp png_ptr)
+{
+ png_debug(1, "in png_init_read_transformations\n");
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+ if (png_ptr != NULL)
+#endif
+ {
+#if defined(PNG_READ_BACKGROUND_SUPPORTED) || defined(PNG_READ_SHIFT_SUPPORTED) \
+ || defined(PNG_READ_GAMMA_SUPPORTED)
+ int color_type = png_ptr->color_type;
+#endif
+
+#if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED)
+
+#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
+ /* Detect gray background and attempt to enable optimization
+ * for gray --> RGB case */
+ /* Note: if PNG_BACKGROUND_EXPAND is set and color_type is either RGB or
+ * RGB_ALPHA (in which case need_expand is superfluous anyway), the
+ * background color might actually be gray yet not be flagged as such.
+ * This is not a problem for the current code, which uses
+ * PNG_BACKGROUND_IS_GRAY only to decide when to do the
+ * png_do_gray_to_rgb() transformation.
+ */
+ if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&
+ !(color_type & PNG_COLOR_MASK_COLOR))
+ {
+ png_ptr->mode |= PNG_BACKGROUND_IS_GRAY;
+ } else if ((png_ptr->transformations & PNG_BACKGROUND) &&
+ !(png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&
+ (png_ptr->transformations & PNG_GRAY_TO_RGB) &&
+ png_ptr->background.red == png_ptr->background.green &&
+ png_ptr->background.red == png_ptr->background.blue)
+ {
+ png_ptr->mode |= PNG_BACKGROUND_IS_GRAY;
+ png_ptr->background.gray = png_ptr->background.red;
+ }
+#endif
+
+ if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&
+ (png_ptr->transformations & PNG_EXPAND))
+ {
+ if (!(color_type & PNG_COLOR_MASK_COLOR)) /* i.e., GRAY or GRAY_ALPHA */
+ {
+ /* expand background and tRNS chunks */
+ switch (png_ptr->bit_depth)
+ {
+ case 1:
+ png_ptr->background.gray *= (png_uint_16)0xff;
+ png_ptr->background.red = png_ptr->background.green
+ = png_ptr->background.blue = png_ptr->background.gray;
+ if (!(png_ptr->transformations & PNG_EXPAND_tRNS))
+ {
+ png_ptr->trans_values.gray *= (png_uint_16)0xff;
+ png_ptr->trans_values.red = png_ptr->trans_values.green
+ = png_ptr->trans_values.blue = png_ptr->trans_values.gray;
+ }
+ break;
+ case 2:
+ png_ptr->background.gray *= (png_uint_16)0x55;
+ png_ptr->background.red = png_ptr->background.green
+ = png_ptr->background.blue = png_ptr->background.gray;
+ if (!(png_ptr->transformations & PNG_EXPAND_tRNS))
+ {
+ png_ptr->trans_values.gray *= (png_uint_16)0x55;
+ png_ptr->trans_values.red = png_ptr->trans_values.green
+ = png_ptr->trans_values.blue = png_ptr->trans_values.gray;
+ }
+ break;
+ case 4:
+ png_ptr->background.gray *= (png_uint_16)0x11;
+ png_ptr->background.red = png_ptr->background.green
+ = png_ptr->background.blue = png_ptr->background.gray;
+ if (!(png_ptr->transformations & PNG_EXPAND_tRNS))
+ {
+ png_ptr->trans_values.gray *= (png_uint_16)0x11;
+ png_ptr->trans_values.red = png_ptr->trans_values.green
+ = png_ptr->trans_values.blue = png_ptr->trans_values.gray;
+ }
+ break;
+ case 8:
+ case 16:
+ png_ptr->background.red = png_ptr->background.green
+ = png_ptr->background.blue = png_ptr->background.gray;
+ break;
+ }
+ }
+ else if (color_type == PNG_COLOR_TYPE_PALETTE)
+ {
+ png_ptr->background.red =
+ png_ptr->palette[png_ptr->background.index].red;
+ png_ptr->background.green =
+ png_ptr->palette[png_ptr->background.index].green;
+ png_ptr->background.blue =
+ png_ptr->palette[png_ptr->background.index].blue;
+
+#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
+ if (png_ptr->transformations & PNG_INVERT_ALPHA)
+ {
+#if defined(PNG_READ_EXPAND_SUPPORTED)
+ if (!(png_ptr->transformations & PNG_EXPAND_tRNS))
+#endif
+ {
+ /* invert the alpha channel (in tRNS) unless the pixels are
+ going to be expanded, in which case leave it for later */
+ int i, istop;
+ istop=(int)png_ptr->num_trans;
+ for (i=0; i<istop; i++)
+ png_ptr->trans[i] = (png_byte)(255 - png_ptr->trans[i]);
+ }
+ }
+#endif
+
+ }
+ }
+#endif
+
+#if defined(PNG_READ_BACKGROUND_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED)
+ png_ptr->background_1 = png_ptr->background;
+#endif
+#if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)
+
+ if ((color_type == PNG_COLOR_TYPE_PALETTE && png_ptr->num_trans != 0)
+ && (fabs(png_ptr->screen_gamma * png_ptr->gamma - 1.0)
+ < PNG_GAMMA_THRESHOLD))
+ {
+ int i, k;
+ k=0;
+ for (i=0; i<png_ptr->num_trans; i++)
+ {
+ if (png_ptr->trans[i] != 0 && png_ptr->trans[i] != 0xff)
+ k=1; /* partial transparency is present */
+ }
+ if (k == 0)
+ png_ptr->transformations &= ~PNG_GAMMA;
+ }
+
+ if ((png_ptr->transformations & (PNG_GAMMA | PNG_RGB_TO_GRAY)) &&
+ png_ptr->gamma != 0.0)
+ {
+ png_build_gamma_table(png_ptr);
+#if defined(PNG_READ_BACKGROUND_SUPPORTED)
+ if (png_ptr->transformations & PNG_BACKGROUND)
+ {
+ if (color_type == PNG_COLOR_TYPE_PALETTE)
+ {
+ /* could skip if no transparency and
+ */
+ png_color back, back_1;
+ png_colorp palette = png_ptr->palette;
+ int num_palette = png_ptr->num_palette;
+ int i;
+ if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE)
+ {
+ back.red = png_ptr->gamma_table[png_ptr->background.red];
+ back.green = png_ptr->gamma_table[png_ptr->background.green];
+ back.blue = png_ptr->gamma_table[png_ptr->background.blue];
+
+ back_1.red = png_ptr->gamma_to_1[png_ptr->background.red];
+ back_1.green = png_ptr->gamma_to_1[png_ptr->background.green];
+ back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue];
+ }
+ else
+ {
+ double g, gs;
+
+ switch (png_ptr->background_gamma_type)
+ {
+ case PNG_BACKGROUND_GAMMA_SCREEN:
+ g = (png_ptr->screen_gamma);
+ gs = 1.0;
+ break;
+ case PNG_BACKGROUND_GAMMA_FILE:
+ g = 1.0 / (png_ptr->gamma);
+ gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
+ break;
+ case PNG_BACKGROUND_GAMMA_UNIQUE:
+ g = 1.0 / (png_ptr->background_gamma);
+ gs = 1.0 / (png_ptr->background_gamma *
+ png_ptr->screen_gamma);
+ break;
+ default:
+ g = 1.0; /* back_1 */
+ gs = 1.0; /* back */
+ }
+
+ if ( fabs(gs - 1.0) < PNG_GAMMA_THRESHOLD)
+ {
+ back.red = (png_byte)png_ptr->background.red;
+ back.green = (png_byte)png_ptr->background.green;
+ back.blue = (png_byte)png_ptr->background.blue;
+ }
+ else
+ {
+ back.red = (png_byte)(pow(
+ (double)png_ptr->background.red/255, gs) * 255.0 + .5);
+ back.green = (png_byte)(pow(
+ (double)png_ptr->background.green/255, gs) * 255.0 + .5);
+ back.blue = (png_byte)(pow(
+ (double)png_ptr->background.blue/255, gs) * 255.0 + .5);
+ }
+
+ back_1.red = (png_byte)(pow(
+ (double)png_ptr->background.red/255, g) * 255.0 + .5);
+ back_1.green = (png_byte)(pow(
+ (double)png_ptr->background.green/255, g) * 255.0 + .5);
+ back_1.blue = (png_byte)(pow(
+ (double)png_ptr->background.blue/255, g) * 255.0 + .5);
+ }
+ for (i = 0; i < num_palette; i++)
+ {
+ if (i < (int)png_ptr->num_trans && png_ptr->trans[i] != 0xff)
+ {
+ if (png_ptr->trans[i] == 0)
+ {
+ palette[i] = back;
+ }
+ else /* if (png_ptr->trans[i] != 0xff) */
+ {
+ png_byte v, w;
+
+ v = png_ptr->gamma_to_1[palette[i].red];
+ png_composite(w, v, png_ptr->trans[i], back_1.red);
+ palette[i].red = png_ptr->gamma_from_1[w];
+
+ v = png_ptr->gamma_to_1[palette[i].green];
+ png_composite(w, v, png_ptr->trans[i], back_1.green);
+ palette[i].green = png_ptr->gamma_from_1[w];
+
+ v = png_ptr->gamma_to_1[palette[i].blue];
+ png_composite(w, v, png_ptr->trans[i], back_1.blue);
+ palette[i].blue = png_ptr->gamma_from_1[w];
+ }
+ }
+ else
+ {
+ palette[i].red = png_ptr->gamma_table[palette[i].red];
+ palette[i].green = png_ptr->gamma_table[palette[i].green];
+ palette[i].blue = png_ptr->gamma_table[palette[i].blue];
+ }
+ }
+ /* Prevent the transformations being done again, and make sure
+ * that the now spurious alpha channel is stripped - the code
+ * has just reduced background composition and gamma correction
+ * to a simple alpha channel strip.
+ */
+ png_ptr->transformations &= ~PNG_BACKGROUND;
+ png_ptr->transformations &= ~PNG_GAMMA;
+ png_ptr->transformations |= PNG_STRIP_ALPHA;
+ }
+ /* if (png_ptr->background_gamma_type!=PNG_BACKGROUND_GAMMA_UNKNOWN) */
+ else
+ /* color_type != PNG_COLOR_TYPE_PALETTE */
+ {
+ double m = (double)(((png_uint_32)1 << png_ptr->bit_depth) - 1);
+ double g = 1.0;
+ double gs = 1.0;
+
+ switch (png_ptr->background_gamma_type)
+ {
+ case PNG_BACKGROUND_GAMMA_SCREEN:
+ g = (png_ptr->screen_gamma);
+ gs = 1.0;
+ break;
+ case PNG_BACKGROUND_GAMMA_FILE:
+ g = 1.0 / (png_ptr->gamma);
+ gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
+ break;
+ case PNG_BACKGROUND_GAMMA_UNIQUE:
+ g = 1.0 / (png_ptr->background_gamma);
+ gs = 1.0 / (png_ptr->background_gamma *
+ png_ptr->screen_gamma);
+ break;
+ }
+
+ png_ptr->background_1.gray = (png_uint_16)(pow(
+ (double)png_ptr->background.gray / m, g) * m + .5);
+ png_ptr->background.gray = (png_uint_16)(pow(
+ (double)png_ptr->background.gray / m, gs) * m + .5);
+
+ if ((png_ptr->background.red != png_ptr->background.green) ||
+ (png_ptr->background.red != png_ptr->background.blue) ||
+ (png_ptr->background.red != png_ptr->background.gray))
+ {
+ /* RGB or RGBA with color background */
+ png_ptr->background_1.red = (png_uint_16)(pow(
+ (double)png_ptr->background.red / m, g) * m + .5);
+ png_ptr->background_1.green = (png_uint_16)(pow(
+ (double)png_ptr->background.green / m, g) * m + .5);
+ png_ptr->background_1.blue = (png_uint_16)(pow(
+ (double)png_ptr->background.blue / m, g) * m + .5);
+ png_ptr->background.red = (png_uint_16)(pow(
+ (double)png_ptr->background.red / m, gs) * m + .5);
+ png_ptr->background.green = (png_uint_16)(pow(
+ (double)png_ptr->background.green / m, gs) * m + .5);
+ png_ptr->background.blue = (png_uint_16)(pow(
+ (double)png_ptr->background.blue / m, gs) * m + .5);
+ }
+ else
+ {
+ /* GRAY, GRAY ALPHA, RGB, or RGBA with gray background */
+ png_ptr->background_1.red = png_ptr->background_1.green
+ = png_ptr->background_1.blue = png_ptr->background_1.gray;
+ png_ptr->background.red = png_ptr->background.green
+ = png_ptr->background.blue = png_ptr->background.gray;
+ }
+ }
+ }
+ else
+ /* transformation does not include PNG_BACKGROUND */
+#endif /* PNG_READ_BACKGROUND_SUPPORTED */
+ if (color_type == PNG_COLOR_TYPE_PALETTE)
+ {
+ png_colorp palette = png_ptr->palette;
+ int num_palette = png_ptr->num_palette;
+ int i;
+
+ for (i = 0; i < num_palette; i++)
+ {
+ palette[i].red = png_ptr->gamma_table[palette[i].red];
+ palette[i].green = png_ptr->gamma_table[palette[i].green];
+ palette[i].blue = png_ptr->gamma_table[palette[i].blue];
+ }
+
+ /* Done the gamma correction. */
+ png_ptr->transformations &= ~PNG_GAMMA;
+ }
+ }
+#if defined(PNG_READ_BACKGROUND_SUPPORTED)
+ else
+#endif
+#endif /* PNG_READ_GAMMA_SUPPORTED && PNG_FLOATING_POINT_SUPPORTED */
+#if defined(PNG_READ_BACKGROUND_SUPPORTED)
+ /* No GAMMA transformation */
+ if ((png_ptr->transformations & PNG_BACKGROUND) &&
+ (color_type == PNG_COLOR_TYPE_PALETTE))
+ {
+ int i;
+ int istop = (int)png_ptr->num_trans;
+ png_color back;
+ png_colorp palette = png_ptr->palette;
+
+ back.red = (png_byte)png_ptr->background.red;
+ back.green = (png_byte)png_ptr->background.green;
+ back.blue = (png_byte)png_ptr->background.blue;
+
+ for (i = 0; i < istop; i++)
+ {
+ if (png_ptr->trans[i] == 0)
+ {
+ palette[i] = back;
+ }
+ else if (png_ptr->trans[i] != 0xff)
+ {
+ /* The png_composite() macro is defined in png.h */
+ png_composite(palette[i].red, palette[i].red,
+ png_ptr->trans[i], back.red);
+ png_composite(palette[i].green, palette[i].green,
+ png_ptr->trans[i], back.green);
+ png_composite(palette[i].blue, palette[i].blue,
+ png_ptr->trans[i], back.blue);
+ }
+ }
+
+ /* Handled alpha, still need to strip the channel. */
+ png_ptr->transformations &= ~PNG_BACKGROUND;
+ png_ptr->transformations |= PNG_STRIP_ALPHA;
+ }
+#endif /* PNG_READ_BACKGROUND_SUPPORTED */
+
+#if defined(PNG_READ_SHIFT_SUPPORTED)
+ if ((png_ptr->transformations & PNG_SHIFT) &&
+ (color_type == PNG_COLOR_TYPE_PALETTE))
+ {
+ png_uint_16 i;
+ png_uint_16 istop = png_ptr->num_palette;
+ int sr = 8 - png_ptr->sig_bit.red;
+ int sg = 8 - png_ptr->sig_bit.green;
+ int sb = 8 - png_ptr->sig_bit.blue;
+
+ if (sr < 0 || sr > 8)
+ sr = 0;
+ if (sg < 0 || sg > 8)
+ sg = 0;
+ if (sb < 0 || sb > 8)
+ sb = 0;
+ for (i = 0; i < istop; i++)
+ {
+ png_ptr->palette[i].red >>= sr;
+ png_ptr->palette[i].green >>= sg;
+ png_ptr->palette[i].blue >>= sb;
+ }
+ }
+#endif /* PNG_READ_SHIFT_SUPPORTED */
+ }
+#if !defined(PNG_READ_GAMMA_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED) \
+ && !defined(PNG_READ_BACKGROUND_SUPPORTED)
+ if (png_ptr)
+ return;
+#endif
+}
+
+/* Modify the info structure to reflect the transformations. The
+ * info should be updated so a PNG file could be written with it,
+ * assuming the transformations result in valid PNG data.
+ */
+void /* PRIVATE */
+png_read_transform_info(png_structp png_ptr, png_infop info_ptr)
+{
+ png_debug(1, "in png_read_transform_info\n");
+#if defined(PNG_READ_EXPAND_SUPPORTED)
+ if (png_ptr->transformations & PNG_EXPAND)
+ {
+ if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+ {
+ if (png_ptr->num_trans &&
+ (png_ptr->transformations & PNG_EXPAND_tRNS))
+ info_ptr->color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+ else
+ info_ptr->color_type = PNG_COLOR_TYPE_RGB;
+ info_ptr->bit_depth = 8;
+ info_ptr->num_trans = 0;
+ }
+ else
+ {
+ if (png_ptr->num_trans)
+ {
+ if (png_ptr->transformations & PNG_EXPAND_tRNS)
+ info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;
+#if 0 /* Removed from libpng-1.2.27 */
+ else
+ info_ptr->color_type |= PNG_COLOR_MASK_COLOR;
+#endif
+ }
+ if (info_ptr->bit_depth < 8)
+ info_ptr->bit_depth = 8;
+ info_ptr->num_trans = 0;
+ }
+ }
+#endif
+
+#if defined(PNG_READ_BACKGROUND_SUPPORTED)
+ if (png_ptr->transformations & PNG_BACKGROUND)
+ {
+ info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA;
+ info_ptr->num_trans = 0;
+ info_ptr->background = png_ptr->background;
+ }
+#endif
+
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+ if (png_ptr->transformations & PNG_GAMMA)
+ {
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+ info_ptr->gamma = png_ptr->gamma;
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+ info_ptr->int_gamma = png_ptr->int_gamma;
+#endif
+ }
+#endif
+
+#if defined(PNG_READ_16_TO_8_SUPPORTED)
+ if ((png_ptr->transformations & PNG_16_TO_8) && (info_ptr->bit_depth == 16))
+ info_ptr->bit_depth = 8;
+#endif
+
+#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
+ if (png_ptr->transformations & PNG_GRAY_TO_RGB)
+ info_ptr->color_type |= PNG_COLOR_MASK_COLOR;
+#endif
+
+#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
+ if (png_ptr->transformations & PNG_RGB_TO_GRAY)
+ info_ptr->color_type &= ~PNG_COLOR_MASK_COLOR;
+#endif
+
+#if defined(PNG_READ_DITHER_SUPPORTED)
+ if (png_ptr->transformations & PNG_DITHER)
+ {
+ if (((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||
+ (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)) &&
+ png_ptr->palette_lookup && info_ptr->bit_depth == 8)
+ {
+ info_ptr->color_type = PNG_COLOR_TYPE_PALETTE;
+ }
+ }
+#endif
+
+#if defined(PNG_READ_PACK_SUPPORTED)
+ if ((png_ptr->transformations & PNG_PACK) && (info_ptr->bit_depth < 8))
+ info_ptr->bit_depth = 8;
+#endif
+
+ if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+ info_ptr->channels = 1;
+ else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR)
+ info_ptr->channels = 3;
+ else
+ info_ptr->channels = 1;
+
+#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
+ if (png_ptr->flags & PNG_FLAG_STRIP_ALPHA)
+ info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA;
+#endif
+
+ if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)
+ info_ptr->channels++;
+
+#if defined(PNG_READ_FILLER_SUPPORTED)
+ /* STRIP_ALPHA and FILLER allowed: MASK_ALPHA bit stripped above */
+ if ((png_ptr->transformations & PNG_FILLER) &&
+ ((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||
+ (info_ptr->color_type == PNG_COLOR_TYPE_GRAY)))
+ {
+ info_ptr->channels++;
+ /* if adding a true alpha channel not just filler */
+#if !defined(PNG_1_0_X)
+ if (png_ptr->transformations & PNG_ADD_ALPHA)
+ info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;
+#endif
+ }
+#endif
+
+#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) && \
+defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
+ if (png_ptr->transformations & PNG_USER_TRANSFORM)
+ {
+ if (info_ptr->bit_depth < png_ptr->user_transform_depth)
+ info_ptr->bit_depth = png_ptr->user_transform_depth;
+ if (info_ptr->channels < png_ptr->user_transform_channels)
+ info_ptr->channels = png_ptr->user_transform_channels;
+ }
+#endif
+
+ info_ptr->pixel_depth = (png_byte)(info_ptr->channels *
+ info_ptr->bit_depth);
+
+ info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, info_ptr->width);
+
+#if !defined(PNG_READ_EXPAND_SUPPORTED)
+ if (png_ptr)
+ return;
+#endif
+}
+
+/* Transform the row. The order of transformations is significant,
+ * and is very touchy. If you add a transformation, take care to
+ * decide how it fits in with the other transformations here.
+ */
+void /* PRIVATE */
+png_do_read_transformations(png_structp png_ptr)
+{
+ png_debug(1, "in png_do_read_transformations\n");
+ if (png_ptr->row_buf == NULL)
+ {
+#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)
+ char msg[50];
+
+ png_snprintf2(msg, 50,
+ "NULL row buffer for row %ld, pass %d", (long)png_ptr->row_number,
+ png_ptr->pass);
+ png_error(png_ptr, msg);
+#else
+ png_error(png_ptr, "NULL row buffer");
+#endif
+ }
+#ifdef PNG_WARN_UNINITIALIZED_ROW
+ if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
+ /* Application has failed to call either png_read_start_image()
+ * or png_read_update_info() after setting transforms that expand
+ * pixels. This check added to libpng-1.2.19 */
+#if (PNG_WARN_UNINITIALIZED_ROW==1)
+ png_error(png_ptr, "Uninitialized row");
+#else
+ png_warning(png_ptr, "Uninitialized row");
+#endif
+#endif
+
+#if defined(PNG_READ_EXPAND_SUPPORTED)
+ if (png_ptr->transformations & PNG_EXPAND)
+ {
+ if (png_ptr->row_info.color_type == PNG_COLOR_TYPE_PALETTE)
+ {
+ png_do_expand_palette(&(png_ptr->row_info), png_ptr->row_buf + 1,
+ png_ptr->palette, png_ptr->trans, png_ptr->num_trans);
+ }
+ else
+ {
+ if (png_ptr->num_trans &&
+ (png_ptr->transformations & PNG_EXPAND_tRNS))
+ png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,
+ &(png_ptr->trans_values));
+ else
+ png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,
+ NULL);
+ }
+ }
+#endif
+
+#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
+ if (png_ptr->flags & PNG_FLAG_STRIP_ALPHA)
+ png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,
+ PNG_FLAG_FILLER_AFTER | (png_ptr->flags & PNG_FLAG_STRIP_ALPHA));
+#endif
+
+#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
+ if (png_ptr->transformations & PNG_RGB_TO_GRAY)
+ {
+ int rgb_error =
+ png_do_rgb_to_gray(png_ptr, &(png_ptr->row_info), png_ptr->row_buf + 1);
+ if (rgb_error)
+ {
+ png_ptr->rgb_to_gray_status=1;
+ if ((png_ptr->transformations & PNG_RGB_TO_GRAY) ==
+ PNG_RGB_TO_GRAY_WARN)
+ png_warning(png_ptr, "png_do_rgb_to_gray found nongray pixel");
+ if ((png_ptr->transformations & PNG_RGB_TO_GRAY) ==
+ PNG_RGB_TO_GRAY_ERR)
+ png_error(png_ptr, "png_do_rgb_to_gray found nongray pixel");
+ }
+ }
+#endif
+
+/*
+From Andreas Dilger e-mail to png-implement, 26 March 1998:
+
+ In most cases, the "simple transparency" should be done prior to doing
+ gray-to-RGB, or you will have to test 3x as many bytes to check if a
+ pixel is transparent. You would also need to make sure that the
+ transparency information is upgraded to RGB.
+
+ To summarize, the current flow is:
+ - Gray + simple transparency -> compare 1 or 2 gray bytes and composite
+ with background "in place" if transparent,
+ convert to RGB if necessary
+ - Gray + alpha -> composite with gray background and remove alpha bytes,
+ convert to RGB if necessary
+
+ To support RGB backgrounds for gray images we need:
+ - Gray + simple transparency -> convert to RGB + simple transparency, compare
+ 3 or 6 bytes and composite with background
+ "in place" if transparent (3x compare/pixel
+ compared to doing composite with gray bkgrnd)
+ - Gray + alpha -> convert to RGB + alpha, composite with background and
+ remove alpha bytes (3x float operations/pixel
+ compared with composite on gray background)
+
+ Greg's change will do this. The reason it wasn't done before is for
+ performance, as this increases the per-pixel operations. If we would check
+ in advance if the background was gray or RGB, and position the gray-to-RGB
+ transform appropriately, then it would save a lot of work/time.
+ */
+
+#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
+ /* if gray -> RGB, do so now only if background is non-gray; else do later
+ * for performance reasons */
+ if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&
+ !(png_ptr->mode & PNG_BACKGROUND_IS_GRAY))
+ png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+
+#if defined(PNG_READ_BACKGROUND_SUPPORTED)
+ if ((png_ptr->transformations & PNG_BACKGROUND) &&
+ ((png_ptr->num_trans != 0 ) ||
+ (png_ptr->color_type & PNG_COLOR_MASK_ALPHA)))
+ png_do_background(&(png_ptr->row_info), png_ptr->row_buf + 1,
+ &(png_ptr->trans_values), &(png_ptr->background)
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+ , &(png_ptr->background_1),
+ png_ptr->gamma_table, png_ptr->gamma_from_1,
+ png_ptr->gamma_to_1, png_ptr->gamma_16_table,
+ png_ptr->gamma_16_from_1, png_ptr->gamma_16_to_1,
+ png_ptr->gamma_shift
+#endif
+);
+#endif
+
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+ if ((png_ptr->transformations & PNG_GAMMA) &&
+#if defined(PNG_READ_BACKGROUND_SUPPORTED)
+ !((png_ptr->transformations & PNG_BACKGROUND) &&
+ ((png_ptr->num_trans != 0) ||
+ (png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) &&
+#endif
+ (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE))
+ png_do_gamma(&(png_ptr->row_info), png_ptr->row_buf + 1,
+ png_ptr->gamma_table, png_ptr->gamma_16_table,
+ png_ptr->gamma_shift);
+#endif
+
+#if defined(PNG_READ_16_TO_8_SUPPORTED)
+ if (png_ptr->transformations & PNG_16_TO_8)
+ png_do_chop(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+
+#if defined(PNG_READ_DITHER_SUPPORTED)
+ if (png_ptr->transformations & PNG_DITHER)
+ {
+ png_do_dither((png_row_infop)&(png_ptr->row_info), png_ptr->row_buf + 1,
+ png_ptr->palette_lookup, png_ptr->dither_index);
+ if (png_ptr->row_info.rowbytes == (png_uint_32)0)
+ png_error(png_ptr, "png_do_dither returned rowbytes=0");
+ }
+#endif
+
+#if defined(PNG_READ_INVERT_SUPPORTED)
+ if (png_ptr->transformations & PNG_INVERT_MONO)
+ png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+
+#if defined(PNG_READ_SHIFT_SUPPORTED)
+ if (png_ptr->transformations & PNG_SHIFT)
+ png_do_unshift(&(png_ptr->row_info), png_ptr->row_buf + 1,
+ &(png_ptr->shift));
+#endif
+
+#if defined(PNG_READ_PACK_SUPPORTED)
+ if (png_ptr->transformations & PNG_PACK)
+ png_do_unpack(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+
+#if defined(PNG_READ_BGR_SUPPORTED)
+ if (png_ptr->transformations & PNG_BGR)
+ png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+
+#if defined(PNG_READ_PACKSWAP_SUPPORTED)
+ if (png_ptr->transformations & PNG_PACKSWAP)
+ png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+
+#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
+ /* if gray -> RGB, do so now only if we did not do so above */
+ if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&
+ (png_ptr->mode & PNG_BACKGROUND_IS_GRAY))
+ png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+
+#if defined(PNG_READ_FILLER_SUPPORTED)
+ if (png_ptr->transformations & PNG_FILLER)
+ png_do_read_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,
+ (png_uint_32)png_ptr->filler, png_ptr->flags);
+#endif
+
+#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
+ if (png_ptr->transformations & PNG_INVERT_ALPHA)
+ png_do_read_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+
+#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)
+ if (png_ptr->transformations & PNG_SWAP_ALPHA)
+ png_do_read_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+
+#if defined(PNG_READ_SWAP_SUPPORTED)
+ if (png_ptr->transformations & PNG_SWAP_BYTES)
+ png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
+ if (png_ptr->transformations & PNG_USER_TRANSFORM)
+ {
+ if (png_ptr->read_user_transform_fn != NULL)
+ (*(png_ptr->read_user_transform_fn)) /* user read transform function */
+ (png_ptr, /* png_ptr */
+ &(png_ptr->row_info), /* row_info: */
+ /* png_uint_32 width; width of row */
+ /* png_uint_32 rowbytes; number of bytes in row */
+ /* png_byte color_type; color type of pixels */
+ /* png_byte bit_depth; bit depth of samples */
+ /* png_byte channels; number of channels (1-4) */
+ /* png_byte pixel_depth; bits per pixel (depth*channels) */
+ png_ptr->row_buf + 1); /* start of pixel data for row */
+#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
+ if (png_ptr->user_transform_depth)
+ png_ptr->row_info.bit_depth = png_ptr->user_transform_depth;
+ if (png_ptr->user_transform_channels)
+ png_ptr->row_info.channels = png_ptr->user_transform_channels;
+#endif
+ png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *
+ png_ptr->row_info.channels);
+ png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,
+ png_ptr->row_info.width);
+ }
+#endif
+
+}
+
+#if defined(PNG_READ_PACK_SUPPORTED)
+/* Unpack pixels of 1, 2, or 4 bits per pixel into 1 byte per pixel,
+ * without changing the actual values. Thus, if you had a row with
+ * a bit depth of 1, you would end up with bytes that only contained
+ * the numbers 0 or 1. If you would rather they contain 0 and 255, use
+ * png_do_shift() after this.
+ */
+void /* PRIVATE */
+png_do_unpack(png_row_infop row_info, png_bytep row)
+{
+ png_debug(1, "in png_do_unpack\n");
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+ if (row != NULL && row_info != NULL && row_info->bit_depth < 8)
+#else
+ if (row_info->bit_depth < 8)
+#endif
+ {
+ png_uint_32 i;
+ png_uint_32 row_width=row_info->width;
+
+ switch (row_info->bit_depth)
+ {
+ case 1:
+ {
+ png_bytep sp = row + (png_size_t)((row_width - 1) >> 3);
+ png_bytep dp = row + (png_size_t)row_width - 1;
+ png_uint_32 shift = 7 - (int)((row_width + 7) & 0x07);
+ for (i = 0; i < row_width; i++)
+ {
+ *dp = (png_byte)((*sp >> shift) & 0x01);
+ if (shift == 7)
+ {
+ shift = 0;
+ sp--;
+ }
+ else
+ shift++;
+
+ dp--;
+ }
+ break;
+ }
+ case 2:
+ {
+
+ png_bytep sp = row + (png_size_t)((row_width - 1) >> 2);
+ png_bytep dp = row + (png_size_t)row_width - 1;
+ png_uint_32 shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);
+ for (i = 0; i < row_width; i++)
+ {
+ *dp = (png_byte)((*sp >> shift) & 0x03);
+ if (shift == 6)
+ {
+ shift = 0;
+ sp--;
+ }
+ else
+ shift += 2;
+
+ dp--;
+ }
+ break;
+ }
+ case 4:
+ {
+ png_bytep sp = row + (png_size_t)((row_width - 1) >> 1);
+ png_bytep dp = row + (png_size_t)row_width - 1;
+ png_uint_32 shift = (int)((1 - ((row_width + 1) & 0x01)) << 2);
+ for (i = 0; i < row_width; i++)
+ {
+ *dp = (png_byte)((*sp >> shift) & 0x0f);
+ if (shift == 4)
+ {
+ shift = 0;
+ sp--;
+ }
+ else
+ shift = 4;
+
+ dp--;
+ }
+ break;
+ }
+ }
+ row_info->bit_depth = 8;
+ row_info->pixel_depth = (png_byte)(8 * row_info->channels);
+ row_info->rowbytes = row_width * row_info->channels;
+ }
+}
+#endif
+
+#if defined(PNG_READ_SHIFT_SUPPORTED)
+/* Reverse the effects of png_do_shift. This routine merely shifts the
+ * pixels back to their significant bits values. Thus, if you have
+ * a row of bit depth 8, but only 5 are significant, this will shift
+ * the values back to 0 through 31.
+ */
+void /* PRIVATE */
+png_do_unshift(png_row_infop row_info, png_bytep row, png_color_8p sig_bits)
+{
+ png_debug(1, "in png_do_unshift\n");
+ if (
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+ row != NULL && row_info != NULL && sig_bits != NULL &&
+#endif
+ row_info->color_type != PNG_COLOR_TYPE_PALETTE)
+ {
+ int shift[4];
+ int channels = 0;
+ int c;
+ png_uint_16 value = 0;
+ png_uint_32 row_width = row_info->width;
+
+ if (row_info->color_type & PNG_COLOR_MASK_COLOR)
+ {
+ shift[channels++] = row_info->bit_depth - sig_bits->red;
+ shift[channels++] = row_info->bit_depth - sig_bits->green;
+ shift[channels++] = row_info->bit_depth - sig_bits->blue;
+ }
+ else
+ {
+ shift[channels++] = row_info->bit_depth - sig_bits->gray;
+ }
+ if (row_info->color_type & PNG_COLOR_MASK_ALPHA)
+ {
+ shift[channels++] = row_info->bit_depth - sig_bits->alpha;
+ }
+
+ for (c = 0; c < channels; c++)
+ {
+ if (shift[c] <= 0)
+ shift[c] = 0;
+ else
+ value = 1;
+ }
+
+ if (!value)
+ return;
+
+ switch (row_info->bit_depth)
+ {
+ case 2:
+ {
+ png_bytep bp;
+ png_uint_32 i;
+ png_uint_32 istop = row_info->rowbytes;
+
+ for (bp = row, i = 0; i < istop; i++)
+ {
+ *bp >>= 1;
+ *bp++ &= 0x55;
+ }
+ break;
+ }
+ case 4:
+ {
+ png_bytep bp = row;
+ png_uint_32 i;
+ png_uint_32 istop = row_info->rowbytes;
+ png_byte mask = (png_byte)((((int)0xf0 >> shift[0]) & (int)0xf0) |
+ (png_byte)((int)0xf >> shift[0]));
+
+ for (i = 0; i < istop; i++)
+ {
+ *bp >>= shift[0];
+ *bp++ &= mask;
+ }
+ break;
+ }
+ case 8:
+ {
+ png_bytep bp = row;
+ png_uint_32 i;
+ png_uint_32 istop = row_width * channels;
+
+ for (i = 0; i < istop; i++)
+ {
+ *bp++ >>= shift[i%channels];
+ }
+ break;
+ }
+ case 16:
+ {
+ png_bytep bp = row;
+ png_uint_32 i;
+ png_uint_32 istop = channels * row_width;
+
+ for (i = 0; i < istop; i++)
+ {
+ value = (png_uint_16)((*bp << 8) + *(bp + 1));
+ value >>= shift[i%channels];
+ *bp++ = (png_byte)(value >> 8);
+ *bp++ = (png_byte)(value & 0xff);
+ }
+ break;
+ }
+ }
+ }
+}
+#endif
+
+#if defined(PNG_READ_16_TO_8_SUPPORTED)
+/* chop rows of bit depth 16 down to 8 */
+void /* PRIVATE */
+png_do_chop(png_row_infop row_info, png_bytep row)
+{
+ png_debug(1, "in png_do_chop\n");
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+ if (row != NULL && row_info != NULL && row_info->bit_depth == 16)
+#else
+ if (row_info->bit_depth == 16)
+#endif
+ {
+ png_bytep sp = row;
+ png_bytep dp = row;
+ png_uint_32 i;
+ png_uint_32 istop = row_info->width * row_info->channels;
+
+ for (i = 0; i<istop; i++, sp += 2, dp++)
+ {
+#if defined(PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED)
+ /* This does a more accurate scaling of the 16-bit color
+ * value, rather than a simple low-byte truncation.
+ *
+ * What the ideal calculation should be:
+ * *dp = (((((png_uint_32)(*sp) << 8) |
+ * (png_uint_32)(*(sp + 1))) * 255 + 127) / (png_uint_32)65535L;
+ *
+ * GRR: no, I think this is what it really should be:
+ * *dp = (((((png_uint_32)(*sp) << 8) |
+ * (png_uint_32)(*(sp + 1))) + 128L) / (png_uint_32)257L;
+ *
+ * GRR: here's the exact calculation with shifts:
+ * temp = (((png_uint_32)(*sp) << 8) | (png_uint_32)(*(sp + 1))) + 128L;
+ * *dp = (temp - (temp >> 8)) >> 8;
+ *
+ * Approximate calculation with shift/add instead of multiply/divide:
+ * *dp = ((((png_uint_32)(*sp) << 8) |
+ * (png_uint_32)((int)(*(sp + 1)) - *sp)) + 128) >> 8;
+ *
+ * What we actually do to avoid extra shifting and conversion:
+ */
+
+ *dp = *sp + ((((int)(*(sp + 1)) - *sp) > 128) ? 1 : 0);
+#else
+ /* Simply discard the low order byte */
+ *dp = *sp;
+#endif
+ }
+ row_info->bit_depth = 8;
+ row_info->pixel_depth = (png_byte)(8 * row_info->channels);
+ row_info->rowbytes = row_info->width * row_info->channels;
+ }
+}
+#endif
+
+#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)
+void /* PRIVATE */
+png_do_read_swap_alpha(png_row_infop row_info, png_bytep row)
+{
+ png_debug(1, "in png_do_read_swap_alpha\n");
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+ if (row != NULL && row_info != NULL)
+#endif
+ {
+ png_uint_32 row_width = row_info->width;
+ if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+ {
+ /* This converts from RGBA to ARGB */
+ if (row_info->bit_depth == 8)
+ {
+ png_bytep sp = row + row_info->rowbytes;
+ png_bytep dp = sp;
+ png_byte save;
+ png_uint_32 i;
+
+ for (i = 0; i < row_width; i++)
+ {
+ save = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = save;
+ }
+ }
+ /* This converts from RRGGBBAA to AARRGGBB */
+ else
+ {
+ png_bytep sp = row + row_info->rowbytes;
+ png_bytep dp = sp;
+ png_byte save[2];
+ png_uint_32 i;
+
+ for (i = 0; i < row_width; i++)
+ {
+ save[0] = *(--sp);
+ save[1] = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = save[0];
+ *(--dp) = save[1];
+ }
+ }
+ }
+ else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+ {
+ /* This converts from GA to AG */
+ if (row_info->bit_depth == 8)
+ {
+ png_bytep sp = row + row_info->rowbytes;
+ png_bytep dp = sp;
+ png_byte save;
+ png_uint_32 i;
+
+ for (i = 0; i < row_width; i++)
+ {
+ save = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = save;
+ }
+ }
+ /* This converts from GGAA to AAGG */
+ else
+ {
+ png_bytep sp = row + row_info->rowbytes;
+ png_bytep dp = sp;
+ png_byte save[2];
+ png_uint_32 i;
+
+ for (i = 0; i < row_width; i++)
+ {
+ save[0] = *(--sp);
+ save[1] = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = save[0];
+ *(--dp) = save[1];
+ }
+ }
+ }
+ }
+}
+#endif
+
+#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
+void /* PRIVATE */
+png_do_read_invert_alpha(png_row_infop row_info, png_bytep row)
+{
+ png_debug(1, "in png_do_read_invert_alpha\n");
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+ if (row != NULL && row_info != NULL)
+#endif
+ {
+ png_uint_32 row_width = row_info->width;
+ if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+ {
+ /* This inverts the alpha channel in RGBA */
+ if (row_info->bit_depth == 8)
+ {
+ png_bytep sp = row + row_info->rowbytes;
+ png_bytep dp = sp;
+ png_uint_32 i;
+
+ for (i = 0; i < row_width; i++)
+ {
+ *(--dp) = (png_byte)(255 - *(--sp));
+
+/* This does nothing:
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ We can replace it with:
+*/
+ sp-=3;
+ dp=sp;
+ }
+ }
+ /* This inverts the alpha channel in RRGGBBAA */
+ else
+ {
+ png_bytep sp = row + row_info->rowbytes;
+ png_bytep dp = sp;
+ png_uint_32 i;
+
+ for (i = 0; i < row_width; i++)
+ {
+ *(--dp) = (png_byte)(255 - *(--sp));
+ *(--dp) = (png_byte)(255 - *(--sp));
+
+/* This does nothing:
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ We can replace it with:
+*/
+ sp-=6;
+ dp=sp;
+ }
+ }
+ }
+ else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+ {
+ /* This inverts the alpha channel in GA */
+ if (row_info->bit_depth == 8)
+ {
+ png_bytep sp = row + row_info->rowbytes;
+ png_bytep dp = sp;
+ png_uint_32 i;
+
+ for (i = 0; i < row_width; i++)
+ {
+ *(--dp) = (png_byte)(255 - *(--sp));
+ *(--dp) = *(--sp);
+ }
+ }
+ /* This inverts the alpha channel in GGAA */
+ else
+ {
+ png_bytep sp = row + row_info->rowbytes;
+ png_bytep dp = sp;
+ png_uint_32 i;
+
+ for (i = 0; i < row_width; i++)
+ {
+ *(--dp) = (png_byte)(255 - *(--sp));
+ *(--dp) = (png_byte)(255 - *(--sp));
+/*
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+*/
+ sp-=2;
+ dp=sp;
+ }
+ }
+ }
+ }
+}
+#endif
+
+#if defined(PNG_READ_FILLER_SUPPORTED)
+/* Add filler channel if we have RGB color */
+void /* PRIVATE */
+png_do_read_filler(png_row_infop row_info, png_bytep row,
+ png_uint_32 filler, png_uint_32 flags)
+{
+ png_uint_32 i;
+ png_uint_32 row_width = row_info->width;
+
+ png_byte hi_filler = (png_byte)((filler>>8) & 0xff);
+ png_byte lo_filler = (png_byte)(filler & 0xff);
+
+ png_debug(1, "in png_do_read_filler\n");
+ if (
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+ row != NULL && row_info != NULL &&
+#endif
+ row_info->color_type == PNG_COLOR_TYPE_GRAY)
+ {
+ if (row_info->bit_depth == 8)
+ {
+ /* This changes the data from G to GX */
+ if (flags & PNG_FLAG_FILLER_AFTER)
+ {
+ png_bytep sp = row + (png_size_t)row_width;
+ png_bytep dp = sp + (png_size_t)row_width;
+ for (i = 1; i < row_width; i++)
+ {
+ *(--dp) = lo_filler;
+ *(--dp) = *(--sp);
+ }
+ *(--dp) = lo_filler;
+ row_info->channels = 2;
+ row_info->pixel_depth = 16;
+ row_info->rowbytes = row_width * 2;
+ }
+ /* This changes the data from G to XG */
+ else
+ {
+ png_bytep sp = row + (png_size_t)row_width;
+ png_bytep dp = sp + (png_size_t)row_width;
+ for (i = 0; i < row_width; i++)
+ {
+ *(--dp) = *(--sp);
+ *(--dp) = lo_filler;
+ }
+ row_info->channels = 2;
+ row_info->pixel_depth = 16;
+ row_info->rowbytes = row_width * 2;
+ }
+ }
+ else if (row_info->bit_depth == 16)
+ {
+ /* This changes the data from GG to GGXX */
+ if (flags & PNG_FLAG_FILLER_AFTER)
+ {
+ png_bytep sp = row + (png_size_t)row_width * 2;
+ png_bytep dp = sp + (png_size_t)row_width * 2;
+ for (i = 1; i < row_width; i++)
+ {
+ *(--dp) = hi_filler;
+ *(--dp) = lo_filler;
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ }
+ *(--dp) = hi_filler;
+ *(--dp) = lo_filler;
+ row_info->channels = 2;
+ row_info->pixel_depth = 32;
+ row_info->rowbytes = row_width * 4;
+ }
+ /* This changes the data from GG to XXGG */
+ else
+ {
+ png_bytep sp = row + (png_size_t)row_width * 2;
+ png_bytep dp = sp + (png_size_t)row_width * 2;
+ for (i = 0; i < row_width; i++)
+ {
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = hi_filler;
+ *(--dp) = lo_filler;
+ }
+ row_info->channels = 2;
+ row_info->pixel_depth = 32;
+ row_info->rowbytes = row_width * 4;
+ }
+ }
+ } /* COLOR_TYPE == GRAY */
+ else if (row_info->color_type == PNG_COLOR_TYPE_RGB)
+ {
+ if (row_info->bit_depth == 8)
+ {
+ /* This changes the data from RGB to RGBX */
+ if (flags & PNG_FLAG_FILLER_AFTER)
+ {
+ png_bytep sp = row + (png_size_t)row_width * 3;
+ png_bytep dp = sp + (png_size_t)row_width;
+ for (i = 1; i < row_width; i++)
+ {
+ *(--dp) = lo_filler;
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ }
+ *(--dp) = lo_filler;
+ row_info->channels = 4;
+ row_info->pixel_depth = 32;
+ row_info->rowbytes = row_width * 4;
+ }
+ /* This changes the data from RGB to XRGB */
+ else
+ {
+ png_bytep sp = row + (png_size_t)row_width * 3;
+ png_bytep dp = sp + (png_size_t)row_width;
+ for (i = 0; i < row_width; i++)
+ {
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = lo_filler;
+ }
+ row_info->channels = 4;
+ row_info->pixel_depth = 32;
+ row_info->rowbytes = row_width * 4;
+ }
+ }
+ else if (row_info->bit_depth == 16)
+ {
+ /* This changes the data from RRGGBB to RRGGBBXX */
+ if (flags & PNG_FLAG_FILLER_AFTER)
+ {
+ png_bytep sp = row + (png_size_t)row_width * 6;
+ png_bytep dp = sp + (png_size_t)row_width * 2;
+ for (i = 1; i < row_width; i++)
+ {
+ *(--dp) = hi_filler;
+ *(--dp) = lo_filler;
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ }
+ *(--dp) = hi_filler;
+ *(--dp) = lo_filler;
+ row_info->channels = 4;
+ row_info->pixel_depth = 64;
+ row_info->rowbytes = row_width * 8;
+ }
+ /* This changes the data from RRGGBB to XXRRGGBB */
+ else
+ {
+ png_bytep sp = row + (png_size_t)row_width * 6;
+ png_bytep dp = sp + (png_size_t)row_width * 2;
+ for (i = 0; i < row_width; i++)
+ {
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = *(--sp);
+ *(--dp) = hi_filler;
+ *(--dp) = lo_filler;
+ }
+ row_info->channels = 4;
+ row_info->pixel_depth = 64;
+ row_info->rowbytes = row_width * 8;
+ }
+ }
+ } /* COLOR_TYPE == RGB */
+}
+#endif
+
+#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
+/* expand grayscale files to RGB, with or without alpha */
+void /* PRIVATE */
+png_do_gray_to_rgb(png_row_infop row_info, png_bytep row)
+{
+ png_uint_32 i;
+ png_uint_32 row_width = row_info->width;
+
+ png_debug(1, "in png_do_gray_to_rgb\n");
+ if (row_info->bit_depth >= 8 &&
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+ row != NULL && row_info != NULL &&
+#endif
+ !(row_info->color_type & PNG_COLOR_MASK_COLOR))
+ {
+ if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
+ {
+ if (row_info->bit_depth == 8)
+ {
+ png_bytep sp = row + (png_size_t)row_width - 1;
+ png_bytep dp = sp + (png_size_t)row_width * 2;
+ for (i = 0; i < row_width; i++)
+ {
+ *(dp--) = *sp;
+ *(dp--) = *sp;
+ *(dp--) = *(sp--);
+ }
+ }
+ else
+ {
+ png_bytep sp = row + (png_size_t)row_width * 2 - 1;
+ png_bytep dp = sp + (png_size_t)row_width * 4;
+ for (i = 0; i < row_width; i++)
+ {
+ *(dp--) = *sp;
+ *(dp--) = *(sp - 1);
+ *(dp--) = *sp;
+ *(dp--) = *(sp - 1);
+ *(dp--) = *(sp--);
+ *(dp--) = *(sp--);
+ }
+ }
+ }
+ else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+ {
+ if (row_info->bit_depth == 8)
+ {
+ png_bytep sp = row + (png_size_t)row_width * 2 - 1;
+ png_bytep dp = sp + (png_size_t)row_width * 2;
+ for (i = 0; i < row_width; i++)
+ {
+ *(dp--) = *(sp--);
+ *(dp--) = *sp;
+ *(dp--) = *sp;
+ *(dp--) = *(sp--);
+ }
+ }
+ else
+ {
+ png_bytep sp = row + (png_size_t)row_width * 4 - 1;
+ png_bytep dp = sp + (png_size_t)row_width * 4;
+ for (i = 0; i < row_width; i++)
+ {
+ *(dp--) = *(sp--);
+ *(dp--) = *(sp--);
+ *(dp--) = *sp;
+ *(dp--) = *(sp - 1);
+ *(dp--) = *sp;
+ *(dp--) = *(sp - 1);
+ *(dp--) = *(sp--);
+ *(dp--) = *(sp--);
+ }
+ }
+ }
+ row_info->channels += (png_byte)2;
+ row_info->color_type |= PNG_COLOR_MASK_COLOR;
+ row_info->pixel_depth = (png_byte)(row_info->channels *
+ row_info->bit_depth);
+ row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
+ }
+}
+#endif
+
+#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
+/* reduce RGB files to grayscale, with or without alpha
+ * using the equation given in Poynton's ColorFAQ at
+ * <http://www.inforamp.net/~poynton/> (THIS LINK IS DEAD June 2008)
+ * New link:
+ * <http://www.poynton.com/notes/colour_and_gamma/>
+ * Charles Poynton poynton at poynton.com
+ *
+ * Y = 0.212671 * R + 0.715160 * G + 0.072169 * B
+ *
+ * We approximate this with
+ *
+ * Y = 0.21268 * R + 0.7151 * G + 0.07217 * B
+ *
+ * which can be expressed with integers as
+ *
+ * Y = (6969 * R + 23434 * G + 2365 * B)/32768
+ *
+ * The calculation is to be done in a linear colorspace.
+ *
+ * Other integer coefficents can be used via png_set_rgb_to_gray().
+ */
+int /* PRIVATE */
+png_do_rgb_to_gray(png_structp png_ptr, png_row_infop row_info, png_bytep row)
+
+{
+ png_uint_32 i;
+
+ png_uint_32 row_width = row_info->width;
+ int rgb_error = 0;
+
+ png_debug(1, "in png_do_rgb_to_gray\n");
+ if (
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+ row != NULL && row_info != NULL &&
+#endif
+ (row_info->color_type & PNG_COLOR_MASK_COLOR))
+ {
+ png_uint_32 rc = png_ptr->rgb_to_gray_red_coeff;
+ png_uint_32 gc = png_ptr->rgb_to_gray_green_coeff;
+ png_uint_32 bc = png_ptr->rgb_to_gray_blue_coeff;
+
+ if (row_info->color_type == PNG_COLOR_TYPE_RGB)
+ {
+ if (row_info->bit_depth == 8)
+ {
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+ if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL)
+ {
+ png_bytep sp = row;
+ png_bytep dp = row;
+
+ for (i = 0; i < row_width; i++)
+ {
+ png_byte red = png_ptr->gamma_to_1[*(sp++)];
+ png_byte green = png_ptr->gamma_to_1[*(sp++)];
+ png_byte blue = png_ptr->gamma_to_1[*(sp++)];
+ if (red != green || red != blue)
+ {
+ rgb_error |= 1;
+ *(dp++) = png_ptr->gamma_from_1[
+ (rc*red + gc*green + bc*blue)>>15];
+ }
+ else
+ *(dp++) = *(sp - 1);
+ }
+ }
+ else
+#endif
+ {
+ png_bytep sp = row;
+ png_bytep dp = row;
+ for (i = 0; i < row_width; i++)
+ {
+ png_byte red = *(sp++);
+ png_byte green = *(sp++);
+ png_byte blue = *(sp++);
+ if (red != green || red != blue)
+ {
+ rgb_error |= 1;
+ *(dp++) = (png_byte)((rc*red + gc*green + bc*blue)>>15);
+ }
+ else
+ *(dp++) = *(sp - 1);
+ }
+ }
+ }
+
+ else /* RGB bit_depth == 16 */
+ {
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+ if (png_ptr->gamma_16_to_1 != NULL &&
+ png_ptr->gamma_16_from_1 != NULL)
+ {
+ png_bytep sp = row;
+ png_bytep dp = row;
+ for (i = 0; i < row_width; i++)
+ {
+ png_uint_16 red, green, blue, w;
+
+ red = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
+ green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
+ blue = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
+
+ if (red == green && red == blue)
+ w = red;
+ else
+ {
+ png_uint_16 red_1 = png_ptr->gamma_16_to_1[(red&0xff) >>
+ png_ptr->gamma_shift][red>>8];
+ png_uint_16 green_1 = png_ptr->gamma_16_to_1[(green&0xff) >>
+ png_ptr->gamma_shift][green>>8];
+ png_uint_16 blue_1 = png_ptr->gamma_16_to_1[(blue&0xff) >>
+ png_ptr->gamma_shift][blue>>8];
+ png_uint_16 gray16 = (png_uint_16)((rc*red_1 + gc*green_1
+ + bc*blue_1)>>15);
+ w = png_ptr->gamma_16_from_1[(gray16&0xff) >>
+ png_ptr->gamma_shift][gray16 >> 8];
+ rgb_error |= 1;
+ }
+
+ *(dp++) = (png_byte)((w>>8) & 0xff);
+ *(dp++) = (png_byte)(w & 0xff);
+ }
+ }
+ else
+#endif
+ {
+ png_bytep sp = row;
+ png_bytep dp = row;
+ for (i = 0; i < row_width; i++)
+ {
+ png_uint_16 red, green, blue, gray16;
+
+ red = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
+ green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
+ blue = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
+
+ if (red != green || red != blue)
+ rgb_error |= 1;
+ gray16 = (png_uint_16)((rc*red + gc*green + bc*blue)>>15);
+ *(dp++) = (png_byte)((gray16>>8) & 0xff);
+ *(dp++) = (png_byte)(gray16 & 0xff);
+ }
+ }
+ }
+ }
+ if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+ {
+ if (row_info->bit_depth == 8)
+ {
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+ if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL)
+ {
+ png_bytep sp = row;
+ png_bytep dp = row;
+ for (i = 0; i < row_width; i++)
+ {
+ png_byte red = png_ptr->gamma_to_1[*(sp++)];
+ png_byte green = png_ptr->gamma_to_1[*(sp++)];
+ png_byte blue = png_ptr->gamma_to_1[*(sp++)];
+ if (red != green || red != blue)
+ rgb_error |= 1;
+ *(dp++) = png_ptr->gamma_from_1
+ [(rc*red + gc*green + bc*blue)>>15];
+ *(dp++) = *(sp++); /* alpha */
+ }
+ }
+ else
+#endif
+ {
+ png_bytep sp = row;
+ png_bytep dp = row;
+ for (i = 0; i < row_width; i++)
+ {
+ png_byte red = *(sp++);
+ png_byte green = *(sp++);
+ png_byte blue = *(sp++);
+ if (red != green || red != blue)
+ rgb_error |= 1;
+ *(dp++) = (png_byte)((rc*red + gc*green + bc*blue)>>15);
+ *(dp++) = *(sp++); /* alpha */
+ }
+ }
+ }
+ else /* RGBA bit_depth == 16 */
+ {
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+ if (png_ptr->gamma_16_to_1 != NULL &&
+ png_ptr->gamma_16_from_1 != NULL)
+ {
+ png_bytep sp = row;
+ png_bytep dp = row;
+ for (i = 0; i < row_width; i++)
+ {
+ png_uint_16 red, green, blue, w;
+
+ red = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
+ green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
+ blue = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
+
+ if (red == green && red == blue)
+ w = red;
+ else
+ {
+ png_uint_16 red_1 = png_ptr->gamma_16_to_1[(red&0xff) >>
+ png_ptr->gamma_shift][red>>8];
+ png_uint_16 green_1 = png_ptr->gamma_16_to_1[(green&0xff) >>
+ png_ptr->gamma_shift][green>>8];
+ png_uint_16 blue_1 = png_ptr->gamma_16_to_1[(blue&0xff) >>
+ png_ptr->gamma_shift][blue>>8];
+ png_uint_16 gray16 = (png_uint_16)((rc * red_1
+ + gc * green_1 + bc * blue_1)>>15);
+ w = png_ptr->gamma_16_from_1[(gray16&0xff) >>
+ png_ptr->gamma_shift][gray16 >> 8];
+ rgb_error |= 1;
+ }
+
+ *(dp++) = (png_byte)((w>>8) & 0xff);
+ *(dp++) = (png_byte)(w & 0xff);
+ *(dp++) = *(sp++); /* alpha */
+ *(dp++) = *(sp++);
+ }
+ }
+ else
+#endif
+ {
+ png_bytep sp = row;
+ png_bytep dp = row;
+ for (i = 0; i < row_width; i++)
+ {
+ png_uint_16 red, green, blue, gray16;
+ red = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2;
+ green = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2;
+ blue = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2;
+ if (red != green || red != blue)
+ rgb_error |= 1;
+ gray16 = (png_uint_16)((rc*red + gc*green + bc*blue)>>15);
+ *(dp++) = (png_byte)((gray16>>8) & 0xff);
+ *(dp++) = (png_byte)(gray16 & 0xff);
+ *(dp++) = *(sp++); /* alpha */
+ *(dp++) = *(sp++);
+ }
+ }
+ }
+ }
+ row_info->channels -= (png_byte)2;
+ row_info->color_type &= ~PNG_COLOR_MASK_COLOR;
+ row_info->pixel_depth = (png_byte)(row_info->channels *
+ row_info->bit_depth);
+ row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
+ }
+ return rgb_error;
+}
+#endif
+
+/* Build a grayscale palette. Palette is assumed to be 1 << bit_depth
+ * large of png_color. This lets grayscale images be treated as
+ * paletted. Most useful for gamma correction and simplification
+ * of code.
+ */
+void PNGAPI
+png_build_grayscale_palette(int bit_depth, png_colorp palette)
+{
+ int num_palette;
+ int color_inc;
+ int i;
+ int v;
+
+ png_debug(1, "in png_do_build_grayscale_palette\n");
+ if (palette == NULL)
+ return;
+
+ switch (bit_depth)
+ {
+ case 1:
+ num_palette = 2;
+ color_inc = 0xff;
+ break;
+ case 2:
+ num_palette = 4;
+ color_inc = 0x55;
+ break;
+ case 4:
+ num_palette = 16;
+ color_inc = 0x11;
+ break;
+ case 8:
+ num_palette = 256;
+ color_inc = 1;
+ break;
+ default:
+ num_palette = 0;
+ color_inc = 0;
+ break;
+ }
+
+ for (i = 0, v = 0; i < num_palette; i++, v += color_inc)
+ {
+ palette[i].red = (png_byte)v;
+ palette[i].green = (png_byte)v;
+ palette[i].blue = (png_byte)v;
+ }
+}
+
+/* This function is currently unused. Do we really need it? */
+#if defined(PNG_READ_DITHER_SUPPORTED) && defined(PNG_CORRECT_PALETTE_SUPPORTED)
+void /* PRIVATE */
+png_correct_palette(png_structp png_ptr, png_colorp palette,
+ int num_palette)
+{
+ png_debug(1, "in png_correct_palette\n");
+#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \
+ defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)
+ if (png_ptr->transformations & (PNG_GAMMA | PNG_BACKGROUND))
+ {
+ png_color back, back_1;
+
+ if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE)
+ {
+ back.red = png_ptr->gamma_table[png_ptr->background.red];
+ back.green = png_ptr->gamma_table[png_ptr->background.green];
+ back.blue = png_ptr->gamma_table[png_ptr->background.blue];
+
+ back_1.red = png_ptr->gamma_to_1[png_ptr->background.red];
+ back_1.green = png_ptr->gamma_to_1[png_ptr->background.green];
+ back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue];
+ }
+ else
+ {
+ double g;
+
+ g = 1.0 / (png_ptr->background_gamma * png_ptr->screen_gamma);
+
+ if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_SCREEN ||
+ fabs(g - 1.0) < PNG_GAMMA_THRESHOLD)
+ {
+ back.red = png_ptr->background.red;
+ back.green = png_ptr->background.green;
+ back.blue = png_ptr->background.blue;
+ }
+ else
+ {
+ back.red =
+ (png_byte)(pow((double)png_ptr->background.red/255, g) *
+ 255.0 + 0.5);
+ back.green =
+ (png_byte)(pow((double)png_ptr->background.green/255, g) *
+ 255.0 + 0.5);
+ back.blue =
+ (png_byte)(pow((double)png_ptr->background.blue/255, g) *
+ 255.0 + 0.5);
+ }
+
+ g = 1.0 / png_ptr->background_gamma;
+
+ back_1.red =
+ (png_byte)(pow((double)png_ptr->background.red/255, g) *
+ 255.0 + 0.5);
+ back_1.green =
+ (png_byte)(pow((double)png_ptr->background.green/255, g) *
+ 255.0 + 0.5);
+ back_1.blue =
+ (png_byte)(pow((double)png_ptr->background.blue/255, g) *
+ 255.0 + 0.5);
+ }
+
+ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+ {
+ png_uint_32 i;
+
+ for (i = 0; i < (png_uint_32)num_palette; i++)
+ {
+ if (i < png_ptr->num_trans && png_ptr->trans[i] == 0)
+ {
+ palette[i] = back;
+ }
+ else if (i < png_ptr->num_trans && png_ptr->trans[i] != 0xff)
+ {
+ png_byte v, w;
+
+ v = png_ptr->gamma_to_1[png_ptr->palette[i].red];
+ png_composite(w, v, png_ptr->trans[i], back_1.red);
+ palette[i].red = png_ptr->gamma_from_1[w];
+
+ v = png_ptr->gamma_to_1[png_ptr->palette[i].green];
+ png_composite(w, v, png_ptr->trans[i], back_1.green);
+ palette[i].green = png_ptr->gamma_from_1[w];
+
+ v = png_ptr->gamma_to_1[png_ptr->palette[i].blue];
+ png_composite(w, v, png_ptr->trans[i], back_1.blue);
+ palette[i].blue = png_ptr->gamma_from_1[w];
+ }
+ else
+ {
+ palette[i].red = png_ptr->gamma_table[palette[i].red];
+ palette[i].green = png_ptr->gamma_table[palette[i].green];
+ palette[i].blue = png_ptr->gamma_table[palette[i].blue];
+ }
+ }
+ }
+ else
+ {
+ int i;
+
+ for (i = 0; i < num_palette; i++)
+ {
+ if (palette[i].red == (png_byte)png_ptr->trans_values.gray)
+ {
+ palette[i] = back;
+ }
+ else
+ {
+ palette[i].red = png_ptr->gamma_table[palette[i].red];
+ palette[i].green = png_ptr->gamma_table[palette[i].green];
+ palette[i].blue = png_ptr->gamma_table[palette[i].blue];
+ }
+ }
+ }
+ }
+ else
+#endif
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+ if (png_ptr->transformations & PNG_GAMMA)
+ {
+ int i;
+
+ for (i = 0; i < num_palette; i++)
+ {
+ palette[i].red = png_ptr->gamma_table[palette[i].red];
+ palette[i].green = png_ptr->gamma_table[palette[i].green];
+ palette[i].blue = png_ptr->gamma_table[palette[i].blue];
+ }
+ }
+#if defined(PNG_READ_BACKGROUND_SUPPORTED)
+ else
+#endif
+#endif
+#if defined(PNG_READ_BACKGROUND_SUPPORTED)
+ if (png_ptr->transformations & PNG_BACKGROUND)
+ {
+ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+ {
+ png_color back;
+
+ back.red = (png_byte)png_ptr->background.red;
+ back.green = (png_byte)png_ptr->background.green;
+ back.blue = (png_byte)png_ptr->background.blue;
+
+ for (i = 0; i < (int)png_ptr->num_trans; i++)
+ {
+ if (png_ptr->trans[i] == 0)
+ {
+ palette[i].red = back.red;
+ palette[i].green = back.green;
+ palette[i].blue = back.blue;
+ }
+ else if (png_ptr->trans[i] != 0xff)
+ {
+ png_composite(palette[i].red, png_ptr->palette[i].red,
+ png_ptr->trans[i], back.red);
+ png_composite(palette[i].green, png_ptr->palette[i].green,
+ png_ptr->trans[i], back.green);
+ png_composite(palette[i].blue, png_ptr->palette[i].blue,
+ png_ptr->trans[i], back.blue);
+ }
+ }
+ }
+ else /* assume grayscale palette (what else could it be?) */
+ {
+ int i;
+
+ for (i = 0; i < num_palette; i++)
+ {
+ if (i == (png_byte)png_ptr->trans_values.gray)
+ {
+ palette[i].red = (png_byte)png_ptr->background.red;
+ palette[i].green = (png_byte)png_ptr->background.green;
+ palette[i].blue = (png_byte)png_ptr->background.blue;
+ }
+ }
+ }
+ }
+#endif
+}
+#endif
+
+#if defined(PNG_READ_BACKGROUND_SUPPORTED)
+/* Replace any alpha or transparency with the supplied background color.
+ * "background" is already in the screen gamma, while "background_1" is
+ * at a gamma of 1.0. Paletted files have already been taken care of.
+ */
+void /* PRIVATE */
+png_do_background(png_row_infop row_info, png_bytep row,
+ png_color_16p trans_values, png_color_16p background
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+ , png_color_16p background_1,
+ png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1,
+ png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1,
+ png_uint_16pp gamma_16_to_1, int gamma_shift
+#endif
+ )
+{
+ png_bytep sp, dp;
+ png_uint_32 i;
+ png_uint_32 row_width=row_info->width;
+ int shift;
+
+ png_debug(1, "in png_do_background\n");
+ if (background != NULL &&
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+ row != NULL && row_info != NULL &&
+#endif
+ (!(row_info->color_type & PNG_COLOR_MASK_ALPHA) ||
+ (row_info->color_type != PNG_COLOR_TYPE_PALETTE && trans_values)))
+ {
+ switch (row_info->color_type)
+ {
+ case PNG_COLOR_TYPE_GRAY:
+ {
+ switch (row_info->bit_depth)
+ {
+ case 1:
+ {
+ sp = row;
+ shift = 7;
+ for (i = 0; i < row_width; i++)
+ {
+ if ((png_uint_16)((*sp >> shift) & 0x01)
+ == trans_values->gray)
+ {
+ *sp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff);
+ *sp |= (png_byte)(background->gray << shift);
+ }
+ if (!shift)
+ {
+ shift = 7;
+ sp++;
+ }
+ else
+ shift--;
+ }
+ break;
+ }
+ case 2:
+ {
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+ if (gamma_table != NULL)
+ {
+ sp = row;
+ shift = 6;
+ for (i = 0; i < row_width; i++)
+ {
+ if ((png_uint_16)((*sp >> shift) & 0x03)
+ == trans_values->gray)
+ {
+ *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
+ *sp |= (png_byte)(background->gray << shift);
+ }
+ else
+ {
+ png_byte p = (png_byte)((*sp >> shift) & 0x03);
+ png_byte g = (png_byte)((gamma_table [p | (p << 2) |
+ (p << 4) | (p << 6)] >> 6) & 0x03);
+ *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
+ *sp |= (png_byte)(g << shift);
+ }
+ if (!shift)
+ {
+ shift = 6;
+ sp++;
+ }
+ else
+ shift -= 2;
+ }
+ }
+ else
+#endif
+ {
+ sp = row;
+ shift = 6;
+ for (i = 0; i < row_width; i++)
+ {
+ if ((png_uint_16)((*sp >> shift) & 0x03)
+ == trans_values->gray)
+ {
+ *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
+ *sp |= (png_byte)(background->gray << shift);
+ }
+ if (!shift)
+ {
+ shift = 6;
+ sp++;
+ }
+ else
+ shift -= 2;
+ }
+ }
+ break;
+ }
+ case 4:
+ {
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+ if (gamma_table != NULL)
+ {
+ sp = row;
+ shift = 4;
+ for (i = 0; i < row_width; i++)
+ {
+ if ((png_uint_16)((*sp >> shift) & 0x0f)
+ == trans_values->gray)
+ {
+ *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
+ *sp |= (png_byte)(background->gray << shift);
+ }
+ else
+ {
+ png_byte p = (png_byte)((*sp >> shift) & 0x0f);
+ png_byte g = (png_byte)((gamma_table[p |
+ (p << 4)] >> 4) & 0x0f);
+ *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
+ *sp |= (png_byte)(g << shift);
+ }
+ if (!shift)
+ {
+ shift = 4;
+ sp++;
+ }
+ else
+ shift -= 4;
+ }
+ }
+ else
+#endif
+ {
+ sp = row;
+ shift = 4;
+ for (i = 0; i < row_width; i++)
+ {
+ if ((png_uint_16)((*sp >> shift) & 0x0f)
+ == trans_values->gray)
+ {
+ *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
+ *sp |= (png_byte)(background->gray << shift);
+ }
+ if (!shift)
+ {
+ shift = 4;
+ sp++;
+ }
+ else
+ shift -= 4;
+ }
+ }
+ break;
+ }
+ case 8:
+ {
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+ if (gamma_table != NULL)
+ {
+ sp = row;
+ for (i = 0; i < row_width; i++, sp++)
+ {
+ if (*sp == trans_values->gray)
+ {
+ *sp = (png_byte)background->gray;
+ }
+ else
+ {
+ *sp = gamma_table[*sp];
+ }
+ }
+ }
+ else
+#endif
+ {
+ sp = row;
+ for (i = 0; i < row_width; i++, sp++)
+ {
+ if (*sp == trans_values->gray)
+ {
+ *sp = (png_byte)background->gray;
+ }
+ }
+ }
+ break;
+ }
+ case 16:
+ {
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+ if (gamma_16 != NULL)
+ {
+ sp = row;
+ for (i = 0; i < row_width; i++, sp += 2)
+ {
+ png_uint_16 v;
+
+ v = (png_uint_16)(((*sp) << 8) + *(sp + 1));
+ if (v == trans_values->gray)
+ {
+ /* background is already in screen gamma */
+ *sp = (png_byte)((background->gray >> 8) & 0xff);
+ *(sp + 1) = (png_byte)(background->gray & 0xff);
+ }
+ else
+ {
+ v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
+ *sp = (png_byte)((v >> 8) & 0xff);
+ *(sp + 1) = (png_byte)(v & 0xff);
+ }
+ }
+ }
+ else
+#endif
+ {
+ sp = row;
+ for (i = 0; i < row_width; i++, sp += 2)
+ {
+ png_uint_16 v;
+
+ v = (png_uint_16)(((*sp) << 8) + *(sp + 1));
+ if (v == trans_values->gray)
+ {
+ *sp = (png_byte)((background->gray >> 8) & 0xff);
+ *(sp + 1) = (png_byte)(background->gray & 0xff);
+ }
+ }
+ }
+ break;
+ }
+ }
+ break;
+ }
+ case PNG_COLOR_TYPE_RGB:
+ {
+ if (row_info->bit_depth == 8)
+ {
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+ if (gamma_table != NULL)
+ {
+ sp = row;
+ for (i = 0; i < row_width; i++, sp += 3)
+ {
+ if (*sp == trans_values->red &&
+ *(sp + 1) == trans_values->green &&
+ *(sp + 2) == trans_values->blue)
+ {
+ *sp = (png_byte)background->red;
+ *(sp + 1) = (png_byte)background->green;
+ *(sp + 2) = (png_byte)background->blue;
+ }
+ else
+ {
+ *sp = gamma_table[*sp];
+ *(sp + 1) = gamma_table[*(sp + 1)];
+ *(sp + 2) = gamma_table[*(sp + 2)];
+ }
+ }
+ }
+ else
+#endif
+ {
+ sp = row;
+ for (i = 0; i < row_width; i++, sp += 3)
+ {
+ if (*sp == trans_values->red &&
+ *(sp + 1) == trans_values->green &&
+ *(sp + 2) == trans_values->blue)
+ {
+ *sp = (png_byte)background->red;
+ *(sp + 1) = (png_byte)background->green;
+ *(sp + 2) = (png_byte)background->blue;
+ }
+ }
+ }
+ }
+ else /* if (row_info->bit_depth == 16) */
+ {
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+ if (gamma_16 != NULL)
+ {
+ sp = row;
+ for (i = 0; i < row_width; i++, sp += 6)
+ {
+ png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));
+ png_uint_16 g = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));
+ png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5));
+ if (r == trans_values->red && g == trans_values->green &&
+ b == trans_values->blue)
+ {
+ /* background is already in screen gamma */
+ *sp = (png_byte)((background->red >> 8) & 0xff);
+ *(sp + 1) = (png_byte)(background->red & 0xff);
+ *(sp + 2) = (png_byte)((background->green >> 8) & 0xff);
+ *(sp + 3) = (png_byte)(background->green & 0xff);
+ *(sp + 4) = (png_byte)((background->blue >> 8) & 0xff);
+ *(sp + 5) = (png_byte)(background->blue & 0xff);
+ }
+ else
+ {
+ png_uint_16 v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
+ *sp = (png_byte)((v >> 8) & 0xff);
+ *(sp + 1) = (png_byte)(v & 0xff);
+ v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];
+ *(sp + 2) = (png_byte)((v >> 8) & 0xff);
+ *(sp + 3) = (png_byte)(v & 0xff);
+ v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];
+ *(sp + 4) = (png_byte)((v >> 8) & 0xff);
+ *(sp + 5) = (png_byte)(v & 0xff);
+ }
+ }
+ }
+ else
+#endif
+ {
+ sp = row;
+ for (i = 0; i < row_width; i++, sp += 6)
+ {
+ png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp+1));
+ png_uint_16 g = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));
+ png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5));
+
+ if (r == trans_values->red && g == trans_values->green &&
+ b == trans_values->blue)
+ {
+ *sp = (png_byte)((background->red >> 8) & 0xff);
+ *(sp + 1) = (png_byte)(background->red & 0xff);
+ *(sp + 2) = (png_byte)((background->green >> 8) & 0xff);
+ *(sp + 3) = (png_byte)(background->green & 0xff);
+ *(sp + 4) = (png_byte)((background->blue >> 8) & 0xff);
+ *(sp + 5) = (png_byte)(background->blue & 0xff);
+ }
+ }
+ }
+ }
+ break;
+ }
+ case PNG_COLOR_TYPE_GRAY_ALPHA:
+ {
+ if (row_info->bit_depth == 8)
+ {
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+ if (gamma_to_1 != NULL && gamma_from_1 != NULL &&
+ gamma_table != NULL)
+ {
+ sp = row;
+ dp = row;
+ for (i = 0; i < row_width; i++, sp += 2, dp++)
+ {
+ png_uint_16 a = *(sp + 1);
+
+ if (a == 0xff)
+ {
+ *dp = gamma_table[*sp];
+ }
+ else if (a == 0)
+ {
+ /* background is already in screen gamma */
+ *dp = (png_byte)background->gray;
+ }
+ else
+ {
+ png_byte v, w;
+
+ v = gamma_to_1[*sp];
+ png_composite(w, v, a, background_1->gray);
+ *dp = gamma_from_1[w];
+ }
+ }
+ }
+ else
+#endif
+ {
+ sp = row;
+ dp = row;
+ for (i = 0; i < row_width; i++, sp += 2, dp++)
+ {
+ png_byte a = *(sp + 1);
+
+ if (a == 0xff)
+ {
+ *dp = *sp;
+ }
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+ else if (a == 0)
+ {
+ *dp = (png_byte)background->gray;
+ }
+ else
+ {
+ png_composite(*dp, *sp, a, background_1->gray);
+ }
+#else
+ *dp = (png_byte)background->gray;
+#endif
+ }
+ }
+ }
+ else /* if (png_ptr->bit_depth == 16) */
+ {
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+ if (gamma_16 != NULL && gamma_16_from_1 != NULL &&
+ gamma_16_to_1 != NULL)
+ {
+ sp = row;
+ dp = row;
+ for (i = 0; i < row_width; i++, sp += 4, dp += 2)
+ {
+ png_uint_16 a = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));
+
+ if (a == (png_uint_16)0xffff)
+ {
+ png_uint_16 v;
+
+ v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
+ *dp = (png_byte)((v >> 8) & 0xff);
+ *(dp + 1) = (png_byte)(v & 0xff);
+ }
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+ else if (a == 0)
+#else
+ else
+#endif
+ {
+ /* background is already in screen gamma */
+ *dp = (png_byte)((background->gray >> 8) & 0xff);
+ *(dp + 1) = (png_byte)(background->gray & 0xff);
+ }
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+ else
+ {
+ png_uint_16 g, v, w;
+
+ g = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];
+ png_composite_16(v, g, a, background_1->gray);
+ w = gamma_16_from_1[(v&0xff) >> gamma_shift][v >> 8];
+ *dp = (png_byte)((w >> 8) & 0xff);
+ *(dp + 1) = (png_byte)(w & 0xff);
+ }
+#endif
+ }
+ }
+ else
+#endif
+ {
+ sp = row;
+ dp = row;
+ for (i = 0; i < row_width; i++, sp += 4, dp += 2)
+ {
+ png_uint_16 a = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));
+ if (a == (png_uint_16)0xffff)
+ {
+ png_memcpy(dp, sp, 2);
+ }
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+ else if (a == 0)
+#else
+ else
+#endif
+ {
+ *dp = (png_byte)((background->gray >> 8) & 0xff);
+ *(dp + 1) = (png_byte)(background->gray & 0xff);
+ }
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+ else
+ {
+ png_uint_16 g, v;
+
+ g = (png_uint_16)(((*sp) << 8) + *(sp + 1));
+ png_composite_16(v, g, a, background_1->gray);
+ *dp = (png_byte)((v >> 8) & 0xff);
+ *(dp + 1) = (png_byte)(v & 0xff);
+ }
+#endif
+ }
+ }
+ }
+ break;
+ }
+ case PNG_COLOR_TYPE_RGB_ALPHA:
+ {
+ if (row_info->bit_depth == 8)
+ {
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+ if (gamma_to_1 != NULL && gamma_from_1 != NULL &&
+ gamma_table != NULL)
+ {
+ sp = row;
+ dp = row;
+ for (i = 0; i < row_width; i++, sp += 4, dp += 3)
+ {
+ png_byte a = *(sp + 3);
+
+ if (a == 0xff)
+ {
+ *dp = gamma_table[*sp];
+ *(dp + 1) = gamma_table[*(sp + 1)];
+ *(dp + 2) = gamma_table[*(sp + 2)];
+ }
+ else if (a == 0)
+ {
+ /* background is already in screen gamma */
+ *dp = (png_byte)background->red;
+ *(dp + 1) = (png_byte)background->green;
+ *(dp + 2) = (png_byte)background->blue;
+ }
+ else
+ {
+ png_byte v, w;
+
+ v = gamma_to_1[*sp];
+ png_composite(w, v, a, background_1->red);
+ *dp = gamma_from_1[w];
+ v = gamma_to_1[*(sp + 1)];
+ png_composite(w, v, a, background_1->green);
+ *(dp + 1) = gamma_from_1[w];
+ v = gamma_to_1[*(sp + 2)];
+ png_composite(w, v, a, background_1->blue);
+ *(dp + 2) = gamma_from_1[w];
+ }
+ }
+ }
+ else
+#endif
+ {
+ sp = row;
+ dp = row;
+ for (i = 0; i < row_width; i++, sp += 4, dp += 3)
+ {
+ png_byte a = *(sp + 3);
+
+ if (a == 0xff)
+ {
+ *dp = *sp;
+ *(dp + 1) = *(sp + 1);
+ *(dp + 2) = *(sp + 2);
+ }
+ else if (a == 0)
+ {
+ *dp = (png_byte)background->red;
+ *(dp + 1) = (png_byte)background->green;
+ *(dp + 2) = (png_byte)background->blue;
+ }
+ else
+ {
+ png_composite(*dp, *sp, a, background->red);
+ png_composite(*(dp + 1), *(sp + 1), a,
+ background->green);
+ png_composite(*(dp + 2), *(sp + 2), a,
+ background->blue);
+ }
+ }
+ }
+ }
+ else /* if (row_info->bit_depth == 16) */
+ {
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+ if (gamma_16 != NULL && gamma_16_from_1 != NULL &&
+ gamma_16_to_1 != NULL)
+ {
+ sp = row;
+ dp = row;
+ for (i = 0; i < row_width; i++, sp += 8, dp += 6)
+ {
+ png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))
+ << 8) + (png_uint_16)(*(sp + 7)));
+ if (a == (png_uint_16)0xffff)
+ {
+ png_uint_16 v;
+
+ v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
+ *dp = (png_byte)((v >> 8) & 0xff);
+ *(dp + 1) = (png_byte)(v & 0xff);
+ v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];
+ *(dp + 2) = (png_byte)((v >> 8) & 0xff);
+ *(dp + 3) = (png_byte)(v & 0xff);
+ v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];
+ *(dp + 4) = (png_byte)((v >> 8) & 0xff);
+ *(dp + 5) = (png_byte)(v & 0xff);
+ }
+ else if (a == 0)
+ {
+ /* background is already in screen gamma */
+ *dp = (png_byte)((background->red >> 8) & 0xff);
+ *(dp + 1) = (png_byte)(background->red & 0xff);
+ *(dp + 2) = (png_byte)((background->green >> 8) & 0xff);
+ *(dp + 3) = (png_byte)(background->green & 0xff);
+ *(dp + 4) = (png_byte)((background->blue >> 8) & 0xff);
+ *(dp + 5) = (png_byte)(background->blue & 0xff);
+ }
+ else
+ {
+ png_uint_16 v, w, x;
+
+ v = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];
+ png_composite_16(w, v, a, background_1->red);
+ x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8];
+ *dp = (png_byte)((x >> 8) & 0xff);
+ *(dp + 1) = (png_byte)(x & 0xff);
+ v = gamma_16_to_1[*(sp + 3) >> gamma_shift][*(sp + 2)];
+ png_composite_16(w, v, a, background_1->green);
+ x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8];
+ *(dp + 2) = (png_byte)((x >> 8) & 0xff);
+ *(dp + 3) = (png_byte)(x & 0xff);
+ v = gamma_16_to_1[*(sp + 5) >> gamma_shift][*(sp + 4)];
+ png_composite_16(w, v, a, background_1->blue);
+ x = gamma_16_from_1[(w & 0xff) >> gamma_shift][w >> 8];
+ *(dp + 4) = (png_byte)((x >> 8) & 0xff);
+ *(dp + 5) = (png_byte)(x & 0xff);
+ }
+ }
+ }
+ else
+#endif
+ {
+ sp = row;
+ dp = row;
+ for (i = 0; i < row_width; i++, sp += 8, dp += 6)
+ {
+ png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))
+ << 8) + (png_uint_16)(*(sp + 7)));
+ if (a == (png_uint_16)0xffff)
+ {
+ png_memcpy(dp, sp, 6);
+ }
+ else if (a == 0)
+ {
+ *dp = (png_byte)((background->red >> 8) & 0xff);
+ *(dp + 1) = (png_byte)(background->red & 0xff);
+ *(dp + 2) = (png_byte)((background->green >> 8) & 0xff);
+ *(dp + 3) = (png_byte)(background->green & 0xff);
+ *(dp + 4) = (png_byte)((background->blue >> 8) & 0xff);
+ *(dp + 5) = (png_byte)(background->blue & 0xff);
+ }
+ else
+ {
+ png_uint_16 v;
+
+ png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));
+ png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8)
+ + *(sp + 3));
+ png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8)
+ + *(sp + 5));
+
+ png_composite_16(v, r, a, background->red);
+ *dp = (png_byte)((v >> 8) & 0xff);
+ *(dp + 1) = (png_byte)(v & 0xff);
+ png_composite_16(v, g, a, background->green);
+ *(dp + 2) = (png_byte)((v >> 8) & 0xff);
+ *(dp + 3) = (png_byte)(v & 0xff);
+ png_composite_16(v, b, a, background->blue);
+ *(dp + 4) = (png_byte)((v >> 8) & 0xff);
+ *(dp + 5) = (png_byte)(v & 0xff);
+ }
+ }
+ }
+ }
+ break;
+ }
+ }
+
+ if (row_info->color_type & PNG_COLOR_MASK_ALPHA)
+ {
+ row_info->color_type &= ~PNG_COLOR_MASK_ALPHA;
+ row_info->channels--;
+ row_info->pixel_depth = (png_byte)(row_info->channels *
+ row_info->bit_depth);
+ row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
+ }
+ }
+}
+#endif
+
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+/* Gamma correct the image, avoiding the alpha channel. Make sure
+ * you do this after you deal with the transparency issue on grayscale
+ * or RGB images. If your bit depth is 8, use gamma_table, if it
+ * is 16, use gamma_16_table and gamma_shift. Build these with
+ * build_gamma_table().
+ */
+void /* PRIVATE */
+png_do_gamma(png_row_infop row_info, png_bytep row,
+ png_bytep gamma_table, png_uint_16pp gamma_16_table,
+ int gamma_shift)
+{
+ png_bytep sp;
+ png_uint_32 i;
+ png_uint_32 row_width=row_info->width;
+
+ png_debug(1, "in png_do_gamma\n");
+ if (
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+ row != NULL && row_info != NULL &&
+#endif
+ ((row_info->bit_depth <= 8 && gamma_table != NULL) ||
+ (row_info->bit_depth == 16 && gamma_16_table != NULL)))
+ {
+ switch (row_info->color_type)
+ {
+ case PNG_COLOR_TYPE_RGB:
+ {
+ if (row_info->bit_depth == 8)
+ {
+ sp = row;
+ for (i = 0; i < row_width; i++)
+ {
+ *sp = gamma_table[*sp];
+ sp++;
+ *sp = gamma_table[*sp];
+ sp++;
+ *sp = gamma_table[*sp];
+ sp++;
+ }
+ }
+ else /* if (row_info->bit_depth == 16) */
+ {
+ sp = row;
+ for (i = 0; i < row_width; i++)
+ {
+ png_uint_16 v;
+
+ v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
+ *sp = (png_byte)((v >> 8) & 0xff);
+ *(sp + 1) = (png_byte)(v & 0xff);
+ sp += 2;
+ v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
+ *sp = (png_byte)((v >> 8) & 0xff);
+ *(sp + 1) = (png_byte)(v & 0xff);
+ sp += 2;
+ v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
+ *sp = (png_byte)((v >> 8) & 0xff);
+ *(sp + 1) = (png_byte)(v & 0xff);
+ sp += 2;
+ }
+ }
+ break;
+ }
+ case PNG_COLOR_TYPE_RGB_ALPHA:
+ {
+ if (row_info->bit_depth == 8)
+ {
+ sp = row;
+ for (i = 0; i < row_width; i++)
+ {
+ *sp = gamma_table[*sp];
+ sp++;
+ *sp = gamma_table[*sp];
+ sp++;
+ *sp = gamma_table[*sp];
+ sp++;
+ sp++;
+ }
+ }
+ else /* if (row_info->bit_depth == 16) */
+ {
+ sp = row;
+ for (i = 0; i < row_width; i++)
+ {
+ png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
+ *sp = (png_byte)((v >> 8) & 0xff);
+ *(sp + 1) = (png_byte)(v & 0xff);
+ sp += 2;
+ v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
+ *sp = (png_byte)((v >> 8) & 0xff);
+ *(sp + 1) = (png_byte)(v & 0xff);
+ sp += 2;
+ v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
+ *sp = (png_byte)((v >> 8) & 0xff);
+ *(sp + 1) = (png_byte)(v & 0xff);
+ sp += 4;
+ }
+ }
+ break;
+ }
+ case PNG_COLOR_TYPE_GRAY_ALPHA:
+ {
+ if (row_info->bit_depth == 8)
+ {
+ sp = row;
+ for (i = 0; i < row_width; i++)
+ {
+ *sp = gamma_table[*sp];
+ sp += 2;
+ }
+ }
+ else /* if (row_info->bit_depth == 16) */
+ {
+ sp = row;
+ for (i = 0; i < row_width; i++)
+ {
+ png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
+ *sp = (png_byte)((v >> 8) & 0xff);
+ *(sp + 1) = (png_byte)(v & 0xff);
+ sp += 4;
+ }
+ }
+ break;
+ }
+ case PNG_COLOR_TYPE_GRAY:
+ {
+ if (row_info->bit_depth == 2)
+ {
+ sp = row;
+ for (i = 0; i < row_width; i += 4)
+ {
+ int a = *sp & 0xc0;
+ int b = *sp & 0x30;
+ int c = *sp & 0x0c;
+ int d = *sp & 0x03;
+
+ *sp = (png_byte)(
+ ((((int)gamma_table[a|(a>>2)|(a>>4)|(a>>6)]) ) & 0xc0)|
+ ((((int)gamma_table[(b<<2)|b|(b>>2)|(b>>4)])>>2) & 0x30)|
+ ((((int)gamma_table[(c<<4)|(c<<2)|c|(c>>2)])>>4) & 0x0c)|
+ ((((int)gamma_table[(d<<6)|(d<<4)|(d<<2)|d])>>6) ));
+ sp++;
+ }
+ }
+ if (row_info->bit_depth == 4)
+ {
+ sp = row;
+ for (i = 0; i < row_width; i += 2)
+ {
+ int msb = *sp & 0xf0;
+ int lsb = *sp & 0x0f;
+
+ *sp = (png_byte)((((int)gamma_table[msb | (msb >> 4)]) & 0xf0)
+ | (((int)gamma_table[(lsb << 4) | lsb]) >> 4));
+ sp++;
+ }
+ }
+ else if (row_info->bit_depth == 8)
+ {
+ sp = row;
+ for (i = 0; i < row_width; i++)
+ {
+ *sp = gamma_table[*sp];
+ sp++;
+ }
+ }
+ else if (row_info->bit_depth == 16)
+ {
+ sp = row;
+ for (i = 0; i < row_width; i++)
+ {
+ png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
+ *sp = (png_byte)((v >> 8) & 0xff);
+ *(sp + 1) = (png_byte)(v & 0xff);
+ sp += 2;
+ }
+ }
+ break;
+ }
+ }
+ }
+}
+#endif
+
+#if defined(PNG_READ_EXPAND_SUPPORTED)
+/* Expands a palette row to an RGB or RGBA row depending
+ * upon whether you supply trans and num_trans.
+ */
+void /* PRIVATE */
+png_do_expand_palette(png_row_infop row_info, png_bytep row,
+ png_colorp palette, png_bytep trans, int num_trans)
+{
+ int shift, value;
+ png_bytep sp, dp;
+ png_uint_32 i;
+ png_uint_32 row_width=row_info->width;
+
+ png_debug(1, "in png_do_expand_palette\n");
+ if (
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+ row != NULL && row_info != NULL &&
+#endif
+ row_info->color_type == PNG_COLOR_TYPE_PALETTE)
+ {
+ if (row_info->bit_depth < 8)
+ {
+ switch (row_info->bit_depth)
+ {
+ case 1:
+ {
+ sp = row + (png_size_t)((row_width - 1) >> 3);
+ dp = row + (png_size_t)row_width - 1;
+ shift = 7 - (int)((row_width + 7) & 0x07);
+ for (i = 0; i < row_width; i++)
+ {
+ if ((*sp >> shift) & 0x01)
+ *dp = 1;
+ else
+ *dp = 0;
+ if (shift == 7)
+ {
+ shift = 0;
+ sp--;
+ }
+ else
+ shift++;
+
+ dp--;
+ }
+ break;
+ }
+ case 2:
+ {
+ sp = row + (png_size_t)((row_width - 1) >> 2);
+ dp = row + (png_size_t)row_width - 1;
+ shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);
+ for (i = 0; i < row_width; i++)
+ {
+ value = (*sp >> shift) & 0x03;
+ *dp = (png_byte)value;
+ if (shift == 6)
+ {
+ shift = 0;
+ sp--;
+ }
+ else
+ shift += 2;
+
+ dp--;
+ }
+ break;
+ }
+ case 4:
+ {
+ sp = row + (png_size_t)((row_width - 1) >> 1);
+ dp = row + (png_size_t)row_width - 1;
+ shift = (int)((row_width & 0x01) << 2);
+ for (i = 0; i < row_width; i++)
+ {
+ value = (*sp >> shift) & 0x0f;
+ *dp = (png_byte)value;
+ if (shift == 4)
+ {
+ shift = 0;
+ sp--;
+ }
+ else
+ shift += 4;
+
+ dp--;
+ }
+ break;
+ }
+ }
+ row_info->bit_depth = 8;
+ row_info->pixel_depth = 8;
+ row_info->rowbytes = row_width;
+ }
+ switch (row_info->bit_depth)
+ {
+ case 8:
+ {
+ if (trans != NULL)
+ {
+ sp = row + (png_size_t)row_width - 1;
+ dp = row + (png_size_t)(row_width << 2) - 1;
+
+ for (i = 0; i < row_width; i++)
+ {
+ if ((int)(*sp) >= num_trans)
+ *dp-- = 0xff;
+ else
+ *dp-- = trans[*sp];
+ *dp-- = palette[*sp].blue;
+ *dp-- = palette[*sp].green;
+ *dp-- = palette[*sp].red;
+ sp--;
+ }
+ row_info->bit_depth = 8;
+ row_info->pixel_depth = 32;
+ row_info->rowbytes = row_width * 4;
+ row_info->color_type = 6;
+ row_info->channels = 4;
+ }
+ else
+ {
+ sp = row + (png_size_t)row_width - 1;
+ dp = row + (png_size_t)(row_width * 3) - 1;
+
+ for (i = 0; i < row_width; i++)
+ {
+ *dp-- = palette[*sp].blue;
+ *dp-- = palette[*sp].green;
+ *dp-- = palette[*sp].red;
+ sp--;
+ }
+ row_info->bit_depth = 8;
+ row_info->pixel_depth = 24;
+ row_info->rowbytes = row_width * 3;
+ row_info->color_type = 2;
+ row_info->channels = 3;
+ }
+ break;
+ }
+ }
+ }
+}
+
+/* If the bit depth < 8, it is expanded to 8. Also, if the already
+ * expanded transparency value is supplied, an alpha channel is built.
+ */
+void /* PRIVATE */
+png_do_expand(png_row_infop row_info, png_bytep row,
+ png_color_16p trans_value)
+{
+ int shift, value;
+ png_bytep sp, dp;
+ png_uint_32 i;
+ png_uint_32 row_width=row_info->width;
+
+ png_debug(1, "in png_do_expand\n");
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+ if (row != NULL && row_info != NULL)
+#endif
+ {
+ if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
+ {
+ png_uint_16 gray = (png_uint_16)(trans_value ? trans_value->gray : 0);
+
+ if (row_info->bit_depth < 8)
+ {
+ switch (row_info->bit_depth)
+ {
+ case 1:
+ {
+ gray = (png_uint_16)((gray&0x01)*0xff);
+ sp = row + (png_size_t)((row_width - 1) >> 3);
+ dp = row + (png_size_t)row_width - 1;
+ shift = 7 - (int)((row_width + 7) & 0x07);
+ for (i = 0; i < row_width; i++)
+ {
+ if ((*sp >> shift) & 0x01)
+ *dp = 0xff;
+ else
+ *dp = 0;
+ if (shift == 7)
+ {
+ shift = 0;
+ sp--;
+ }
+ else
+ shift++;
+
+ dp--;
+ }
+ break;
+ }
+ case 2:
+ {
+ gray = (png_uint_16)((gray&0x03)*0x55);
+ sp = row + (png_size_t)((row_width - 1) >> 2);
+ dp = row + (png_size_t)row_width - 1;
+ shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);
+ for (i = 0; i < row_width; i++)
+ {
+ value = (*sp >> shift) & 0x03;
+ *dp = (png_byte)(value | (value << 2) | (value << 4) |
+ (value << 6));
+ if (shift == 6)
+ {
+ shift = 0;
+ sp--;
+ }
+ else
+ shift += 2;
+
+ dp--;
+ }
+ break;
+ }
+ case 4:
+ {
+ gray = (png_uint_16)((gray&0x0f)*0x11);
+ sp = row + (png_size_t)((row_width - 1) >> 1);
+ dp = row + (png_size_t)row_width - 1;
+ shift = (int)((1 - ((row_width + 1) & 0x01)) << 2);
+ for (i = 0; i < row_width; i++)
+ {
+ value = (*sp >> shift) & 0x0f;
+ *dp = (png_byte)(value | (value << 4));
+ if (shift == 4)
+ {
+ shift = 0;
+ sp--;
+ }
+ else
+ shift = 4;
+
+ dp--;
+ }
+ break;
+ }
+ }
+ row_info->bit_depth = 8;
+ row_info->pixel_depth = 8;
+ row_info->rowbytes = row_width;
+ }
+
+ if (trans_value != NULL)
+ {
+ if (row_info->bit_depth == 8)
+ {
+ gray = gray & 0xff;
+ sp = row + (png_size_t)row_width - 1;
+ dp = row + (png_size_t)(row_width << 1) - 1;
+ for (i = 0; i < row_width; i++)
+ {
+ if (*sp == gray)
+ *dp-- = 0;
+ else
+ *dp-- = 0xff;
+ *dp-- = *sp--;
+ }
+ }
+ else if (row_info->bit_depth == 16)
+ {
+ png_byte gray_high = (gray >> 8) & 0xff;
+ png_byte gray_low = gray & 0xff;
+ sp = row + row_info->rowbytes - 1;
+ dp = row + (row_info->rowbytes << 1) - 1;
+ for (i = 0; i < row_width; i++)
+ {
+ if (*(sp - 1) == gray_high && *(sp) == gray_low)
+ {
+ *dp-- = 0;
+ *dp-- = 0;
+ }
+ else
+ {
+ *dp-- = 0xff;
+ *dp-- = 0xff;
+ }
+ *dp-- = *sp--;
+ *dp-- = *sp--;
+ }
+ }
+ row_info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
+ row_info->channels = 2;
+ row_info->pixel_depth = (png_byte)(row_info->bit_depth << 1);
+ row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,
+ row_width);
+ }
+ }
+ else if (row_info->color_type == PNG_COLOR_TYPE_RGB && trans_value)
+ {
+ if (row_info->bit_depth == 8)
+ {
+ png_byte red = trans_value->red & 0xff;
+ png_byte green = trans_value->green & 0xff;
+ png_byte blue = trans_value->blue & 0xff;
+ sp = row + (png_size_t)row_info->rowbytes - 1;
+ dp = row + (png_size_t)(row_width << 2) - 1;
+ for (i = 0; i < row_width; i++)
+ {
+ if (*(sp - 2) == red && *(sp - 1) == green && *(sp) == blue)
+ *dp-- = 0;
+ else
+ *dp-- = 0xff;
+ *dp-- = *sp--;
+ *dp-- = *sp--;
+ *dp-- = *sp--;
+ }
+ }
+ else if (row_info->bit_depth == 16)
+ {
+ png_byte red_high = (trans_value->red >> 8) & 0xff;
+ png_byte green_high = (trans_value->green >> 8) & 0xff;
+ png_byte blue_high = (trans_value->blue >> 8) & 0xff;
+ png_byte red_low = trans_value->red & 0xff;
+ png_byte green_low = trans_value->green & 0xff;
+ png_byte blue_low = trans_value->blue & 0xff;
+ sp = row + row_info->rowbytes - 1;
+ dp = row + (png_size_t)(row_width << 3) - 1;
+ for (i = 0; i < row_width; i++)
+ {
+ if (*(sp - 5) == red_high &&
+ *(sp - 4) == red_low &&
+ *(sp - 3) == green_high &&
+ *(sp - 2) == green_low &&
+ *(sp - 1) == blue_high &&
+ *(sp ) == blue_low)
+ {
+ *dp-- = 0;
+ *dp-- = 0;
+ }
+ else
+ {
+ *dp-- = 0xff;
+ *dp-- = 0xff;
+ }
+ *dp-- = *sp--;
+ *dp-- = *sp--;
+ *dp-- = *sp--;
+ *dp-- = *sp--;
+ *dp-- = *sp--;
+ *dp-- = *sp--;
+ }
+ }
+ row_info->color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+ row_info->channels = 4;
+ row_info->pixel_depth = (png_byte)(row_info->bit_depth << 2);
+ row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
+ }
+ }
+}
+#endif
+
+#if defined(PNG_READ_DITHER_SUPPORTED)
+void /* PRIVATE */
+png_do_dither(png_row_infop row_info, png_bytep row,
+ png_bytep palette_lookup, png_bytep dither_lookup)
+{
+ png_bytep sp, dp;
+ png_uint_32 i;
+ png_uint_32 row_width=row_info->width;
+
+ png_debug(1, "in png_do_dither\n");
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+ if (row != NULL && row_info != NULL)
+#endif
+ {
+ if (row_info->color_type == PNG_COLOR_TYPE_RGB &&
+ palette_lookup && row_info->bit_depth == 8)
+ {
+ int r, g, b, p;
+ sp = row;
+ dp = row;
+ for (i = 0; i < row_width; i++)
+ {
+ r = *sp++;
+ g = *sp++;
+ b = *sp++;
+
+ /* this looks real messy, but the compiler will reduce
+ it down to a reasonable formula. For example, with
+ 5 bits per color, we get:
+ p = (((r >> 3) & 0x1f) << 10) |
+ (((g >> 3) & 0x1f) << 5) |
+ ((b >> 3) & 0x1f);
+ */
+ p = (((r >> (8 - PNG_DITHER_RED_BITS)) &
+ ((1 << PNG_DITHER_RED_BITS) - 1)) <<
+ (PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) |
+ (((g >> (8 - PNG_DITHER_GREEN_BITS)) &
+ ((1 << PNG_DITHER_GREEN_BITS) - 1)) <<
+ (PNG_DITHER_BLUE_BITS)) |
+ ((b >> (8 - PNG_DITHER_BLUE_BITS)) &
+ ((1 << PNG_DITHER_BLUE_BITS) - 1));
+
+ *dp++ = palette_lookup[p];
+ }
+ row_info->color_type = PNG_COLOR_TYPE_PALETTE;
+ row_info->channels = 1;
+ row_info->pixel_depth = row_info->bit_depth;
+ row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
+ }
+ else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&
+ palette_lookup != NULL && row_info->bit_depth == 8)
+ {
+ int r, g, b, p;
+ sp = row;
+ dp = row;
+ for (i = 0; i < row_width; i++)
+ {
+ r = *sp++;
+ g = *sp++;
+ b = *sp++;
+ sp++;
+
+ p = (((r >> (8 - PNG_DITHER_RED_BITS)) &
+ ((1 << PNG_DITHER_RED_BITS) - 1)) <<
+ (PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) |
+ (((g >> (8 - PNG_DITHER_GREEN_BITS)) &
+ ((1 << PNG_DITHER_GREEN_BITS) - 1)) <<
+ (PNG_DITHER_BLUE_BITS)) |
+ ((b >> (8 - PNG_DITHER_BLUE_BITS)) &
+ ((1 << PNG_DITHER_BLUE_BITS) - 1));
+
+ *dp++ = palette_lookup[p];
+ }
+ row_info->color_type = PNG_COLOR_TYPE_PALETTE;
+ row_info->channels = 1;
+ row_info->pixel_depth = row_info->bit_depth;
+ row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
+ }
+ else if (row_info->color_type == PNG_COLOR_TYPE_PALETTE &&
+ dither_lookup && row_info->bit_depth == 8)
+ {
+ sp = row;
+ for (i = 0; i < row_width; i++, sp++)
+ {
+ *sp = dither_lookup[*sp];
+ }
+ }
+ }
+}
+#endif
+
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+static PNG_CONST int png_gamma_shift[] =
+ {0x10, 0x21, 0x42, 0x84, 0x110, 0x248, 0x550, 0xff0, 0x00};
+
+/* We build the 8- or 16-bit gamma tables here. Note that for 16-bit
+ * tables, we don't make a full table if we are reducing to 8-bit in
+ * the future. Note also how the gamma_16 tables are segmented so that
+ * we don't need to allocate > 64K chunks for a full 16-bit table.
+ */
+void /* PRIVATE */
+png_build_gamma_table(png_structp png_ptr)
+{
+ png_debug(1, "in png_build_gamma_table\n");
+
+ if (png_ptr->bit_depth <= 8)
+ {
+ int i;
+ double g;
+
+ if (png_ptr->screen_gamma > .000001)
+ g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
+ else
+ g = 1.0;
+
+ png_ptr->gamma_table = (png_bytep)png_malloc(png_ptr,
+ (png_uint_32)256);
+
+ for (i = 0; i < 256; i++)
+ {
+ png_ptr->gamma_table[i] = (png_byte)(pow((double)i / 255.0,
+ g) * 255.0 + .5);
+ }
+
+#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
+ defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
+ if (png_ptr->transformations & ((PNG_BACKGROUND) | PNG_RGB_TO_GRAY))
+ {
+
+ g = 1.0 / (png_ptr->gamma);
+
+ png_ptr->gamma_to_1 = (png_bytep)png_malloc(png_ptr,
+ (png_uint_32)256);
+
+ for (i = 0; i < 256; i++)
+ {
+ png_ptr->gamma_to_1[i] = (png_byte)(pow((double)i / 255.0,
+ g) * 255.0 + .5);
+ }
+
+
+ png_ptr->gamma_from_1 = (png_bytep)png_malloc(png_ptr,
+ (png_uint_32)256);
+
+ if (png_ptr->screen_gamma > 0.000001)
+ g = 1.0 / png_ptr->screen_gamma;
+ else
+ g = png_ptr->gamma; /* probably doing rgb_to_gray */
+
+ for (i = 0; i < 256; i++)
+ {
+ png_ptr->gamma_from_1[i] = (png_byte)(pow((double)i / 255.0,
+ g) * 255.0 + .5);
+
+ }
+ }
+#endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */
+ }
+ else
+ {
+ double g;
+ int i, j, shift, num;
+ int sig_bit;
+ png_uint_32 ig;
+
+ if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
+ {
+ sig_bit = (int)png_ptr->sig_bit.red;
+ if ((int)png_ptr->sig_bit.green > sig_bit)
+ sig_bit = png_ptr->sig_bit.green;
+ if ((int)png_ptr->sig_bit.blue > sig_bit)
+ sig_bit = png_ptr->sig_bit.blue;
+ }
+ else
+ {
+ sig_bit = (int)png_ptr->sig_bit.gray;
+ }
+
+ if (sig_bit > 0)
+ shift = 16 - sig_bit;
+ else
+ shift = 0;
+
+ if (png_ptr->transformations & PNG_16_TO_8)
+ {
+ if (shift < (16 - PNG_MAX_GAMMA_8))
+ shift = (16 - PNG_MAX_GAMMA_8);
+ }
+
+ if (shift > 8)
+ shift = 8;
+ if (shift < 0)
+ shift = 0;
+
+ png_ptr->gamma_shift = (png_byte)shift;
+
+ num = (1 << (8 - shift));
+
+ if (png_ptr->screen_gamma > .000001)
+ g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
+ else
+ g = 1.0;
+
+ png_ptr->gamma_16_table = (png_uint_16pp)png_malloc(png_ptr,
+ (png_uint_32)(num * png_sizeof(png_uint_16p)));
+
+ if (png_ptr->transformations & (PNG_16_TO_8 | PNG_BACKGROUND))
+ {
+ double fin, fout;
+ png_uint_32 last, max;
+
+ for (i = 0; i < num; i++)
+ {
+ png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr,
+ (png_uint_32)(256 * png_sizeof(png_uint_16)));
+ }
+
+ g = 1.0 / g;
+ last = 0;
+ for (i = 0; i < 256; i++)
+ {
+ fout = ((double)i + 0.5) / 256.0;
+ fin = pow(fout, g);
+ max = (png_uint_32)(fin * (double)((png_uint_32)num << 8));
+ while (last <= max)
+ {
+ png_ptr->gamma_16_table[(int)(last & (0xff >> shift))]
+ [(int)(last >> (8 - shift))] = (png_uint_16)(
+ (png_uint_16)i | ((png_uint_16)i << 8));
+ last++;
+ }
+ }
+ while (last < ((png_uint_32)num << 8))
+ {
+ png_ptr->gamma_16_table[(int)(last & (0xff >> shift))]
+ [(int)(last >> (8 - shift))] = (png_uint_16)65535L;
+ last++;
+ }
+ }
+ else
+ {
+ for (i = 0; i < num; i++)
+ {
+ png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr,
+ (png_uint_32)(256 * png_sizeof(png_uint_16)));
+
+ ig = (((png_uint_32)i * (png_uint_32)png_gamma_shift[shift]) >> 4);
+ for (j = 0; j < 256; j++)
+ {
+ png_ptr->gamma_16_table[i][j] =
+ (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /
+ 65535.0, g) * 65535.0 + .5);
+ }
+ }
+ }
+
+#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
+ defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
+ if (png_ptr->transformations & (PNG_BACKGROUND | PNG_RGB_TO_GRAY))
+ {
+
+ g = 1.0 / (png_ptr->gamma);
+
+ png_ptr->gamma_16_to_1 = (png_uint_16pp)png_malloc(png_ptr,
+ (png_uint_32)(num * png_sizeof(png_uint_16p )));
+
+ for (i = 0; i < num; i++)
+ {
+ png_ptr->gamma_16_to_1[i] = (png_uint_16p)png_malloc(png_ptr,
+ (png_uint_32)(256 * png_sizeof(png_uint_16)));
+
+ ig = (((png_uint_32)i *
+ (png_uint_32)png_gamma_shift[shift]) >> 4);
+ for (j = 0; j < 256; j++)
+ {
+ png_ptr->gamma_16_to_1[i][j] =
+ (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /
+ 65535.0, g) * 65535.0 + .5);
+ }
+ }
+
+ if (png_ptr->screen_gamma > 0.000001)
+ g = 1.0 / png_ptr->screen_gamma;
+ else
+ g = png_ptr->gamma; /* probably doing rgb_to_gray */
+
+ png_ptr->gamma_16_from_1 = (png_uint_16pp)png_malloc(png_ptr,
+ (png_uint_32)(num * png_sizeof(png_uint_16p)));
+
+ for (i = 0; i < num; i++)
+ {
+ png_ptr->gamma_16_from_1[i] = (png_uint_16p)png_malloc(png_ptr,
+ (png_uint_32)(256 * png_sizeof(png_uint_16)));
+
+ ig = (((png_uint_32)i *
+ (png_uint_32)png_gamma_shift[shift]) >> 4);
+ for (j = 0; j < 256; j++)
+ {
+ png_ptr->gamma_16_from_1[i][j] =
+ (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /
+ 65535.0, g) * 65535.0 + .5);
+ }
+ }
+ }
+#endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */
+ }
+}
+#endif
+/* To do: install integer version of png_build_gamma_table here */
+#endif
+
+#if defined(PNG_MNG_FEATURES_SUPPORTED)
+/* undoes intrapixel differencing */
+void /* PRIVATE */
+png_do_read_intrapixel(png_row_infop row_info, png_bytep row)
+{
+ png_debug(1, "in png_do_read_intrapixel\n");
+ if (
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+ row != NULL && row_info != NULL &&
+#endif
+ (row_info->color_type & PNG_COLOR_MASK_COLOR))
+ {
+ int bytes_per_pixel;
+ png_uint_32 row_width = row_info->width;
+ if (row_info->bit_depth == 8)
+ {
+ png_bytep rp;
+ png_uint_32 i;
+
+ if (row_info->color_type == PNG_COLOR_TYPE_RGB)
+ bytes_per_pixel = 3;
+ else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+ bytes_per_pixel = 4;
+ else
+ return;
+
+ for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
+ {
+ *(rp) = (png_byte)((256 + *rp + *(rp+1))&0xff);
+ *(rp+2) = (png_byte)((256 + *(rp+2) + *(rp+1))&0xff);
+ }
+ }
+ else if (row_info->bit_depth == 16)
+ {
+ png_bytep rp;
+ png_uint_32 i;
+
+ if (row_info->color_type == PNG_COLOR_TYPE_RGB)
+ bytes_per_pixel = 6;
+ else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+ bytes_per_pixel = 8;
+ else
+ return;
+
+ for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
+ {
+ png_uint_32 s0 = (*(rp ) << 8) | *(rp + 1);
+ png_uint_32 s1 = (*(rp + 2) << 8) | *(rp + 3);
+ png_uint_32 s2 = (*(rp + 4) << 8) | *(rp + 5);
+ png_uint_32 red = (png_uint_32)((s0 + s1 + 65536L) & 0xffffL);
+ png_uint_32 blue = (png_uint_32)((s2 + s1 + 65536L) & 0xffffL);
+ *(rp ) = (png_byte)((red >> 8) & 0xff);
+ *(rp+1) = (png_byte)(red & 0xff);
+ *(rp+4) = (png_byte)((blue >> 8) & 0xff);
+ *(rp+5) = (png_byte)(blue & 0xff);
+ }
+ }
+ }
+}
+#endif /* PNG_MNG_FEATURES_SUPPORTED */
+#endif /* PNG_READ_SUPPORTED */
--- /dev/null
+
+/* pngrutil.c - utilities to read a PNG file
+ *
+ * Last changed in libpng 1.2.33 [October 31, 2008]
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * This file contains routines that are only called from within
+ * libpng itself during the course of reading an image.
+ */
+
+#define PNG_INTERNAL
+#include "png.h"
+#if defined(PNG_READ_SUPPORTED)
+
+#if defined(_WIN32_WCE) && (_WIN32_WCE<0x500)
+# define WIN32_WCE_OLD
+#endif
+
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+# if defined(WIN32_WCE_OLD)
+/* strtod() function is not supported on WindowsCE */
+__inline double png_strtod(png_structp png_ptr, PNG_CONST char *nptr, char **endptr)
+{
+ double result = 0;
+ int len;
+ wchar_t *str, *end;
+
+ len = MultiByteToWideChar(CP_ACP, 0, nptr, -1, NULL, 0);
+ str = (wchar_t *)png_malloc(png_ptr, len * png_sizeof(wchar_t));
+ if ( NULL != str )
+ {
+ MultiByteToWideChar(CP_ACP, 0, nptr, -1, str, len);
+ result = wcstod(str, &end);
+ len = WideCharToMultiByte(CP_ACP, 0, end, -1, NULL, 0, NULL, NULL);
+ *endptr = (char *)nptr + (png_strlen(nptr) - len + 1);
+ png_free(png_ptr, str);
+ }
+ return result;
+}
+# else
+# define png_strtod(p,a,b) strtod(a,b)
+# endif
+#endif
+
+png_uint_32 PNGAPI
+png_get_uint_31(png_structp png_ptr, png_bytep buf)
+{
+#ifdef PNG_READ_BIG_ENDIAN_SUPPORTED
+ png_uint_32 i = png_get_uint_32(buf);
+#else
+ /* Avoid an extra function call by inlining the result. */
+ png_uint_32 i = ((png_uint_32)(*buf) << 24) +
+ ((png_uint_32)(*(buf + 1)) << 16) +
+ ((png_uint_32)(*(buf + 2)) << 8) +
+ (png_uint_32)(*(buf + 3));
+#endif
+ if (i > PNG_UINT_31_MAX)
+ png_error(png_ptr, "PNG unsigned integer out of range.");
+ return (i);
+}
+#ifndef PNG_READ_BIG_ENDIAN_SUPPORTED
+/* Grab an unsigned 32-bit integer from a buffer in big-endian format. */
+png_uint_32 PNGAPI
+png_get_uint_32(png_bytep buf)
+{
+ png_uint_32 i = ((png_uint_32)(*buf) << 24) +
+ ((png_uint_32)(*(buf + 1)) << 16) +
+ ((png_uint_32)(*(buf + 2)) << 8) +
+ (png_uint_32)(*(buf + 3));
+
+ return (i);
+}
+
+/* Grab a signed 32-bit integer from a buffer in big-endian format. The
+ * data is stored in the PNG file in two's complement format, and it is
+ * assumed that the machine format for signed integers is the same. */
+png_int_32 PNGAPI
+png_get_int_32(png_bytep buf)
+{
+ png_int_32 i = ((png_int_32)(*buf) << 24) +
+ ((png_int_32)(*(buf + 1)) << 16) +
+ ((png_int_32)(*(buf + 2)) << 8) +
+ (png_int_32)(*(buf + 3));
+
+ return (i);
+}
+
+/* Grab an unsigned 16-bit integer from a buffer in big-endian format. */
+png_uint_16 PNGAPI
+png_get_uint_16(png_bytep buf)
+{
+ png_uint_16 i = (png_uint_16)(((png_uint_16)(*buf) << 8) +
+ (png_uint_16)(*(buf + 1)));
+
+ return (i);
+}
+#endif /* PNG_READ_BIG_ENDIAN_SUPPORTED */
+
+/* Read the chunk header (length + type name).
+ * Put the type name into png_ptr->chunk_name, and return the length.
+ */
+png_uint_32 /* PRIVATE */
+png_read_chunk_header(png_structp png_ptr)
+{
+ png_byte buf[8];
+ png_uint_32 length;
+
+ /* read the length and the chunk name */
+ png_read_data(png_ptr, buf, 8);
+ length = png_get_uint_31(png_ptr, buf);
+
+ /* put the chunk name into png_ptr->chunk_name */
+ png_memcpy(png_ptr->chunk_name, buf + 4, 4);
+
+ png_debug2(0, "Reading %s chunk, length = %lu\n",
+ png_ptr->chunk_name, length);
+
+ /* reset the crc and run it over the chunk name */
+ png_reset_crc(png_ptr);
+ png_calculate_crc(png_ptr, png_ptr->chunk_name, 4);
+
+ /* check to see if chunk name is valid */
+ png_check_chunk_name(png_ptr, png_ptr->chunk_name);
+
+ return length;
+}
+
+/* Read data, and (optionally) run it through the CRC. */
+void /* PRIVATE */
+png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length)
+{
+ if (png_ptr == NULL) return;
+ png_read_data(png_ptr, buf, length);
+ png_calculate_crc(png_ptr, buf, length);
+}
+
+/* Optionally skip data and then check the CRC. Depending on whether we
+ are reading a ancillary or critical chunk, and how the program has set
+ things up, we may calculate the CRC on the data and print a message.
+ Returns '1' if there was a CRC error, '0' otherwise. */
+int /* PRIVATE */
+png_crc_finish(png_structp png_ptr, png_uint_32 skip)
+{
+ png_size_t i;
+ png_size_t istop = png_ptr->zbuf_size;
+
+ for (i = (png_size_t)skip; i > istop; i -= istop)
+ {
+ png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
+ }
+ if (i)
+ {
+ png_crc_read(png_ptr, png_ptr->zbuf, i);
+ }
+
+ if (png_crc_error(png_ptr))
+ {
+ if (((png_ptr->chunk_name[0] & 0x20) && /* Ancillary */
+ !(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)) ||
+ (!(png_ptr->chunk_name[0] & 0x20) && /* Critical */
+ (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE)))
+ {
+ png_chunk_warning(png_ptr, "CRC error");
+ }
+ else
+ {
+ png_chunk_error(png_ptr, "CRC error");
+ }
+ return (1);
+ }
+
+ return (0);
+}
+
+/* Compare the CRC stored in the PNG file with that calculated by libpng from
+ the data it has read thus far. */
+int /* PRIVATE */
+png_crc_error(png_structp png_ptr)
+{
+ png_byte crc_bytes[4];
+ png_uint_32 crc;
+ int need_crc = 1;
+
+ if (png_ptr->chunk_name[0] & 0x20) /* ancillary */
+ {
+ if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
+ (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))
+ need_crc = 0;
+ }
+ else /* critical */
+ {
+ if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)
+ need_crc = 0;
+ }
+
+ png_read_data(png_ptr, crc_bytes, 4);
+
+ if (need_crc)
+ {
+ crc = png_get_uint_32(crc_bytes);
+ return ((int)(crc != png_ptr->crc));
+ }
+ else
+ return (0);
+}
+
+#if defined(PNG_READ_zTXt_SUPPORTED) || defined(PNG_READ_iTXt_SUPPORTED) || \
+ defined(PNG_READ_iCCP_SUPPORTED)
+/*
+ * Decompress trailing data in a chunk. The assumption is that chunkdata
+ * points at an allocated area holding the contents of a chunk with a
+ * trailing compressed part. What we get back is an allocated area
+ * holding the original prefix part and an uncompressed version of the
+ * trailing part (the malloc area passed in is freed).
+ */
+void /* PRIVATE */
+png_decompress_chunk(png_structp png_ptr, int comp_type,
+ png_size_t chunklength,
+ png_size_t prefix_size, png_size_t *newlength)
+{
+ static PNG_CONST char msg[] = "Error decoding compressed text";
+ png_charp text;
+ png_size_t text_size;
+
+ if (comp_type == PNG_COMPRESSION_TYPE_BASE)
+ {
+ int ret = Z_OK;
+ png_ptr->zstream.next_in = (png_bytep)(png_ptr->chunkdata + prefix_size);
+ png_ptr->zstream.avail_in = (uInt)(chunklength - prefix_size);
+ png_ptr->zstream.next_out = png_ptr->zbuf;
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+
+ text_size = 0;
+ text = NULL;
+
+ while (png_ptr->zstream.avail_in)
+ {
+ ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
+ if (ret != Z_OK && ret != Z_STREAM_END)
+ {
+ if (png_ptr->zstream.msg != NULL)
+ png_warning(png_ptr, png_ptr->zstream.msg);
+ else
+ png_warning(png_ptr, msg);
+ inflateReset(&png_ptr->zstream);
+ png_ptr->zstream.avail_in = 0;
+
+ if (text == NULL)
+ {
+ text_size = prefix_size + png_sizeof(msg) + 1;
+ text = (png_charp)png_malloc_warn(png_ptr, text_size);
+ if (text == NULL)
+ {
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ png_error(png_ptr, "Not enough memory to decompress chunk");
+ }
+ png_memcpy(text, png_ptr->chunkdata, prefix_size);
+ }
+
+ text[text_size - 1] = 0x00;
+
+ /* Copy what we can of the error message into the text chunk */
+ text_size = (png_size_t)(chunklength -
+ (text - png_ptr->chunkdata) - 1);
+ if (text_size > png_sizeof(msg))
+ text_size = png_sizeof(msg);
+ png_memcpy(text + prefix_size, msg, text_size);
+ break;
+ }
+ if (!png_ptr->zstream.avail_out || ret == Z_STREAM_END)
+ {
+ if (text == NULL)
+ {
+ text_size = prefix_size +
+ png_ptr->zbuf_size - png_ptr->zstream.avail_out;
+ text = (png_charp)png_malloc_warn(png_ptr, text_size + 1);
+ if (text == NULL)
+ {
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ png_error(png_ptr,
+ "Not enough memory to decompress chunk.");
+ }
+ png_memcpy(text + prefix_size, png_ptr->zbuf,
+ text_size - prefix_size);
+ png_memcpy(text, png_ptr->chunkdata, prefix_size);
+ *(text + text_size) = 0x00;
+ }
+ else
+ {
+ png_charp tmp;
+
+ tmp = text;
+ text = (png_charp)png_malloc_warn(png_ptr,
+ (png_uint_32)(text_size +
+ png_ptr->zbuf_size - png_ptr->zstream.avail_out + 1));
+ if (text == NULL)
+ {
+ png_free(png_ptr, tmp);
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ png_error(png_ptr,
+ "Not enough memory to decompress chunk..");
+ }
+ png_memcpy(text, tmp, text_size);
+ png_free(png_ptr, tmp);
+ png_memcpy(text + text_size, png_ptr->zbuf,
+ (png_ptr->zbuf_size - png_ptr->zstream.avail_out));
+ text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out;
+ *(text + text_size) = 0x00;
+ }
+ if (ret == Z_STREAM_END)
+ break;
+ else
+ {
+ png_ptr->zstream.next_out = png_ptr->zbuf;
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+ }
+ }
+ }
+ if (ret != Z_STREAM_END)
+ {
+#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)
+ char umsg[52];
+
+ if (ret == Z_BUF_ERROR)
+ png_snprintf(umsg, 52,
+ "Buffer error in compressed datastream in %s chunk",
+ png_ptr->chunk_name);
+ else if (ret == Z_DATA_ERROR)
+ png_snprintf(umsg, 52,
+ "Data error in compressed datastream in %s chunk",
+ png_ptr->chunk_name);
+ else
+ png_snprintf(umsg, 52,
+ "Incomplete compressed datastream in %s chunk",
+ png_ptr->chunk_name);
+ png_warning(png_ptr, umsg);
+#else
+ png_warning(png_ptr,
+ "Incomplete compressed datastream in chunk other than IDAT");
+#endif
+ text_size = prefix_size;
+ if (text == NULL)
+ {
+ text = (png_charp)png_malloc_warn(png_ptr, text_size+1);
+ if (text == NULL)
+ {
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ png_error(png_ptr, "Not enough memory for text.");
+ }
+ png_memcpy(text, png_ptr->chunkdata, prefix_size);
+ }
+ *(text + text_size) = 0x00;
+ }
+
+ inflateReset(&png_ptr->zstream);
+ png_ptr->zstream.avail_in = 0;
+
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = text;
+ *newlength=text_size;
+ }
+ else /* if (comp_type != PNG_COMPRESSION_TYPE_BASE) */
+ {
+#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)
+ char umsg[50];
+
+ png_snprintf(umsg, 50, "Unknown zTXt compression type %d", comp_type);
+ png_warning(png_ptr, umsg);
+#else
+ png_warning(png_ptr, "Unknown zTXt compression type");
+#endif
+
+ *(png_ptr->chunkdata + prefix_size) = 0x00;
+ *newlength = prefix_size;
+ }
+}
+#endif
+
+/* read and check the IDHR chunk */
+void /* PRIVATE */
+png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+ png_byte buf[13];
+ png_uint_32 width, height;
+ int bit_depth, color_type, compression_type, filter_type;
+ int interlace_type;
+
+ png_debug(1, "in png_handle_IHDR\n");
+
+ if (png_ptr->mode & PNG_HAVE_IHDR)
+ png_error(png_ptr, "Out of place IHDR");
+
+ /* check the length */
+ if (length != 13)
+ png_error(png_ptr, "Invalid IHDR chunk");
+
+ png_ptr->mode |= PNG_HAVE_IHDR;
+
+ png_crc_read(png_ptr, buf, 13);
+ png_crc_finish(png_ptr, 0);
+
+ width = png_get_uint_31(png_ptr, buf);
+ height = png_get_uint_31(png_ptr, buf + 4);
+ bit_depth = buf[8];
+ color_type = buf[9];
+ compression_type = buf[10];
+ filter_type = buf[11];
+ interlace_type = buf[12];
+
+ /* set internal variables */
+ png_ptr->width = width;
+ png_ptr->height = height;
+ png_ptr->bit_depth = (png_byte)bit_depth;
+ png_ptr->interlaced = (png_byte)interlace_type;
+ png_ptr->color_type = (png_byte)color_type;
+#if defined(PNG_MNG_FEATURES_SUPPORTED)
+ png_ptr->filter_type = (png_byte)filter_type;
+#endif
+ png_ptr->compression_type = (png_byte)compression_type;
+
+ /* find number of channels */
+ switch (png_ptr->color_type)
+ {
+ case PNG_COLOR_TYPE_GRAY:
+ case PNG_COLOR_TYPE_PALETTE:
+ png_ptr->channels = 1;
+ break;
+ case PNG_COLOR_TYPE_RGB:
+ png_ptr->channels = 3;
+ break;
+ case PNG_COLOR_TYPE_GRAY_ALPHA:
+ png_ptr->channels = 2;
+ break;
+ case PNG_COLOR_TYPE_RGB_ALPHA:
+ png_ptr->channels = 4;
+ break;
+ }
+
+ /* set up other useful info */
+ png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth *
+ png_ptr->channels);
+ png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->width);
+ png_debug1(3, "bit_depth = %d\n", png_ptr->bit_depth);
+ png_debug1(3, "channels = %d\n", png_ptr->channels);
+ png_debug1(3, "rowbytes = %lu\n", png_ptr->rowbytes);
+ png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth,
+ color_type, interlace_type, compression_type, filter_type);
+}
+
+/* read and check the palette */
+void /* PRIVATE */
+png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+ png_color palette[PNG_MAX_PALETTE_LENGTH];
+ int num, i;
+#ifndef PNG_NO_POINTER_INDEXING
+ png_colorp pal_ptr;
+#endif
+
+ png_debug(1, "in png_handle_PLTE\n");
+
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))
+ png_error(png_ptr, "Missing IHDR before PLTE");
+ else if (png_ptr->mode & PNG_HAVE_IDAT)
+ {
+ png_warning(png_ptr, "Invalid PLTE after IDAT");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+ else if (png_ptr->mode & PNG_HAVE_PLTE)
+ png_error(png_ptr, "Duplicate PLTE chunk");
+
+ png_ptr->mode |= PNG_HAVE_PLTE;
+
+ if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR))
+ {
+ png_warning(png_ptr,
+ "Ignoring PLTE chunk in grayscale PNG");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+#if !defined(PNG_READ_OPT_PLTE_SUPPORTED)
+ if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
+ {
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+#endif
+
+ if (length > 3*PNG_MAX_PALETTE_LENGTH || length % 3)
+ {
+ if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
+ {
+ png_warning(png_ptr, "Invalid palette chunk");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+ else
+ {
+ png_error(png_ptr, "Invalid palette chunk");
+ }
+ }
+
+ num = (int)length / 3;
+
+#ifndef PNG_NO_POINTER_INDEXING
+ for (i = 0, pal_ptr = palette; i < num; i++, pal_ptr++)
+ {
+ png_byte buf[3];
+
+ png_crc_read(png_ptr, buf, 3);
+ pal_ptr->red = buf[0];
+ pal_ptr->green = buf[1];
+ pal_ptr->blue = buf[2];
+ }
+#else
+ for (i = 0; i < num; i++)
+ {
+ png_byte buf[3];
+
+ png_crc_read(png_ptr, buf, 3);
+ /* don't depend upon png_color being any order */
+ palette[i].red = buf[0];
+ palette[i].green = buf[1];
+ palette[i].blue = buf[2];
+ }
+#endif
+
+ /* If we actually NEED the PLTE chunk (ie for a paletted image), we do
+ whatever the normal CRC configuration tells us. However, if we
+ have an RGB image, the PLTE can be considered ancillary, so
+ we will act as though it is. */
+#if !defined(PNG_READ_OPT_PLTE_SUPPORTED)
+ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+#endif
+ {
+ png_crc_finish(png_ptr, 0);
+ }
+#if !defined(PNG_READ_OPT_PLTE_SUPPORTED)
+ else if (png_crc_error(png_ptr)) /* Only if we have a CRC error */
+ {
+ /* If we don't want to use the data from an ancillary chunk,
+ we have two options: an error abort, or a warning and we
+ ignore the data in this chunk (which should be OK, since
+ it's considered ancillary for a RGB or RGBA image). */
+ if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_USE))
+ {
+ if (png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)
+ {
+ png_chunk_error(png_ptr, "CRC error");
+ }
+ else
+ {
+ png_chunk_warning(png_ptr, "CRC error");
+ return;
+ }
+ }
+ /* Otherwise, we (optionally) emit a warning and use the chunk. */
+ else if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN))
+ {
+ png_chunk_warning(png_ptr, "CRC error");
+ }
+ }
+#endif
+
+ png_set_PLTE(png_ptr, info_ptr, palette, num);
+
+#if defined(PNG_READ_tRNS_SUPPORTED)
+ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+ {
+ if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))
+ {
+ if (png_ptr->num_trans > (png_uint_16)num)
+ {
+ png_warning(png_ptr, "Truncating incorrect tRNS chunk length");
+ png_ptr->num_trans = (png_uint_16)num;
+ }
+ if (info_ptr->num_trans > (png_uint_16)num)
+ {
+ png_warning(png_ptr, "Truncating incorrect info tRNS chunk length");
+ info_ptr->num_trans = (png_uint_16)num;
+ }
+ }
+ }
+#endif
+
+}
+
+void /* PRIVATE */
+png_handle_IEND(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+ png_debug(1, "in png_handle_IEND\n");
+
+ if (!(png_ptr->mode & PNG_HAVE_IHDR) || !(png_ptr->mode & PNG_HAVE_IDAT))
+ {
+ png_error(png_ptr, "No image in file");
+ }
+
+ png_ptr->mode |= (PNG_AFTER_IDAT | PNG_HAVE_IEND);
+
+ if (length != 0)
+ {
+ png_warning(png_ptr, "Incorrect IEND chunk length");
+ }
+ png_crc_finish(png_ptr, length);
+
+ info_ptr = info_ptr; /* quiet compiler warnings about unused info_ptr */
+}
+
+#if defined(PNG_READ_gAMA_SUPPORTED)
+void /* PRIVATE */
+png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+ png_fixed_point igamma;
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+ float file_gamma;
+#endif
+ png_byte buf[4];
+
+ png_debug(1, "in png_handle_gAMA\n");
+
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))
+ png_error(png_ptr, "Missing IHDR before gAMA");
+ else if (png_ptr->mode & PNG_HAVE_IDAT)
+ {
+ png_warning(png_ptr, "Invalid gAMA after IDAT");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+ else if (png_ptr->mode & PNG_HAVE_PLTE)
+ /* Should be an error, but we can cope with it */
+ png_warning(png_ptr, "Out of place gAMA chunk");
+
+ if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)
+#if defined(PNG_READ_sRGB_SUPPORTED)
+ && !(info_ptr->valid & PNG_INFO_sRGB)
+#endif
+ )
+ {
+ png_warning(png_ptr, "Duplicate gAMA chunk");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+
+ if (length != 4)
+ {
+ png_warning(png_ptr, "Incorrect gAMA chunk length");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+
+ png_crc_read(png_ptr, buf, 4);
+ if (png_crc_finish(png_ptr, 0))
+ return;
+
+ igamma = (png_fixed_point)png_get_uint_32(buf);
+ /* check for zero gamma */
+ if (igamma == 0)
+ {
+ png_warning(png_ptr,
+ "Ignoring gAMA chunk with gamma=0");
+ return;
+ }
+
+#if defined(PNG_READ_sRGB_SUPPORTED)
+ if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB))
+ if (PNG_OUT_OF_RANGE(igamma, 45500L, 500))
+ {
+ png_warning(png_ptr,
+ "Ignoring incorrect gAMA value when sRGB is also present");
+#ifndef PNG_NO_CONSOLE_IO
+ fprintf(stderr, "gamma = (%d/100000)\n", (int)igamma);
+#endif
+ return;
+ }
+#endif /* PNG_READ_sRGB_SUPPORTED */
+
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+ file_gamma = (float)igamma / (float)100000.0;
+# ifdef PNG_READ_GAMMA_SUPPORTED
+ png_ptr->gamma = file_gamma;
+# endif
+ png_set_gAMA(png_ptr, info_ptr, file_gamma);
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+ png_set_gAMA_fixed(png_ptr, info_ptr, igamma);
+#endif
+}
+#endif
+
+#if defined(PNG_READ_sBIT_SUPPORTED)
+void /* PRIVATE */
+png_handle_sBIT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+ png_size_t truelen;
+ png_byte buf[4];
+
+ png_debug(1, "in png_handle_sBIT\n");
+
+ buf[0] = buf[1] = buf[2] = buf[3] = 0;
+
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))
+ png_error(png_ptr, "Missing IHDR before sBIT");
+ else if (png_ptr->mode & PNG_HAVE_IDAT)
+ {
+ png_warning(png_ptr, "Invalid sBIT after IDAT");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+ else if (png_ptr->mode & PNG_HAVE_PLTE)
+ {
+ /* Should be an error, but we can cope with it */
+ png_warning(png_ptr, "Out of place sBIT chunk");
+ }
+ if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT))
+ {
+ png_warning(png_ptr, "Duplicate sBIT chunk");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+
+ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+ truelen = 3;
+ else
+ truelen = (png_size_t)png_ptr->channels;
+
+ if (length != truelen || length > 4)
+ {
+ png_warning(png_ptr, "Incorrect sBIT chunk length");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+
+ png_crc_read(png_ptr, buf, truelen);
+ if (png_crc_finish(png_ptr, 0))
+ return;
+
+ if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
+ {
+ png_ptr->sig_bit.red = buf[0];
+ png_ptr->sig_bit.green = buf[1];
+ png_ptr->sig_bit.blue = buf[2];
+ png_ptr->sig_bit.alpha = buf[3];
+ }
+ else
+ {
+ png_ptr->sig_bit.gray = buf[0];
+ png_ptr->sig_bit.red = buf[0];
+ png_ptr->sig_bit.green = buf[0];
+ png_ptr->sig_bit.blue = buf[0];
+ png_ptr->sig_bit.alpha = buf[1];
+ }
+ png_set_sBIT(png_ptr, info_ptr, &(png_ptr->sig_bit));
+}
+#endif
+
+#if defined(PNG_READ_cHRM_SUPPORTED)
+void /* PRIVATE */
+png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+ png_byte buf[32];
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+ float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;
+#endif
+ png_fixed_point int_x_white, int_y_white, int_x_red, int_y_red, int_x_green,
+ int_y_green, int_x_blue, int_y_blue;
+
+ png_uint_32 uint_x, uint_y;
+
+ png_debug(1, "in png_handle_cHRM\n");
+
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))
+ png_error(png_ptr, "Missing IHDR before cHRM");
+ else if (png_ptr->mode & PNG_HAVE_IDAT)
+ {
+ png_warning(png_ptr, "Invalid cHRM after IDAT");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+ else if (png_ptr->mode & PNG_HAVE_PLTE)
+ /* Should be an error, but we can cope with it */
+ png_warning(png_ptr, "Missing PLTE before cHRM");
+
+ if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM)
+#if defined(PNG_READ_sRGB_SUPPORTED)
+ && !(info_ptr->valid & PNG_INFO_sRGB)
+#endif
+ )
+ {
+ png_warning(png_ptr, "Duplicate cHRM chunk");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+
+ if (length != 32)
+ {
+ png_warning(png_ptr, "Incorrect cHRM chunk length");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+
+ png_crc_read(png_ptr, buf, 32);
+ if (png_crc_finish(png_ptr, 0))
+ return;
+
+ uint_x = png_get_uint_32(buf);
+ uint_y = png_get_uint_32(buf + 4);
+ if (uint_x > 80000L || uint_y > 80000L ||
+ uint_x + uint_y > 100000L)
+ {
+ png_warning(png_ptr, "Invalid cHRM white point");
+ return;
+ }
+ int_x_white = (png_fixed_point)uint_x;
+ int_y_white = (png_fixed_point)uint_y;
+
+ uint_x = png_get_uint_32(buf + 8);
+ uint_y = png_get_uint_32(buf + 12);
+ if (uint_x + uint_y > 100000L)
+ {
+ png_warning(png_ptr, "Invalid cHRM red point");
+ return;
+ }
+ int_x_red = (png_fixed_point)uint_x;
+ int_y_red = (png_fixed_point)uint_y;
+
+ uint_x = png_get_uint_32(buf + 16);
+ uint_y = png_get_uint_32(buf + 20);
+ if (uint_x + uint_y > 100000L)
+ {
+ png_warning(png_ptr, "Invalid cHRM green point");
+ return;
+ }
+ int_x_green = (png_fixed_point)uint_x;
+ int_y_green = (png_fixed_point)uint_y;
+
+ uint_x = png_get_uint_32(buf + 24);
+ uint_y = png_get_uint_32(buf + 28);
+ if (uint_x + uint_y > 100000L)
+ {
+ png_warning(png_ptr, "Invalid cHRM blue point");
+ return;
+ }
+ int_x_blue = (png_fixed_point)uint_x;
+ int_y_blue = (png_fixed_point)uint_y;
+
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+ white_x = (float)int_x_white / (float)100000.0;
+ white_y = (float)int_y_white / (float)100000.0;
+ red_x = (float)int_x_red / (float)100000.0;
+ red_y = (float)int_y_red / (float)100000.0;
+ green_x = (float)int_x_green / (float)100000.0;
+ green_y = (float)int_y_green / (float)100000.0;
+ blue_x = (float)int_x_blue / (float)100000.0;
+ blue_y = (float)int_y_blue / (float)100000.0;
+#endif
+
+#if defined(PNG_READ_sRGB_SUPPORTED)
+ if ((info_ptr != NULL) && (info_ptr->valid & PNG_INFO_sRGB))
+ {
+ if (PNG_OUT_OF_RANGE(int_x_white, 31270, 1000) ||
+ PNG_OUT_OF_RANGE(int_y_white, 32900, 1000) ||
+ PNG_OUT_OF_RANGE(int_x_red, 64000L, 1000) ||
+ PNG_OUT_OF_RANGE(int_y_red, 33000, 1000) ||
+ PNG_OUT_OF_RANGE(int_x_green, 30000, 1000) ||
+ PNG_OUT_OF_RANGE(int_y_green, 60000L, 1000) ||
+ PNG_OUT_OF_RANGE(int_x_blue, 15000, 1000) ||
+ PNG_OUT_OF_RANGE(int_y_blue, 6000, 1000))
+ {
+ png_warning(png_ptr,
+ "Ignoring incorrect cHRM value when sRGB is also present");
+#ifndef PNG_NO_CONSOLE_IO
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+ fprintf(stderr, "wx=%f, wy=%f, rx=%f, ry=%f\n",
+ white_x, white_y, red_x, red_y);
+ fprintf(stderr, "gx=%f, gy=%f, bx=%f, by=%f\n",
+ green_x, green_y, blue_x, blue_y);
+#else
+ fprintf(stderr, "wx=%ld, wy=%ld, rx=%ld, ry=%ld\n",
+ int_x_white, int_y_white, int_x_red, int_y_red);
+ fprintf(stderr, "gx=%ld, gy=%ld, bx=%ld, by=%ld\n",
+ int_x_green, int_y_green, int_x_blue, int_y_blue);
+#endif
+#endif /* PNG_NO_CONSOLE_IO */
+ }
+ return;
+ }
+#endif /* PNG_READ_sRGB_SUPPORTED */
+
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+ png_set_cHRM(png_ptr, info_ptr,
+ white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+ png_set_cHRM_fixed(png_ptr, info_ptr,
+ int_x_white, int_y_white, int_x_red, int_y_red, int_x_green,
+ int_y_green, int_x_blue, int_y_blue);
+#endif
+}
+#endif
+
+#if defined(PNG_READ_sRGB_SUPPORTED)
+void /* PRIVATE */
+png_handle_sRGB(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+ int intent;
+ png_byte buf[1];
+
+ png_debug(1, "in png_handle_sRGB\n");
+
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))
+ png_error(png_ptr, "Missing IHDR before sRGB");
+ else if (png_ptr->mode & PNG_HAVE_IDAT)
+ {
+ png_warning(png_ptr, "Invalid sRGB after IDAT");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+ else if (png_ptr->mode & PNG_HAVE_PLTE)
+ /* Should be an error, but we can cope with it */
+ png_warning(png_ptr, "Out of place sRGB chunk");
+
+ if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB))
+ {
+ png_warning(png_ptr, "Duplicate sRGB chunk");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+
+ if (length != 1)
+ {
+ png_warning(png_ptr, "Incorrect sRGB chunk length");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+
+ png_crc_read(png_ptr, buf, 1);
+ if (png_crc_finish(png_ptr, 0))
+ return;
+
+ intent = buf[0];
+ /* check for bad intent */
+ if (intent >= PNG_sRGB_INTENT_LAST)
+ {
+ png_warning(png_ptr, "Unknown sRGB intent");
+ return;
+ }
+
+#if defined(PNG_READ_gAMA_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED)
+ if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA))
+ {
+ png_fixed_point igamma;
+#ifdef PNG_FIXED_POINT_SUPPORTED
+ igamma=info_ptr->int_gamma;
+#else
+# ifdef PNG_FLOATING_POINT_SUPPORTED
+ igamma=(png_fixed_point)(info_ptr->gamma * 100000.);
+# endif
+#endif
+ if (PNG_OUT_OF_RANGE(igamma, 45500L, 500))
+ {
+ png_warning(png_ptr,
+ "Ignoring incorrect gAMA value when sRGB is also present");
+#ifndef PNG_NO_CONSOLE_IO
+# ifdef PNG_FIXED_POINT_SUPPORTED
+ fprintf(stderr, "incorrect gamma=(%d/100000)\n",
+ (int)png_ptr->int_gamma);
+# else
+# ifdef PNG_FLOATING_POINT_SUPPORTED
+ fprintf(stderr, "incorrect gamma=%f\n", png_ptr->gamma);
+# endif
+# endif
+#endif
+ }
+ }
+#endif /* PNG_READ_gAMA_SUPPORTED */
+
+#ifdef PNG_READ_cHRM_SUPPORTED
+#ifdef PNG_FIXED_POINT_SUPPORTED
+ if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))
+ if (PNG_OUT_OF_RANGE(info_ptr->int_x_white, 31270, 1000) ||
+ PNG_OUT_OF_RANGE(info_ptr->int_y_white, 32900, 1000) ||
+ PNG_OUT_OF_RANGE(info_ptr->int_x_red, 64000L, 1000) ||
+ PNG_OUT_OF_RANGE(info_ptr->int_y_red, 33000, 1000) ||
+ PNG_OUT_OF_RANGE(info_ptr->int_x_green, 30000, 1000) ||
+ PNG_OUT_OF_RANGE(info_ptr->int_y_green, 60000L, 1000) ||
+ PNG_OUT_OF_RANGE(info_ptr->int_x_blue, 15000, 1000) ||
+ PNG_OUT_OF_RANGE(info_ptr->int_y_blue, 6000, 1000))
+ {
+ png_warning(png_ptr,
+ "Ignoring incorrect cHRM value when sRGB is also present");
+ }
+#endif /* PNG_FIXED_POINT_SUPPORTED */
+#endif /* PNG_READ_cHRM_SUPPORTED */
+
+ png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, intent);
+}
+#endif /* PNG_READ_sRGB_SUPPORTED */
+
+#if defined(PNG_READ_iCCP_SUPPORTED)
+void /* PRIVATE */
+png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+/* Note: this does not properly handle chunks that are > 64K under DOS */
+{
+ png_byte compression_type;
+ png_bytep pC;
+ png_charp profile;
+ png_uint_32 skip = 0;
+ png_uint_32 profile_size, profile_length;
+ png_size_t slength, prefix_length, data_length;
+
+ png_debug(1, "in png_handle_iCCP\n");
+
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))
+ png_error(png_ptr, "Missing IHDR before iCCP");
+ else if (png_ptr->mode & PNG_HAVE_IDAT)
+ {
+ png_warning(png_ptr, "Invalid iCCP after IDAT");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+ else if (png_ptr->mode & PNG_HAVE_PLTE)
+ /* Should be an error, but we can cope with it */
+ png_warning(png_ptr, "Out of place iCCP chunk");
+
+ if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP))
+ {
+ png_warning(png_ptr, "Duplicate iCCP chunk");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+
+#ifdef PNG_MAX_MALLOC_64K
+ if (length > (png_uint_32)65535L)
+ {
+ png_warning(png_ptr, "iCCP chunk too large to fit in memory");
+ skip = length - (png_uint_32)65535L;
+ length = (png_uint_32)65535L;
+ }
+#endif
+
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = (png_charp)png_malloc(png_ptr, length + 1);
+ slength = (png_size_t)length;
+ png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
+
+ if (png_crc_finish(png_ptr, skip))
+ {
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ return;
+ }
+
+ png_ptr->chunkdata[slength] = 0x00;
+
+ for (profile = png_ptr->chunkdata; *profile; profile++)
+ /* empty loop to find end of name */ ;
+
+ ++profile;
+
+ /* there should be at least one zero (the compression type byte)
+ following the separator, and we should be on it */
+ if ( profile >= png_ptr->chunkdata + slength - 1)
+ {
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ png_warning(png_ptr, "Malformed iCCP chunk");
+ return;
+ }
+
+ /* compression_type should always be zero */
+ compression_type = *profile++;
+ if (compression_type)
+ {
+ png_warning(png_ptr, "Ignoring nonzero compression type in iCCP chunk");
+ compression_type = 0x00; /* Reset it to zero (libpng-1.0.6 through 1.0.8
+ wrote nonzero) */
+ }
+
+ prefix_length = profile - png_ptr->chunkdata;
+ png_decompress_chunk(png_ptr, compression_type,
+ slength, prefix_length, &data_length);
+
+ profile_length = data_length - prefix_length;
+
+ if ( prefix_length > data_length || profile_length < 4)
+ {
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ png_warning(png_ptr, "Profile size field missing from iCCP chunk");
+ return;
+ }
+
+ /* Check the profile_size recorded in the first 32 bits of the ICC profile */
+ pC = (png_bytep)(png_ptr->chunkdata + prefix_length);
+ profile_size = ((*(pC ))<<24) |
+ ((*(pC + 1))<<16) |
+ ((*(pC + 2))<< 8) |
+ ((*(pC + 3)) );
+
+ if (profile_size < profile_length)
+ profile_length = profile_size;
+
+ if (profile_size > profile_length)
+ {
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ png_warning(png_ptr, "Ignoring truncated iCCP profile.");
+ return;
+ }
+
+ png_set_iCCP(png_ptr, info_ptr, png_ptr->chunkdata,
+ compression_type, png_ptr->chunkdata + prefix_length, profile_length);
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+}
+#endif /* PNG_READ_iCCP_SUPPORTED */
+
+#if defined(PNG_READ_sPLT_SUPPORTED)
+void /* PRIVATE */
+png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+/* Note: this does not properly handle chunks that are > 64K under DOS */
+{
+ png_bytep entry_start;
+ png_sPLT_t new_palette;
+#ifdef PNG_NO_POINTER_INDEXING
+ png_sPLT_entryp pp;
+#endif
+ int data_length, entry_size, i;
+ png_uint_32 skip = 0;
+ png_size_t slength;
+
+ png_debug(1, "in png_handle_sPLT\n");
+
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))
+ png_error(png_ptr, "Missing IHDR before sPLT");
+ else if (png_ptr->mode & PNG_HAVE_IDAT)
+ {
+ png_warning(png_ptr, "Invalid sPLT after IDAT");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+
+#ifdef PNG_MAX_MALLOC_64K
+ if (length > (png_uint_32)65535L)
+ {
+ png_warning(png_ptr, "sPLT chunk too large to fit in memory");
+ skip = length - (png_uint_32)65535L;
+ length = (png_uint_32)65535L;
+ }
+#endif
+
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = (png_charp)png_malloc(png_ptr, length + 1);
+ slength = (png_size_t)length;
+ png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
+
+ if (png_crc_finish(png_ptr, skip))
+ {
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ return;
+ }
+
+ png_ptr->chunkdata[slength] = 0x00;
+
+ for (entry_start = (png_bytep)png_ptr->chunkdata; *entry_start; entry_start++)
+ /* empty loop to find end of name */ ;
+ ++entry_start;
+
+ /* a sample depth should follow the separator, and we should be on it */
+ if (entry_start > (png_bytep)png_ptr->chunkdata + slength - 2)
+ {
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ png_warning(png_ptr, "malformed sPLT chunk");
+ return;
+ }
+
+ new_palette.depth = *entry_start++;
+ entry_size = (new_palette.depth == 8 ? 6 : 10);
+ data_length = (slength - (entry_start - (png_bytep)png_ptr->chunkdata));
+
+ /* integrity-check the data length */
+ if (data_length % entry_size)
+ {
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ png_warning(png_ptr, "sPLT chunk has bad length");
+ return;
+ }
+
+ new_palette.nentries = (png_int_32) ( data_length / entry_size);
+ if ((png_uint_32) new_palette.nentries >
+ (png_uint_32) (PNG_SIZE_MAX / png_sizeof(png_sPLT_entry)))
+ {
+ png_warning(png_ptr, "sPLT chunk too long");
+ return;
+ }
+ new_palette.entries = (png_sPLT_entryp)png_malloc_warn(
+ png_ptr, new_palette.nentries * png_sizeof(png_sPLT_entry));
+ if (new_palette.entries == NULL)
+ {
+ png_warning(png_ptr, "sPLT chunk requires too much memory");
+ return;
+ }
+
+#ifndef PNG_NO_POINTER_INDEXING
+ for (i = 0; i < new_palette.nentries; i++)
+ {
+ png_sPLT_entryp pp = new_palette.entries + i;
+
+ if (new_palette.depth == 8)
+ {
+ pp->red = *entry_start++;
+ pp->green = *entry_start++;
+ pp->blue = *entry_start++;
+ pp->alpha = *entry_start++;
+ }
+ else
+ {
+ pp->red = png_get_uint_16(entry_start); entry_start += 2;
+ pp->green = png_get_uint_16(entry_start); entry_start += 2;
+ pp->blue = png_get_uint_16(entry_start); entry_start += 2;
+ pp->alpha = png_get_uint_16(entry_start); entry_start += 2;
+ }
+ pp->frequency = png_get_uint_16(entry_start); entry_start += 2;
+ }
+#else
+ pp = new_palette.entries;
+ for (i = 0; i < new_palette.nentries; i++)
+ {
+
+ if (new_palette.depth == 8)
+ {
+ pp[i].red = *entry_start++;
+ pp[i].green = *entry_start++;
+ pp[i].blue = *entry_start++;
+ pp[i].alpha = *entry_start++;
+ }
+ else
+ {
+ pp[i].red = png_get_uint_16(entry_start); entry_start += 2;
+ pp[i].green = png_get_uint_16(entry_start); entry_start += 2;
+ pp[i].blue = png_get_uint_16(entry_start); entry_start += 2;
+ pp[i].alpha = png_get_uint_16(entry_start); entry_start += 2;
+ }
+ pp->frequency = png_get_uint_16(entry_start); entry_start += 2;
+ }
+#endif
+
+ /* discard all chunk data except the name and stash that */
+ new_palette.name = png_ptr->chunkdata;
+
+ png_set_sPLT(png_ptr, info_ptr, &new_palette, 1);
+
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ png_free(png_ptr, new_palette.entries);
+}
+#endif /* PNG_READ_sPLT_SUPPORTED */
+
+#if defined(PNG_READ_tRNS_SUPPORTED)
+void /* PRIVATE */
+png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+ png_byte readbuf[PNG_MAX_PALETTE_LENGTH];
+
+ png_debug(1, "in png_handle_tRNS\n");
+
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))
+ png_error(png_ptr, "Missing IHDR before tRNS");
+ else if (png_ptr->mode & PNG_HAVE_IDAT)
+ {
+ png_warning(png_ptr, "Invalid tRNS after IDAT");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+ else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))
+ {
+ png_warning(png_ptr, "Duplicate tRNS chunk");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+
+ if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
+ {
+ png_byte buf[2];
+
+ if (length != 2)
+ {
+ png_warning(png_ptr, "Incorrect tRNS chunk length");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+
+ png_crc_read(png_ptr, buf, 2);
+ png_ptr->num_trans = 1;
+ png_ptr->trans_values.gray = png_get_uint_16(buf);
+ }
+ else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
+ {
+ png_byte buf[6];
+
+ if (length != 6)
+ {
+ png_warning(png_ptr, "Incorrect tRNS chunk length");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+ png_crc_read(png_ptr, buf, (png_size_t)length);
+ png_ptr->num_trans = 1;
+ png_ptr->trans_values.red = png_get_uint_16(buf);
+ png_ptr->trans_values.green = png_get_uint_16(buf + 2);
+ png_ptr->trans_values.blue = png_get_uint_16(buf + 4);
+ }
+ else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+ {
+ if (!(png_ptr->mode & PNG_HAVE_PLTE))
+ {
+ /* Should be an error, but we can cope with it. */
+ png_warning(png_ptr, "Missing PLTE before tRNS");
+ }
+ if (length > (png_uint_32)png_ptr->num_palette ||
+ length > PNG_MAX_PALETTE_LENGTH)
+ {
+ png_warning(png_ptr, "Incorrect tRNS chunk length");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+ if (length == 0)
+ {
+ png_warning(png_ptr, "Zero length tRNS chunk");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+ png_crc_read(png_ptr, readbuf, (png_size_t)length);
+ png_ptr->num_trans = (png_uint_16)length;
+ }
+ else
+ {
+ png_warning(png_ptr, "tRNS chunk not allowed with alpha channel");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+
+ if (png_crc_finish(png_ptr, 0))
+ {
+ png_ptr->num_trans = 0;
+ return;
+ }
+
+ png_set_tRNS(png_ptr, info_ptr, readbuf, png_ptr->num_trans,
+ &(png_ptr->trans_values));
+}
+#endif
+
+#if defined(PNG_READ_bKGD_SUPPORTED)
+void /* PRIVATE */
+png_handle_bKGD(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+ png_size_t truelen;
+ png_byte buf[6];
+
+ png_debug(1, "in png_handle_bKGD\n");
+
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))
+ png_error(png_ptr, "Missing IHDR before bKGD");
+ else if (png_ptr->mode & PNG_HAVE_IDAT)
+ {
+ png_warning(png_ptr, "Invalid bKGD after IDAT");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+ else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
+ !(png_ptr->mode & PNG_HAVE_PLTE))
+ {
+ png_warning(png_ptr, "Missing PLTE before bKGD");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+ else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD))
+ {
+ png_warning(png_ptr, "Duplicate bKGD chunk");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+
+ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+ truelen = 1;
+ else if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
+ truelen = 6;
+ else
+ truelen = 2;
+
+ if (length != truelen)
+ {
+ png_warning(png_ptr, "Incorrect bKGD chunk length");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+
+ png_crc_read(png_ptr, buf, truelen);
+ if (png_crc_finish(png_ptr, 0))
+ return;
+
+ /* We convert the index value into RGB components so that we can allow
+ * arbitrary RGB values for background when we have transparency, and
+ * so it is easy to determine the RGB values of the background color
+ * from the info_ptr struct. */
+ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+ {
+ png_ptr->background.index = buf[0];
+ if (info_ptr && info_ptr->num_palette)
+ {
+ if (buf[0] > info_ptr->num_palette)
+ {
+ png_warning(png_ptr, "Incorrect bKGD chunk index value");
+ return;
+ }
+ png_ptr->background.red =
+ (png_uint_16)png_ptr->palette[buf[0]].red;
+ png_ptr->background.green =
+ (png_uint_16)png_ptr->palette[buf[0]].green;
+ png_ptr->background.blue =
+ (png_uint_16)png_ptr->palette[buf[0]].blue;
+ }
+ }
+ else if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) /* GRAY */
+ {
+ png_ptr->background.red =
+ png_ptr->background.green =
+ png_ptr->background.blue =
+ png_ptr->background.gray = png_get_uint_16(buf);
+ }
+ else
+ {
+ png_ptr->background.red = png_get_uint_16(buf);
+ png_ptr->background.green = png_get_uint_16(buf + 2);
+ png_ptr->background.blue = png_get_uint_16(buf + 4);
+ }
+
+ png_set_bKGD(png_ptr, info_ptr, &(png_ptr->background));
+}
+#endif
+
+#if defined(PNG_READ_hIST_SUPPORTED)
+void /* PRIVATE */
+png_handle_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+ unsigned int num, i;
+ png_uint_16 readbuf[PNG_MAX_PALETTE_LENGTH];
+
+ png_debug(1, "in png_handle_hIST\n");
+
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))
+ png_error(png_ptr, "Missing IHDR before hIST");
+ else if (png_ptr->mode & PNG_HAVE_IDAT)
+ {
+ png_warning(png_ptr, "Invalid hIST after IDAT");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+ else if (!(png_ptr->mode & PNG_HAVE_PLTE))
+ {
+ png_warning(png_ptr, "Missing PLTE before hIST");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+ else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST))
+ {
+ png_warning(png_ptr, "Duplicate hIST chunk");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+
+ num = length / 2 ;
+ if (num != (unsigned int) png_ptr->num_palette || num >
+ (unsigned int) PNG_MAX_PALETTE_LENGTH)
+ {
+ png_warning(png_ptr, "Incorrect hIST chunk length");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+
+ for (i = 0; i < num; i++)
+ {
+ png_byte buf[2];
+
+ png_crc_read(png_ptr, buf, 2);
+ readbuf[i] = png_get_uint_16(buf);
+ }
+
+ if (png_crc_finish(png_ptr, 0))
+ return;
+
+ png_set_hIST(png_ptr, info_ptr, readbuf);
+}
+#endif
+
+#if defined(PNG_READ_pHYs_SUPPORTED)
+void /* PRIVATE */
+png_handle_pHYs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+ png_byte buf[9];
+ png_uint_32 res_x, res_y;
+ int unit_type;
+
+ png_debug(1, "in png_handle_pHYs\n");
+
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))
+ png_error(png_ptr, "Missing IHDR before pHYs");
+ else if (png_ptr->mode & PNG_HAVE_IDAT)
+ {
+ png_warning(png_ptr, "Invalid pHYs after IDAT");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+ else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
+ {
+ png_warning(png_ptr, "Duplicate pHYs chunk");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+
+ if (length != 9)
+ {
+ png_warning(png_ptr, "Incorrect pHYs chunk length");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+
+ png_crc_read(png_ptr, buf, 9);
+ if (png_crc_finish(png_ptr, 0))
+ return;
+
+ res_x = png_get_uint_32(buf);
+ res_y = png_get_uint_32(buf + 4);
+ unit_type = buf[8];
+ png_set_pHYs(png_ptr, info_ptr, res_x, res_y, unit_type);
+}
+#endif
+
+#if defined(PNG_READ_oFFs_SUPPORTED)
+void /* PRIVATE */
+png_handle_oFFs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+ png_byte buf[9];
+ png_int_32 offset_x, offset_y;
+ int unit_type;
+
+ png_debug(1, "in png_handle_oFFs\n");
+
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))
+ png_error(png_ptr, "Missing IHDR before oFFs");
+ else if (png_ptr->mode & PNG_HAVE_IDAT)
+ {
+ png_warning(png_ptr, "Invalid oFFs after IDAT");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+ else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
+ {
+ png_warning(png_ptr, "Duplicate oFFs chunk");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+
+ if (length != 9)
+ {
+ png_warning(png_ptr, "Incorrect oFFs chunk length");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+
+ png_crc_read(png_ptr, buf, 9);
+ if (png_crc_finish(png_ptr, 0))
+ return;
+
+ offset_x = png_get_int_32(buf);
+ offset_y = png_get_int_32(buf + 4);
+ unit_type = buf[8];
+ png_set_oFFs(png_ptr, info_ptr, offset_x, offset_y, unit_type);
+}
+#endif
+
+#if defined(PNG_READ_pCAL_SUPPORTED)
+/* read the pCAL chunk (described in the PNG Extensions document) */
+void /* PRIVATE */
+png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+ png_int_32 X0, X1;
+ png_byte type, nparams;
+ png_charp buf, units, endptr;
+ png_charpp params;
+ png_size_t slength;
+ int i;
+
+ png_debug(1, "in png_handle_pCAL\n");
+
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))
+ png_error(png_ptr, "Missing IHDR before pCAL");
+ else if (png_ptr->mode & PNG_HAVE_IDAT)
+ {
+ png_warning(png_ptr, "Invalid pCAL after IDAT");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+ else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL))
+ {
+ png_warning(png_ptr, "Duplicate pCAL chunk");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+
+ png_debug1(2, "Allocating and reading pCAL chunk data (%lu bytes)\n",
+ length + 1);
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
+ if (png_ptr->chunkdata == NULL)
+ {
+ png_warning(png_ptr, "No memory for pCAL purpose.");
+ return;
+ }
+ slength = (png_size_t)length;
+ png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
+
+ if (png_crc_finish(png_ptr, 0))
+ {
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ return;
+ }
+
+ png_ptr->chunkdata[slength] = 0x00; /* null terminate the last string */
+
+ png_debug(3, "Finding end of pCAL purpose string\n");
+ for (buf = png_ptr->chunkdata; *buf; buf++)
+ /* empty loop */ ;
+
+ endptr = png_ptr->chunkdata + slength;
+
+ /* We need to have at least 12 bytes after the purpose string
+ in order to get the parameter information. */
+ if (endptr <= buf + 12)
+ {
+ png_warning(png_ptr, "Invalid pCAL data");
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ return;
+ }
+
+ png_debug(3, "Reading pCAL X0, X1, type, nparams, and units\n");
+ X0 = png_get_int_32((png_bytep)buf+1);
+ X1 = png_get_int_32((png_bytep)buf+5);
+ type = buf[9];
+ nparams = buf[10];
+ units = buf + 11;
+
+ png_debug(3, "Checking pCAL equation type and number of parameters\n");
+ /* Check that we have the right number of parameters for known
+ equation types. */
+ if ((type == PNG_EQUATION_LINEAR && nparams != 2) ||
+ (type == PNG_EQUATION_BASE_E && nparams != 3) ||
+ (type == PNG_EQUATION_ARBITRARY && nparams != 3) ||
+ (type == PNG_EQUATION_HYPERBOLIC && nparams != 4))
+ {
+ png_warning(png_ptr, "Invalid pCAL parameters for equation type");
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ return;
+ }
+ else if (type >= PNG_EQUATION_LAST)
+ {
+ png_warning(png_ptr, "Unrecognized equation type for pCAL chunk");
+ }
+
+ for (buf = units; *buf; buf++)
+ /* Empty loop to move past the units string. */ ;
+
+ png_debug(3, "Allocating pCAL parameters array\n");
+ params = (png_charpp)png_malloc_warn(png_ptr,
+ (png_uint_32)(nparams * png_sizeof(png_charp))) ;
+ if (params == NULL)
+ {
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ png_warning(png_ptr, "No memory for pCAL params.");
+ return;
+ }
+
+ /* Get pointers to the start of each parameter string. */
+ for (i = 0; i < (int)nparams; i++)
+ {
+ buf++; /* Skip the null string terminator from previous parameter. */
+
+ png_debug1(3, "Reading pCAL parameter %d\n", i);
+ for (params[i] = buf; buf <= endptr && *buf != 0x00; buf++)
+ /* Empty loop to move past each parameter string */ ;
+
+ /* Make sure we haven't run out of data yet */
+ if (buf > endptr)
+ {
+ png_warning(png_ptr, "Invalid pCAL data");
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ png_free(png_ptr, params);
+ return;
+ }
+ }
+
+ png_set_pCAL(png_ptr, info_ptr, png_ptr->chunkdata, X0, X1, type, nparams,
+ units, params);
+
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ png_free(png_ptr, params);
+}
+#endif
+
+#if defined(PNG_READ_sCAL_SUPPORTED)
+/* read the sCAL chunk */
+void /* PRIVATE */
+png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+ png_charp ep;
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+ double width, height;
+ png_charp vp;
+#else
+#ifdef PNG_FIXED_POINT_SUPPORTED
+ png_charp swidth, sheight;
+#endif
+#endif
+ png_size_t slength;
+
+ png_debug(1, "in png_handle_sCAL\n");
+
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))
+ png_error(png_ptr, "Missing IHDR before sCAL");
+ else if (png_ptr->mode & PNG_HAVE_IDAT)
+ {
+ png_warning(png_ptr, "Invalid sCAL after IDAT");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+ else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sCAL))
+ {
+ png_warning(png_ptr, "Duplicate sCAL chunk");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+
+ png_debug1(2, "Allocating and reading sCAL chunk data (%lu bytes)\n",
+ length + 1);
+ png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
+ if (png_ptr->chunkdata == NULL)
+ {
+ png_warning(png_ptr, "Out of memory while processing sCAL chunk");
+ return;
+ }
+ slength = (png_size_t)length;
+ png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
+
+ if (png_crc_finish(png_ptr, 0))
+ {
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ return;
+ }
+
+ png_ptr->chunkdata[slength] = 0x00; /* null terminate the last string */
+
+ ep = png_ptr->chunkdata + 1; /* skip unit byte */
+
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+ width = png_strtod(png_ptr, ep, &vp);
+ if (*vp)
+ {
+ png_warning(png_ptr, "malformed width string in sCAL chunk");
+ return;
+ }
+#else
+#ifdef PNG_FIXED_POINT_SUPPORTED
+ swidth = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1);
+ if (swidth == NULL)
+ {
+ png_warning(png_ptr, "Out of memory while processing sCAL chunk width");
+ return;
+ }
+ png_memcpy(swidth, ep, (png_size_t)png_strlen(ep));
+#endif
+#endif
+
+ for (ep = png_ptr->chunkdata; *ep; ep++)
+ /* empty loop */ ;
+ ep++;
+
+ if (png_ptr->chunkdata + slength < ep)
+ {
+ png_warning(png_ptr, "Truncated sCAL chunk");
+#if defined(PNG_FIXED_POINT_SUPPORTED) && \
+ !defined(PNG_FLOATING_POINT_SUPPORTED)
+ png_free(png_ptr, swidth);
+#endif
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ return;
+ }
+
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+ height = png_strtod(png_ptr, ep, &vp);
+ if (*vp)
+ {
+ png_warning(png_ptr, "malformed height string in sCAL chunk");
+ return;
+ }
+#else
+#ifdef PNG_FIXED_POINT_SUPPORTED
+ sheight = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1);
+ if (sheight == NULL)
+ {
+ png_warning(png_ptr, "Out of memory while processing sCAL chunk height");
+ return;
+ }
+ png_memcpy(sheight, ep, (png_size_t)png_strlen(ep));
+#endif
+#endif
+
+ if (png_ptr->chunkdata + slength < ep
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+ || width <= 0. || height <= 0.
+#endif
+ )
+ {
+ png_warning(png_ptr, "Invalid sCAL data");
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)
+ png_free(png_ptr, swidth);
+ png_free(png_ptr, sheight);
+#endif
+ return;
+ }
+
+
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+ png_set_sCAL(png_ptr, info_ptr, png_ptr->chunkdata[0], width, height);
+#else
+#ifdef PNG_FIXED_POINT_SUPPORTED
+ png_set_sCAL_s(png_ptr, info_ptr, png_ptr->chunkdata[0], swidth, sheight);
+#endif
+#endif
+
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)
+ png_free(png_ptr, swidth);
+ png_free(png_ptr, sheight);
+#endif
+}
+#endif
+
+#if defined(PNG_READ_tIME_SUPPORTED)
+void /* PRIVATE */
+png_handle_tIME(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+ png_byte buf[7];
+ png_time mod_time;
+
+ png_debug(1, "in png_handle_tIME\n");
+
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))
+ png_error(png_ptr, "Out of place tIME chunk");
+ else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME))
+ {
+ png_warning(png_ptr, "Duplicate tIME chunk");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+
+ if (png_ptr->mode & PNG_HAVE_IDAT)
+ png_ptr->mode |= PNG_AFTER_IDAT;
+
+ if (length != 7)
+ {
+ png_warning(png_ptr, "Incorrect tIME chunk length");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+
+ png_crc_read(png_ptr, buf, 7);
+ if (png_crc_finish(png_ptr, 0))
+ return;
+
+ mod_time.second = buf[6];
+ mod_time.minute = buf[5];
+ mod_time.hour = buf[4];
+ mod_time.day = buf[3];
+ mod_time.month = buf[2];
+ mod_time.year = png_get_uint_16(buf);
+
+ png_set_tIME(png_ptr, info_ptr, &mod_time);
+}
+#endif
+
+#if defined(PNG_READ_tEXt_SUPPORTED)
+/* Note: this does not properly handle chunks that are > 64K under DOS */
+void /* PRIVATE */
+png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+ png_textp text_ptr;
+ png_charp key;
+ png_charp text;
+ png_uint_32 skip = 0;
+ png_size_t slength;
+ int ret;
+
+ png_debug(1, "in png_handle_tEXt\n");
+
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))
+ png_error(png_ptr, "Missing IHDR before tEXt");
+
+ if (png_ptr->mode & PNG_HAVE_IDAT)
+ png_ptr->mode |= PNG_AFTER_IDAT;
+
+#ifdef PNG_MAX_MALLOC_64K
+ if (length > (png_uint_32)65535L)
+ {
+ png_warning(png_ptr, "tEXt chunk too large to fit in memory");
+ skip = length - (png_uint_32)65535L;
+ length = (png_uint_32)65535L;
+ }
+#endif
+
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
+ if (png_ptr->chunkdata == NULL)
+ {
+ png_warning(png_ptr, "No memory to process text chunk.");
+ return;
+ }
+ slength = (png_size_t)length;
+ png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
+
+ if (png_crc_finish(png_ptr, skip))
+ {
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ return;
+ }
+
+ key = png_ptr->chunkdata;
+ key[slength] = 0x00;
+
+ for (text = key; *text; text++)
+ /* empty loop to find end of key */ ;
+
+ if (text != key + slength)
+ text++;
+
+ text_ptr = (png_textp)png_malloc_warn(png_ptr,
+ (png_uint_32)png_sizeof(png_text));
+ if (text_ptr == NULL)
+ {
+ png_warning(png_ptr, "Not enough memory to process text chunk.");
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ return;
+ }
+ text_ptr->compression = PNG_TEXT_COMPRESSION_NONE;
+ text_ptr->key = key;
+#ifdef PNG_iTXt_SUPPORTED
+ text_ptr->lang = NULL;
+ text_ptr->lang_key = NULL;
+ text_ptr->itxt_length = 0;
+#endif
+ text_ptr->text = text;
+ text_ptr->text_length = png_strlen(text);
+
+ ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
+
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ png_free(png_ptr, text_ptr);
+ if (ret)
+ png_warning(png_ptr, "Insufficient memory to process text chunk.");
+}
+#endif
+
+#if defined(PNG_READ_zTXt_SUPPORTED)
+/* note: this does not correctly handle chunks that are > 64K under DOS */
+void /* PRIVATE */
+png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+ png_textp text_ptr;
+ png_charp text;
+ int comp_type;
+ int ret;
+ png_size_t slength, prefix_len, data_len;
+
+ png_debug(1, "in png_handle_zTXt\n");
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))
+ png_error(png_ptr, "Missing IHDR before zTXt");
+
+ if (png_ptr->mode & PNG_HAVE_IDAT)
+ png_ptr->mode |= PNG_AFTER_IDAT;
+
+#ifdef PNG_MAX_MALLOC_64K
+ /* We will no doubt have problems with chunks even half this size, but
+ there is no hard and fast rule to tell us where to stop. */
+ if (length > (png_uint_32)65535L)
+ {
+ png_warning(png_ptr, "zTXt chunk too large to fit in memory");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+#endif
+
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
+ if (png_ptr->chunkdata == NULL)
+ {
+ png_warning(png_ptr, "Out of memory processing zTXt chunk.");
+ return;
+ }
+ slength = (png_size_t)length;
+ png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
+ if (png_crc_finish(png_ptr, 0))
+ {
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ return;
+ }
+
+ png_ptr->chunkdata[slength] = 0x00;
+
+ for (text = png_ptr->chunkdata; *text; text++)
+ /* empty loop */ ;
+
+ /* zTXt must have some text after the chunkdataword */
+ if (text >= png_ptr->chunkdata + slength - 2)
+ {
+ png_warning(png_ptr, "Truncated zTXt chunk");
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ return;
+ }
+ else
+ {
+ comp_type = *(++text);
+ if (comp_type != PNG_TEXT_COMPRESSION_zTXt)
+ {
+ png_warning(png_ptr, "Unknown compression type in zTXt chunk");
+ comp_type = PNG_TEXT_COMPRESSION_zTXt;
+ }
+ text++; /* skip the compression_method byte */
+ }
+ prefix_len = text - png_ptr->chunkdata;
+
+ png_decompress_chunk(png_ptr, comp_type,
+ (png_size_t)length, prefix_len, &data_len);
+
+ text_ptr = (png_textp)png_malloc_warn(png_ptr,
+ (png_uint_32)png_sizeof(png_text));
+ if (text_ptr == NULL)
+ {
+ png_warning(png_ptr, "Not enough memory to process zTXt chunk.");
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ return;
+ }
+ text_ptr->compression = comp_type;
+ text_ptr->key = png_ptr->chunkdata;
+#ifdef PNG_iTXt_SUPPORTED
+ text_ptr->lang = NULL;
+ text_ptr->lang_key = NULL;
+ text_ptr->itxt_length = 0;
+#endif
+ text_ptr->text = png_ptr->chunkdata + prefix_len;
+ text_ptr->text_length = data_len;
+
+ ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
+
+ png_free(png_ptr, text_ptr);
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ if (ret)
+ png_error(png_ptr, "Insufficient memory to store zTXt chunk.");
+}
+#endif
+
+#if defined(PNG_READ_iTXt_SUPPORTED)
+/* note: this does not correctly handle chunks that are > 64K under DOS */
+void /* PRIVATE */
+png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+ png_textp text_ptr;
+ png_charp key, lang, text, lang_key;
+ int comp_flag;
+ int comp_type = 0;
+ int ret;
+ png_size_t slength, prefix_len, data_len;
+
+ png_debug(1, "in png_handle_iTXt\n");
+
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))
+ png_error(png_ptr, "Missing IHDR before iTXt");
+
+ if (png_ptr->mode & PNG_HAVE_IDAT)
+ png_ptr->mode |= PNG_AFTER_IDAT;
+
+#ifdef PNG_MAX_MALLOC_64K
+ /* We will no doubt have problems with chunks even half this size, but
+ there is no hard and fast rule to tell us where to stop. */
+ if (length > (png_uint_32)65535L)
+ {
+ png_warning(png_ptr, "iTXt chunk too large to fit in memory");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+#endif
+
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
+ if (png_ptr->chunkdata == NULL)
+ {
+ png_warning(png_ptr, "No memory to process iTXt chunk.");
+ return;
+ }
+ slength = (png_size_t)length;
+ png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
+ if (png_crc_finish(png_ptr, 0))
+ {
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ return;
+ }
+
+ png_ptr->chunkdata[slength] = 0x00;
+
+ for (lang = png_ptr->chunkdata; *lang; lang++)
+ /* empty loop */ ;
+ lang++; /* skip NUL separator */
+
+ /* iTXt must have a language tag (possibly empty), two compression bytes,
+ translated keyword (possibly empty), and possibly some text after the
+ keyword */
+
+ if (lang >= png_ptr->chunkdata + slength - 3)
+ {
+ png_warning(png_ptr, "Truncated iTXt chunk");
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ return;
+ }
+ else
+ {
+ comp_flag = *lang++;
+ comp_type = *lang++;
+ }
+
+ for (lang_key = lang; *lang_key; lang_key++)
+ /* empty loop */ ;
+ lang_key++; /* skip NUL separator */
+
+ if (lang_key >= png_ptr->chunkdata + slength)
+ {
+ png_warning(png_ptr, "Truncated iTXt chunk");
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ return;
+ }
+
+ for (text = lang_key; *text; text++)
+ /* empty loop */ ;
+ text++; /* skip NUL separator */
+ if (text >= png_ptr->chunkdata + slength)
+ {
+ png_warning(png_ptr, "Malformed iTXt chunk");
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ return;
+ }
+
+ prefix_len = text - png_ptr->chunkdata;
+
+ key=png_ptr->chunkdata;
+ if (comp_flag)
+ png_decompress_chunk(png_ptr, comp_type,
+ (size_t)length, prefix_len, &data_len);
+ else
+ data_len = png_strlen(png_ptr->chunkdata + prefix_len);
+ text_ptr = (png_textp)png_malloc_warn(png_ptr,
+ (png_uint_32)png_sizeof(png_text));
+ if (text_ptr == NULL)
+ {
+ png_warning(png_ptr, "Not enough memory to process iTXt chunk.");
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ return;
+ }
+ text_ptr->compression = (int)comp_flag + 1;
+ text_ptr->lang_key = png_ptr->chunkdata + (lang_key - key);
+ text_ptr->lang = png_ptr->chunkdata + (lang - key);
+ text_ptr->itxt_length = data_len;
+ text_ptr->text_length = 0;
+ text_ptr->key = png_ptr->chunkdata;
+ text_ptr->text = png_ptr->chunkdata + prefix_len;
+
+ ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
+
+ png_free(png_ptr, text_ptr);
+ png_free(png_ptr, png_ptr->chunkdata);
+ png_ptr->chunkdata = NULL;
+ if (ret)
+ png_error(png_ptr, "Insufficient memory to store iTXt chunk.");
+}
+#endif
+
+/* This function is called when we haven't found a handler for a
+ chunk. If there isn't a problem with the chunk itself (ie bad
+ chunk name, CRC, or a critical chunk), the chunk is silently ignored
+ -- unless the PNG_FLAG_UNKNOWN_CHUNKS_SUPPORTED flag is on in which
+ case it will be saved away to be written out later. */
+void /* PRIVATE */
+png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+ png_uint_32 skip = 0;
+
+ png_debug(1, "in png_handle_unknown\n");
+
+ if (png_ptr->mode & PNG_HAVE_IDAT)
+ {
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_CONST PNG_IDAT;
+#endif
+ if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) /* not an IDAT */
+ png_ptr->mode |= PNG_AFTER_IDAT;
+ }
+
+ if (!(png_ptr->chunk_name[0] & 0x20))
+ {
+#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
+ if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
+ PNG_HANDLE_CHUNK_ALWAYS
+#if defined(PNG_READ_USER_CHUNKS_SUPPORTED)
+ && png_ptr->read_user_chunk_fn == NULL
+#endif
+ )
+#endif
+ png_chunk_error(png_ptr, "unknown critical chunk");
+ }
+
+#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
+ if ((png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS) ||
+ (png_ptr->read_user_chunk_fn != NULL))
+ {
+#ifdef PNG_MAX_MALLOC_64K
+ if (length > (png_uint_32)65535L)
+ {
+ png_warning(png_ptr, "unknown chunk too large to fit in memory");
+ skip = length - (png_uint_32)65535L;
+ length = (png_uint_32)65535L;
+ }
+#endif
+ png_memcpy((png_charp)png_ptr->unknown_chunk.name,
+ (png_charp)png_ptr->chunk_name,
+ png_sizeof(png_ptr->unknown_chunk.name));
+ png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name)-1] = '\0';
+ png_ptr->unknown_chunk.size = (png_size_t)length;
+ if (length == 0)
+ png_ptr->unknown_chunk.data = NULL;
+ else
+ {
+ png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr, length);
+ png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length);
+ }
+#if defined(PNG_READ_USER_CHUNKS_SUPPORTED)
+ if (png_ptr->read_user_chunk_fn != NULL)
+ {
+ /* callback to user unknown chunk handler */
+ int ret;
+ ret = (*(png_ptr->read_user_chunk_fn))
+ (png_ptr, &png_ptr->unknown_chunk);
+ if (ret < 0)
+ png_chunk_error(png_ptr, "error in user chunk");
+ if (ret == 0)
+ {
+ if (!(png_ptr->chunk_name[0] & 0x20))
+ if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
+ PNG_HANDLE_CHUNK_ALWAYS)
+ png_chunk_error(png_ptr, "unknown critical chunk");
+ png_set_unknown_chunks(png_ptr, info_ptr,
+ &png_ptr->unknown_chunk, 1);
+ }
+ }
+ else
+#endif
+ png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1);
+ png_free(png_ptr, png_ptr->unknown_chunk.data);
+ png_ptr->unknown_chunk.data = NULL;
+ }
+ else
+#endif
+ skip = length;
+
+ png_crc_finish(png_ptr, skip);
+
+#if !defined(PNG_READ_USER_CHUNKS_SUPPORTED)
+ info_ptr = info_ptr; /* quiet compiler warnings about unused info_ptr */
+#endif
+}
+
+/* This function is called to verify that a chunk name is valid.
+ This function can't have the "critical chunk check" incorporated
+ into it, since in the future we will need to be able to call user
+ functions to handle unknown critical chunks after we check that
+ the chunk name itself is valid. */
+
+#define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))
+
+void /* PRIVATE */
+png_check_chunk_name(png_structp png_ptr, png_bytep chunk_name)
+{
+ png_debug(1, "in png_check_chunk_name\n");
+ if (isnonalpha(chunk_name[0]) || isnonalpha(chunk_name[1]) ||
+ isnonalpha(chunk_name[2]) || isnonalpha(chunk_name[3]))
+ {
+ png_chunk_error(png_ptr, "invalid chunk type");
+ }
+}
+
+/* Combines the row recently read in with the existing pixels in the
+ row. This routine takes care of alpha and transparency if requested.
+ This routine also handles the two methods of progressive display
+ of interlaced images, depending on the mask value.
+ The mask value describes which pixels are to be combined with
+ the row. The pattern always repeats every 8 pixels, so just 8
+ bits are needed. A one indicates the pixel is to be combined,
+ a zero indicates the pixel is to be skipped. This is in addition
+ to any alpha or transparency value associated with the pixel. If
+ you want all pixels to be combined, pass 0xff (255) in mask. */
+
+void /* PRIVATE */
+png_combine_row(png_structp png_ptr, png_bytep row, int mask)
+{
+ png_debug(1, "in png_combine_row\n");
+ if (mask == 0xff)
+ {
+ png_memcpy(row, png_ptr->row_buf + 1,
+ PNG_ROWBYTES(png_ptr->row_info.pixel_depth, png_ptr->width));
+ }
+ else
+ {
+ switch (png_ptr->row_info.pixel_depth)
+ {
+ case 1:
+ {
+ png_bytep sp = png_ptr->row_buf + 1;
+ png_bytep dp = row;
+ int s_inc, s_start, s_end;
+ int m = 0x80;
+ int shift;
+ png_uint_32 i;
+ png_uint_32 row_width = png_ptr->width;
+
+#if defined(PNG_READ_PACKSWAP_SUPPORTED)
+ if (png_ptr->transformations & PNG_PACKSWAP)
+ {
+ s_start = 0;
+ s_end = 7;
+ s_inc = 1;
+ }
+ else
+#endif
+ {
+ s_start = 7;
+ s_end = 0;
+ s_inc = -1;
+ }
+
+ shift = s_start;
+
+ for (i = 0; i < row_width; i++)
+ {
+ if (m & mask)
+ {
+ int value;
+
+ value = (*sp >> shift) & 0x01;
+ *dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff);
+ *dp |= (png_byte)(value << shift);
+ }
+
+ if (shift == s_end)
+ {
+ shift = s_start;
+ sp++;
+ dp++;
+ }
+ else
+ shift += s_inc;
+
+ if (m == 1)
+ m = 0x80;
+ else
+ m >>= 1;
+ }
+ break;
+ }
+ case 2:
+ {
+ png_bytep sp = png_ptr->row_buf + 1;
+ png_bytep dp = row;
+ int s_start, s_end, s_inc;
+ int m = 0x80;
+ int shift;
+ png_uint_32 i;
+ png_uint_32 row_width = png_ptr->width;
+ int value;
+
+#if defined(PNG_READ_PACKSWAP_SUPPORTED)
+ if (png_ptr->transformations & PNG_PACKSWAP)
+ {
+ s_start = 0;
+ s_end = 6;
+ s_inc = 2;
+ }
+ else
+#endif
+ {
+ s_start = 6;
+ s_end = 0;
+ s_inc = -2;
+ }
+
+ shift = s_start;
+
+ for (i = 0; i < row_width; i++)
+ {
+ if (m & mask)
+ {
+ value = (*sp >> shift) & 0x03;
+ *dp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
+ *dp |= (png_byte)(value << shift);
+ }
+
+ if (shift == s_end)
+ {
+ shift = s_start;
+ sp++;
+ dp++;
+ }
+ else
+ shift += s_inc;
+ if (m == 1)
+ m = 0x80;
+ else
+ m >>= 1;
+ }
+ break;
+ }
+ case 4:
+ {
+ png_bytep sp = png_ptr->row_buf + 1;
+ png_bytep dp = row;
+ int s_start, s_end, s_inc;
+ int m = 0x80;
+ int shift;
+ png_uint_32 i;
+ png_uint_32 row_width = png_ptr->width;
+ int value;
+
+#if defined(PNG_READ_PACKSWAP_SUPPORTED)
+ if (png_ptr->transformations & PNG_PACKSWAP)
+ {
+ s_start = 0;
+ s_end = 4;
+ s_inc = 4;
+ }
+ else
+#endif
+ {
+ s_start = 4;
+ s_end = 0;
+ s_inc = -4;
+ }
+ shift = s_start;
+
+ for (i = 0; i < row_width; i++)
+ {
+ if (m & mask)
+ {
+ value = (*sp >> shift) & 0xf;
+ *dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
+ *dp |= (png_byte)(value << shift);
+ }
+
+ if (shift == s_end)
+ {
+ shift = s_start;
+ sp++;
+ dp++;
+ }
+ else
+ shift += s_inc;
+ if (m == 1)
+ m = 0x80;
+ else
+ m >>= 1;
+ }
+ break;
+ }
+ default:
+ {
+ png_bytep sp = png_ptr->row_buf + 1;
+ png_bytep dp = row;
+ png_size_t pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
+ png_uint_32 i;
+ png_uint_32 row_width = png_ptr->width;
+ png_byte m = 0x80;
+
+
+ for (i = 0; i < row_width; i++)
+ {
+ if (m & mask)
+ {
+ png_memcpy(dp, sp, pixel_bytes);
+ }
+
+ sp += pixel_bytes;
+ dp += pixel_bytes;
+
+ if (m == 1)
+ m = 0x80;
+ else
+ m >>= 1;
+ }
+ break;
+ }
+ }
+ }
+}
+
+#ifdef PNG_READ_INTERLACING_SUPPORTED
+/* OLD pre-1.0.9 interface:
+void png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
+ png_uint_32 transformations)
+ */
+void /* PRIVATE */
+png_do_read_interlace(png_structp png_ptr)
+{
+ png_row_infop row_info = &(png_ptr->row_info);
+ png_bytep row = png_ptr->row_buf + 1;
+ int pass = png_ptr->pass;
+ png_uint_32 transformations = png_ptr->transformations;
+#ifdef PNG_USE_LOCAL_ARRAYS
+ /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
+ /* offset to next interlace block */
+ PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
+#endif
+
+ png_debug(1, "in png_do_read_interlace\n");
+ if (row != NULL && row_info != NULL)
+ {
+ png_uint_32 final_width;
+
+ final_width = row_info->width * png_pass_inc[pass];
+
+ switch (row_info->pixel_depth)
+ {
+ case 1:
+ {
+ png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 3);
+ png_bytep dp = row + (png_size_t)((final_width - 1) >> 3);
+ int sshift, dshift;
+ int s_start, s_end, s_inc;
+ int jstop = png_pass_inc[pass];
+ png_byte v;
+ png_uint_32 i;
+ int j;
+
+#if defined(PNG_READ_PACKSWAP_SUPPORTED)
+ if (transformations & PNG_PACKSWAP)
+ {
+ sshift = (int)((row_info->width + 7) & 0x07);
+ dshift = (int)((final_width + 7) & 0x07);
+ s_start = 7;
+ s_end = 0;
+ s_inc = -1;
+ }
+ else
+#endif
+ {
+ sshift = 7 - (int)((row_info->width + 7) & 0x07);
+ dshift = 7 - (int)((final_width + 7) & 0x07);
+ s_start = 0;
+ s_end = 7;
+ s_inc = 1;
+ }
+
+ for (i = 0; i < row_info->width; i++)
+ {
+ v = (png_byte)((*sp >> sshift) & 0x01);
+ for (j = 0; j < jstop; j++)
+ {
+ *dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff);
+ *dp |= (png_byte)(v << dshift);
+ if (dshift == s_end)
+ {
+ dshift = s_start;
+ dp--;
+ }
+ else
+ dshift += s_inc;
+ }
+ if (sshift == s_end)
+ {
+ sshift = s_start;
+ sp--;
+ }
+ else
+ sshift += s_inc;
+ }
+ break;
+ }
+ case 2:
+ {
+ png_bytep sp = row + (png_uint_32)((row_info->width - 1) >> 2);
+ png_bytep dp = row + (png_uint_32)((final_width - 1) >> 2);
+ int sshift, dshift;
+ int s_start, s_end, s_inc;
+ int jstop = png_pass_inc[pass];
+ png_uint_32 i;
+
+#if defined(PNG_READ_PACKSWAP_SUPPORTED)
+ if (transformations & PNG_PACKSWAP)
+ {
+ sshift = (int)(((row_info->width + 3) & 0x03) << 1);
+ dshift = (int)(((final_width + 3) & 0x03) << 1);
+ s_start = 6;
+ s_end = 0;
+ s_inc = -2;
+ }
+ else
+#endif
+ {
+ sshift = (int)((3 - ((row_info->width + 3) & 0x03)) << 1);
+ dshift = (int)((3 - ((final_width + 3) & 0x03)) << 1);
+ s_start = 0;
+ s_end = 6;
+ s_inc = 2;
+ }
+
+ for (i = 0; i < row_info->width; i++)
+ {
+ png_byte v;
+ int j;
+
+ v = (png_byte)((*sp >> sshift) & 0x03);
+ for (j = 0; j < jstop; j++)
+ {
+ *dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff);
+ *dp |= (png_byte)(v << dshift);
+ if (dshift == s_end)
+ {
+ dshift = s_start;
+ dp--;
+ }
+ else
+ dshift += s_inc;
+ }
+ if (sshift == s_end)
+ {
+ sshift = s_start;
+ sp--;
+ }
+ else
+ sshift += s_inc;
+ }
+ break;
+ }
+ case 4:
+ {
+ png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 1);
+ png_bytep dp = row + (png_size_t)((final_width - 1) >> 1);
+ int sshift, dshift;
+ int s_start, s_end, s_inc;
+ png_uint_32 i;
+ int jstop = png_pass_inc[pass];
+
+#if defined(PNG_READ_PACKSWAP_SUPPORTED)
+ if (transformations & PNG_PACKSWAP)
+ {
+ sshift = (int)(((row_info->width + 1) & 0x01) << 2);
+ dshift = (int)(((final_width + 1) & 0x01) << 2);
+ s_start = 4;
+ s_end = 0;
+ s_inc = -4;
+ }
+ else
+#endif
+ {
+ sshift = (int)((1 - ((row_info->width + 1) & 0x01)) << 2);
+ dshift = (int)((1 - ((final_width + 1) & 0x01)) << 2);
+ s_start = 0;
+ s_end = 4;
+ s_inc = 4;
+ }
+
+ for (i = 0; i < row_info->width; i++)
+ {
+ png_byte v = (png_byte)((*sp >> sshift) & 0xf);
+ int j;
+
+ for (j = 0; j < jstop; j++)
+ {
+ *dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff);
+ *dp |= (png_byte)(v << dshift);
+ if (dshift == s_end)
+ {
+ dshift = s_start;
+ dp--;
+ }
+ else
+ dshift += s_inc;
+ }
+ if (sshift == s_end)
+ {
+ sshift = s_start;
+ sp--;
+ }
+ else
+ sshift += s_inc;
+ }
+ break;
+ }
+ default:
+ {
+ png_size_t pixel_bytes = (row_info->pixel_depth >> 3);
+ png_bytep sp = row + (png_size_t)(row_info->width - 1) * pixel_bytes;
+ png_bytep dp = row + (png_size_t)(final_width - 1) * pixel_bytes;
+
+ int jstop = png_pass_inc[pass];
+ png_uint_32 i;
+
+ for (i = 0; i < row_info->width; i++)
+ {
+ png_byte v[8];
+ int j;
+
+ png_memcpy(v, sp, pixel_bytes);
+ for (j = 0; j < jstop; j++)
+ {
+ png_memcpy(dp, v, pixel_bytes);
+ dp -= pixel_bytes;
+ }
+ sp -= pixel_bytes;
+ }
+ break;
+ }
+ }
+ row_info->width = final_width;
+ row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, final_width);
+ }
+#if !defined(PNG_READ_PACKSWAP_SUPPORTED)
+ transformations = transformations; /* silence compiler warning */
+#endif
+}
+#endif /* PNG_READ_INTERLACING_SUPPORTED */
+
+void /* PRIVATE */
+png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row,
+ png_bytep prev_row, int filter)
+{
+ png_debug(1, "in png_read_filter_row\n");
+ png_debug2(2, "row = %lu, filter = %d\n", png_ptr->row_number, filter);
+ switch (filter)
+ {
+ case PNG_FILTER_VALUE_NONE:
+ break;
+ case PNG_FILTER_VALUE_SUB:
+ {
+ png_uint_32 i;
+ png_uint_32 istop = row_info->rowbytes;
+ png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;
+ png_bytep rp = row + bpp;
+ png_bytep lp = row;
+
+ for (i = bpp; i < istop; i++)
+ {
+ *rp = (png_byte)(((int)(*rp) + (int)(*lp++)) & 0xff);
+ rp++;
+ }
+ break;
+ }
+ case PNG_FILTER_VALUE_UP:
+ {
+ png_uint_32 i;
+ png_uint_32 istop = row_info->rowbytes;
+ png_bytep rp = row;
+ png_bytep pp = prev_row;
+
+ for (i = 0; i < istop; i++)
+ {
+ *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);
+ rp++;
+ }
+ break;
+ }
+ case PNG_FILTER_VALUE_AVG:
+ {
+ png_uint_32 i;
+ png_bytep rp = row;
+ png_bytep pp = prev_row;
+ png_bytep lp = row;
+ png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;
+ png_uint_32 istop = row_info->rowbytes - bpp;
+
+ for (i = 0; i < bpp; i++)
+ {
+ *rp = (png_byte)(((int)(*rp) +
+ ((int)(*pp++) / 2 )) & 0xff);
+ rp++;
+ }
+
+ for (i = 0; i < istop; i++)
+ {
+ *rp = (png_byte)(((int)(*rp) +
+ (int)(*pp++ + *lp++) / 2 ) & 0xff);
+ rp++;
+ }
+ break;
+ }
+ case PNG_FILTER_VALUE_PAETH:
+ {
+ png_uint_32 i;
+ png_bytep rp = row;
+ png_bytep pp = prev_row;
+ png_bytep lp = row;
+ png_bytep cp = prev_row;
+ png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;
+ png_uint_32 istop=row_info->rowbytes - bpp;
+
+ for (i = 0; i < bpp; i++)
+ {
+ *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);
+ rp++;
+ }
+
+ for (i = 0; i < istop; i++) /* use leftover rp,pp */
+ {
+ int a, b, c, pa, pb, pc, p;
+
+ a = *lp++;
+ b = *pp++;
+ c = *cp++;
+
+ p = b - c;
+ pc = a - c;
+
+#ifdef PNG_USE_ABS
+ pa = abs(p);
+ pb = abs(pc);
+ pc = abs(p + pc);
+#else
+ pa = p < 0 ? -p : p;
+ pb = pc < 0 ? -pc : pc;
+ pc = (p + pc) < 0 ? -(p + pc) : p + pc;
+#endif
+
+ /*
+ if (pa <= pb && pa <= pc)
+ p = a;
+ else if (pb <= pc)
+ p = b;
+ else
+ p = c;
+ */
+
+ p = (pa <= pb && pa <= pc) ? a : (pb <= pc) ? b : c;
+
+ *rp = (png_byte)(((int)(*rp) + p) & 0xff);
+ rp++;
+ }
+ break;
+ }
+ default:
+ png_warning(png_ptr, "Ignoring bad adaptive filter type");
+ *row = 0;
+ break;
+ }
+}
+
+void /* PRIVATE */
+png_read_finish_row(png_structp png_ptr)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+#ifdef PNG_READ_INTERLACING_SUPPORTED
+ /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
+
+ /* start of interlace block */
+ PNG_CONST int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
+
+ /* offset to next interlace block */
+ PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
+
+ /* start of interlace block in the y direction */
+ PNG_CONST int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
+
+ /* offset to next interlace block in the y direction */
+ PNG_CONST int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
+#endif /* PNG_READ_INTERLACING_SUPPORTED */
+#endif
+
+ png_debug(1, "in png_read_finish_row\n");
+ png_ptr->row_number++;
+ if (png_ptr->row_number < png_ptr->num_rows)
+ return;
+
+#ifdef PNG_READ_INTERLACING_SUPPORTED
+ if (png_ptr->interlaced)
+ {
+ png_ptr->row_number = 0;
+ png_memset_check(png_ptr, png_ptr->prev_row, 0,
+ png_ptr->rowbytes + 1);
+ do
+ {
+ png_ptr->pass++;
+ if (png_ptr->pass >= 7)
+ break;
+ png_ptr->iwidth = (png_ptr->width +
+ png_pass_inc[png_ptr->pass] - 1 -
+ png_pass_start[png_ptr->pass]) /
+ png_pass_inc[png_ptr->pass];
+
+ png_ptr->irowbytes = PNG_ROWBYTES(png_ptr->pixel_depth,
+ png_ptr->iwidth) + 1;
+
+ if (!(png_ptr->transformations & PNG_INTERLACE))
+ {
+ png_ptr->num_rows = (png_ptr->height +
+ png_pass_yinc[png_ptr->pass] - 1 -
+ png_pass_ystart[png_ptr->pass]) /
+ png_pass_yinc[png_ptr->pass];
+ if (!(png_ptr->num_rows))
+ continue;
+ }
+ else /* if (png_ptr->transformations & PNG_INTERLACE) */
+ break;
+ } while (png_ptr->iwidth == 0);
+
+ if (png_ptr->pass < 7)
+ return;
+ }
+#endif /* PNG_READ_INTERLACING_SUPPORTED */
+
+ if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
+ {
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_CONST PNG_IDAT;
+#endif
+ char extra;
+ int ret;
+
+ png_ptr->zstream.next_out = (Byte *)&extra;
+ png_ptr->zstream.avail_out = (uInt)1;
+ for (;;)
+ {
+ if (!(png_ptr->zstream.avail_in))
+ {
+ while (!png_ptr->idat_size)
+ {
+ png_byte chunk_length[4];
+
+ png_crc_finish(png_ptr, 0);
+
+ png_read_data(png_ptr, chunk_length, 4);
+ png_ptr->idat_size = png_get_uint_31(png_ptr, chunk_length);
+ png_reset_crc(png_ptr);
+ png_crc_read(png_ptr, png_ptr->chunk_name, 4);
+ if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
+ png_error(png_ptr, "Not enough image data");
+
+ }
+ png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size;
+ png_ptr->zstream.next_in = png_ptr->zbuf;
+ if (png_ptr->zbuf_size > png_ptr->idat_size)
+ png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size;
+ png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zstream.avail_in);
+ png_ptr->idat_size -= png_ptr->zstream.avail_in;
+ }
+ ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
+ if (ret == Z_STREAM_END)
+ {
+ if (!(png_ptr->zstream.avail_out) || png_ptr->zstream.avail_in ||
+ png_ptr->idat_size)
+ png_warning(png_ptr, "Extra compressed data");
+ png_ptr->mode |= PNG_AFTER_IDAT;
+ png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
+ break;
+ }
+ if (ret != Z_OK)
+ png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :
+ "Decompression Error");
+
+ if (!(png_ptr->zstream.avail_out))
+ {
+ png_warning(png_ptr, "Extra compressed data.");
+ png_ptr->mode |= PNG_AFTER_IDAT;
+ png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
+ break;
+ }
+
+ }
+ png_ptr->zstream.avail_out = 0;
+ }
+
+ if (png_ptr->idat_size || png_ptr->zstream.avail_in)
+ png_warning(png_ptr, "Extra compression data");
+
+ inflateReset(&png_ptr->zstream);
+
+ png_ptr->mode |= PNG_AFTER_IDAT;
+}
+
+void /* PRIVATE */
+png_read_start_row(png_structp png_ptr)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+#ifdef PNG_READ_INTERLACING_SUPPORTED
+ /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
+
+ /* start of interlace block */
+ PNG_CONST int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
+
+ /* offset to next interlace block */
+ PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
+
+ /* start of interlace block in the y direction */
+ PNG_CONST int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
+
+ /* offset to next interlace block in the y direction */
+ PNG_CONST int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
+#endif
+#endif
+
+ int max_pixel_depth;
+ png_size_t row_bytes;
+
+ png_debug(1, "in png_read_start_row\n");
+ png_ptr->zstream.avail_in = 0;
+ png_init_read_transformations(png_ptr);
+#ifdef PNG_READ_INTERLACING_SUPPORTED
+ if (png_ptr->interlaced)
+ {
+ if (!(png_ptr->transformations & PNG_INTERLACE))
+ png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -
+ png_pass_ystart[0]) / png_pass_yinc[0];
+ else
+ png_ptr->num_rows = png_ptr->height;
+
+ png_ptr->iwidth = (png_ptr->width +
+ png_pass_inc[png_ptr->pass] - 1 -
+ png_pass_start[png_ptr->pass]) /
+ png_pass_inc[png_ptr->pass];
+
+ png_ptr->irowbytes =
+ PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->iwidth) + 1;
+ }
+ else
+#endif /* PNG_READ_INTERLACING_SUPPORTED */
+ {
+ png_ptr->num_rows = png_ptr->height;
+ png_ptr->iwidth = png_ptr->width;
+ png_ptr->irowbytes = png_ptr->rowbytes + 1;
+ }
+ max_pixel_depth = png_ptr->pixel_depth;
+
+#if defined(PNG_READ_PACK_SUPPORTED)
+ if ((png_ptr->transformations & PNG_PACK) && png_ptr->bit_depth < 8)
+ max_pixel_depth = 8;
+#endif
+
+#if defined(PNG_READ_EXPAND_SUPPORTED)
+ if (png_ptr->transformations & PNG_EXPAND)
+ {
+ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+ {
+ if (png_ptr->num_trans)
+ max_pixel_depth = 32;
+ else
+ max_pixel_depth = 24;
+ }
+ else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
+ {
+ if (max_pixel_depth < 8)
+ max_pixel_depth = 8;
+ if (png_ptr->num_trans)
+ max_pixel_depth *= 2;
+ }
+ else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
+ {
+ if (png_ptr->num_trans)
+ {
+ max_pixel_depth *= 4;
+ max_pixel_depth /= 3;
+ }
+ }
+ }
+#endif
+
+#if defined(PNG_READ_FILLER_SUPPORTED)
+ if (png_ptr->transformations & (PNG_FILLER))
+ {
+ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+ max_pixel_depth = 32;
+ else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
+ {
+ if (max_pixel_depth <= 8)
+ max_pixel_depth = 16;
+ else
+ max_pixel_depth = 32;
+ }
+ else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
+ {
+ if (max_pixel_depth <= 32)
+ max_pixel_depth = 32;
+ else
+ max_pixel_depth = 64;
+ }
+ }
+#endif
+
+#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
+ if (png_ptr->transformations & PNG_GRAY_TO_RGB)
+ {
+ if (
+#if defined(PNG_READ_EXPAND_SUPPORTED)
+ (png_ptr->num_trans && (png_ptr->transformations & PNG_EXPAND)) ||
+#endif
+#if defined(PNG_READ_FILLER_SUPPORTED)
+ (png_ptr->transformations & (PNG_FILLER)) ||
+#endif
+ png_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+ {
+ if (max_pixel_depth <= 16)
+ max_pixel_depth = 32;
+ else
+ max_pixel_depth = 64;
+ }
+ else
+ {
+ if (max_pixel_depth <= 8)
+ {
+ if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+ max_pixel_depth = 32;
+ else
+ max_pixel_depth = 24;
+ }
+ else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+ max_pixel_depth = 64;
+ else
+ max_pixel_depth = 48;
+ }
+ }
+#endif
+
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) && \
+defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
+ if (png_ptr->transformations & PNG_USER_TRANSFORM)
+ {
+ int user_pixel_depth = png_ptr->user_transform_depth*
+ png_ptr->user_transform_channels;
+ if (user_pixel_depth > max_pixel_depth)
+ max_pixel_depth=user_pixel_depth;
+ }
+#endif
+
+ /* align the width on the next larger 8 pixels. Mainly used
+ for interlacing */
+ row_bytes = ((png_ptr->width + 7) & ~((png_uint_32)7));
+ /* calculate the maximum bytes needed, adding a byte and a pixel
+ for safety's sake */
+ row_bytes = PNG_ROWBYTES(max_pixel_depth, row_bytes) +
+ 1 + ((max_pixel_depth + 7) >> 3);
+#ifdef PNG_MAX_MALLOC_64K
+ if (row_bytes > (png_uint_32)65536L)
+ png_error(png_ptr, "This image requires a row greater than 64KB");
+#endif
+
+ if (row_bytes + 64 > png_ptr->old_big_row_buf_size)
+ {
+ png_free(png_ptr, png_ptr->big_row_buf);
+ png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr, row_bytes+64);
+ png_ptr->row_buf = png_ptr->big_row_buf+32;
+ png_ptr->old_big_row_buf_size = row_bytes+64;
+ }
+
+#ifdef PNG_MAX_MALLOC_64K
+ if ((png_uint_32)png_ptr->rowbytes + 1 > (png_uint_32)65536L)
+ png_error(png_ptr, "This image requires a row greater than 64KB");
+#endif
+ if ((png_uint_32)png_ptr->rowbytes > (png_uint_32)(PNG_SIZE_MAX - 1))
+ png_error(png_ptr, "Row has too many bytes to allocate in memory.");
+
+ if (png_ptr->rowbytes+1 > png_ptr->old_prev_row_size)
+ {
+ png_free(png_ptr, png_ptr->prev_row);
+ png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)(
+ png_ptr->rowbytes + 1));
+ png_ptr->old_prev_row_size = png_ptr->rowbytes+1;
+ }
+
+ png_memset_check(png_ptr, png_ptr->prev_row, 0, png_ptr->rowbytes + 1);
+
+ png_debug1(3, "width = %lu,\n", png_ptr->width);
+ png_debug1(3, "height = %lu,\n", png_ptr->height);
+ png_debug1(3, "iwidth = %lu,\n", png_ptr->iwidth);
+ png_debug1(3, "num_rows = %lu\n", png_ptr->num_rows);
+ png_debug1(3, "rowbytes = %lu,\n", png_ptr->rowbytes);
+ png_debug1(3, "irowbytes = %lu,\n", png_ptr->irowbytes);
+
+ png_ptr->flags |= PNG_FLAG_ROW_INIT;
+}
+#endif /* PNG_READ_SUPPORTED */
--- /dev/null
+
+/* pngset.c - storage of image information into info struct
+ *
+ * Last changed in libpng 1.2.30 [August 15, 2008]
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * The functions here are used during reads to store data from the file
+ * into the info struct, and during writes to store application data
+ * into the info struct for writing into the file. This abstracts the
+ * info struct and allows us to change the structure in the future.
+ */
+
+#define PNG_INTERNAL
+#include "png.h"
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
+
+#if defined(PNG_bKGD_SUPPORTED)
+void PNGAPI
+png_set_bKGD(png_structp png_ptr, png_infop info_ptr, png_color_16p background)
+{
+ png_debug1(1, "in %s storage function\n", "bKGD");
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+
+ png_memcpy(&(info_ptr->background), background, png_sizeof(png_color_16));
+ info_ptr->valid |= PNG_INFO_bKGD;
+}
+#endif
+
+#if defined(PNG_cHRM_SUPPORTED)
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+void PNGAPI
+png_set_cHRM(png_structp png_ptr, png_infop info_ptr,
+ double white_x, double white_y, double red_x, double red_y,
+ double green_x, double green_y, double blue_x, double blue_y)
+{
+ png_debug1(1, "in %s storage function\n", "cHRM");
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+ if (!(white_x || white_y || red_x || red_y || green_x || green_y ||
+ blue_x || blue_y))
+ {
+ png_warning(png_ptr,
+ "Ignoring attempt to set all-zero chromaticity values");
+ return;
+ }
+ if (white_x < 0.0 || white_y < 0.0 ||
+ red_x < 0.0 || red_y < 0.0 ||
+ green_x < 0.0 || green_y < 0.0 ||
+ blue_x < 0.0 || blue_y < 0.0)
+ {
+ png_warning(png_ptr,
+ "Ignoring attempt to set negative chromaticity value");
+ return;
+ }
+ if (white_x > 21474.83 || white_y > 21474.83 ||
+ red_x > 21474.83 || red_y > 21474.83 ||
+ green_x > 21474.83 || green_y > 21474.83 ||
+ blue_x > 21474.83 || blue_y > 21474.83)
+ {
+ png_warning(png_ptr,
+ "Ignoring attempt to set chromaticity value exceeding 21474.83");
+ return;
+ }
+
+ info_ptr->x_white = (float)white_x;
+ info_ptr->y_white = (float)white_y;
+ info_ptr->x_red = (float)red_x;
+ info_ptr->y_red = (float)red_y;
+ info_ptr->x_green = (float)green_x;
+ info_ptr->y_green = (float)green_y;
+ info_ptr->x_blue = (float)blue_x;
+ info_ptr->y_blue = (float)blue_y;
+#ifdef PNG_FIXED_POINT_SUPPORTED
+ info_ptr->int_x_white = (png_fixed_point)(white_x*100000.+0.5);
+ info_ptr->int_y_white = (png_fixed_point)(white_y*100000.+0.5);
+ info_ptr->int_x_red = (png_fixed_point)( red_x*100000.+0.5);
+ info_ptr->int_y_red = (png_fixed_point)( red_y*100000.+0.5);
+ info_ptr->int_x_green = (png_fixed_point)(green_x*100000.+0.5);
+ info_ptr->int_y_green = (png_fixed_point)(green_y*100000.+0.5);
+ info_ptr->int_x_blue = (png_fixed_point)( blue_x*100000.+0.5);
+ info_ptr->int_y_blue = (png_fixed_point)( blue_y*100000.+0.5);
+#endif
+ info_ptr->valid |= PNG_INFO_cHRM;
+}
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+void PNGAPI
+png_set_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,
+ png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x,
+ png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y,
+ png_fixed_point blue_x, png_fixed_point blue_y)
+{
+ png_debug1(1, "in %s storage function\n", "cHRM");
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+
+ if (!(white_x || white_y || red_x || red_y || green_x || green_y ||
+ blue_x || blue_y))
+ {
+ png_warning(png_ptr,
+ "Ignoring attempt to set all-zero chromaticity values");
+ return;
+ }
+ if (white_x < 0 || white_y < 0 ||
+ red_x < 0 || red_y < 0 ||
+ green_x < 0 || green_y < 0 ||
+ blue_x < 0 || blue_y < 0)
+ {
+ png_warning(png_ptr,
+ "Ignoring attempt to set negative chromaticity value");
+ return;
+ }
+ if (white_x > (png_fixed_point) PNG_UINT_31_MAX ||
+ white_y > (png_fixed_point) PNG_UINT_31_MAX ||
+ red_x > (png_fixed_point) PNG_UINT_31_MAX ||
+ red_y > (png_fixed_point) PNG_UINT_31_MAX ||
+ green_x > (png_fixed_point) PNG_UINT_31_MAX ||
+ green_y > (png_fixed_point) PNG_UINT_31_MAX ||
+ blue_x > (png_fixed_point) PNG_UINT_31_MAX ||
+ blue_y > (png_fixed_point) PNG_UINT_31_MAX )
+ {
+ png_warning(png_ptr,
+ "Ignoring attempt to set chromaticity value exceeding 21474.83");
+ return;
+ }
+ info_ptr->int_x_white = white_x;
+ info_ptr->int_y_white = white_y;
+ info_ptr->int_x_red = red_x;
+ info_ptr->int_y_red = red_y;
+ info_ptr->int_x_green = green_x;
+ info_ptr->int_y_green = green_y;
+ info_ptr->int_x_blue = blue_x;
+ info_ptr->int_y_blue = blue_y;
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+ info_ptr->x_white = (float)(white_x/100000.);
+ info_ptr->y_white = (float)(white_y/100000.);
+ info_ptr->x_red = (float)( red_x/100000.);
+ info_ptr->y_red = (float)( red_y/100000.);
+ info_ptr->x_green = (float)(green_x/100000.);
+ info_ptr->y_green = (float)(green_y/100000.);
+ info_ptr->x_blue = (float)( blue_x/100000.);
+ info_ptr->y_blue = (float)( blue_y/100000.);
+#endif
+ info_ptr->valid |= PNG_INFO_cHRM;
+}
+#endif
+#endif
+
+#if defined(PNG_gAMA_SUPPORTED)
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+void PNGAPI
+png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma)
+{
+ double gamma;
+ png_debug1(1, "in %s storage function\n", "gAMA");
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+
+ /* Check for overflow */
+ if (file_gamma > 21474.83)
+ {
+ png_warning(png_ptr, "Limiting gamma to 21474.83");
+ gamma=21474.83;
+ }
+ else
+ gamma = file_gamma;
+ info_ptr->gamma = (float)gamma;
+#ifdef PNG_FIXED_POINT_SUPPORTED
+ info_ptr->int_gamma = (int)(gamma*100000.+.5);
+#endif
+ info_ptr->valid |= PNG_INFO_gAMA;
+ if (gamma == 0.0)
+ png_warning(png_ptr, "Setting gamma=0");
+}
+#endif
+void PNGAPI
+png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point
+ int_gamma)
+{
+ png_fixed_point gamma;
+
+ png_debug1(1, "in %s storage function\n", "gAMA");
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+
+ if (int_gamma > (png_fixed_point) PNG_UINT_31_MAX)
+ {
+ png_warning(png_ptr, "Limiting gamma to 21474.83");
+ gamma=PNG_UINT_31_MAX;
+ }
+ else
+ {
+ if (int_gamma < 0)
+ {
+ png_warning(png_ptr, "Setting negative gamma to zero");
+ gamma = 0;
+ }
+ else
+ gamma = int_gamma;
+ }
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+ info_ptr->gamma = (float)(gamma/100000.);
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+ info_ptr->int_gamma = gamma;
+#endif
+ info_ptr->valid |= PNG_INFO_gAMA;
+ if (gamma == 0)
+ png_warning(png_ptr, "Setting gamma=0");
+}
+#endif
+
+#if defined(PNG_hIST_SUPPORTED)
+void PNGAPI
+png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p hist)
+{
+ int i;
+
+ png_debug1(1, "in %s storage function\n", "hIST");
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+ if (info_ptr->num_palette == 0 || info_ptr->num_palette
+ > PNG_MAX_PALETTE_LENGTH)
+ {
+ png_warning(png_ptr,
+ "Invalid palette size, hIST allocation skipped.");
+ return;
+ }
+
+#ifdef PNG_FREE_ME_SUPPORTED
+ png_free_data(png_ptr, info_ptr, PNG_FREE_HIST, 0);
+#endif
+ /* Changed from info->num_palette to PNG_MAX_PALETTE_LENGTH in version
+ 1.2.1 */
+ png_ptr->hist = (png_uint_16p)png_malloc_warn(png_ptr,
+ (png_uint_32)(PNG_MAX_PALETTE_LENGTH * png_sizeof(png_uint_16)));
+ if (png_ptr->hist == NULL)
+ {
+ png_warning(png_ptr, "Insufficient memory for hIST chunk data.");
+ return;
+ }
+
+ for (i = 0; i < info_ptr->num_palette; i++)
+ png_ptr->hist[i] = hist[i];
+ info_ptr->hist = png_ptr->hist;
+ info_ptr->valid |= PNG_INFO_hIST;
+
+#ifdef PNG_FREE_ME_SUPPORTED
+ info_ptr->free_me |= PNG_FREE_HIST;
+#else
+ png_ptr->flags |= PNG_FLAG_FREE_HIST;
+#endif
+}
+#endif
+
+void PNGAPI
+png_set_IHDR(png_structp png_ptr, png_infop info_ptr,
+ png_uint_32 width, png_uint_32 height, int bit_depth,
+ int color_type, int interlace_type, int compression_type,
+ int filter_type)
+{
+ png_debug1(1, "in %s storage function\n", "IHDR");
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+
+ /* check for width and height valid values */
+ if (width == 0 || height == 0)
+ png_error(png_ptr, "Image width or height is zero in IHDR");
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED
+ if (width > png_ptr->user_width_max || height > png_ptr->user_height_max)
+ png_error(png_ptr, "image size exceeds user limits in IHDR");
+#else
+ if (width > PNG_USER_WIDTH_MAX || height > PNG_USER_HEIGHT_MAX)
+ png_error(png_ptr, "image size exceeds user limits in IHDR");
+#endif
+ if (width > PNG_UINT_31_MAX || height > PNG_UINT_31_MAX)
+ png_error(png_ptr, "Invalid image size in IHDR");
+ if ( width > (PNG_UINT_32_MAX
+ >> 3) /* 8-byte RGBA pixels */
+ - 64 /* bigrowbuf hack */
+ - 1 /* filter byte */
+ - 7*8 /* rounding of width to multiple of 8 pixels */
+ - 8) /* extra max_pixel_depth pad */
+ png_warning(png_ptr, "Width is too large for libpng to process pixels");
+
+ /* check other values */
+ if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 &&
+ bit_depth != 8 && bit_depth != 16)
+ png_error(png_ptr, "Invalid bit depth in IHDR");
+
+ if (color_type < 0 || color_type == 1 ||
+ color_type == 5 || color_type > 6)
+ png_error(png_ptr, "Invalid color type in IHDR");
+
+ if (((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) ||
+ ((color_type == PNG_COLOR_TYPE_RGB ||
+ color_type == PNG_COLOR_TYPE_GRAY_ALPHA ||
+ color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8))
+ png_error(png_ptr, "Invalid color type/bit depth combination in IHDR");
+
+ if (interlace_type >= PNG_INTERLACE_LAST)
+ png_error(png_ptr, "Unknown interlace method in IHDR");
+
+ if (compression_type != PNG_COMPRESSION_TYPE_BASE)
+ png_error(png_ptr, "Unknown compression method in IHDR");
+
+#if defined(PNG_MNG_FEATURES_SUPPORTED)
+ /* Accept filter_method 64 (intrapixel differencing) only if
+ * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
+ * 2. Libpng did not read a PNG signature (this filter_method is only
+ * used in PNG datastreams that are embedded in MNG datastreams) and
+ * 3. The application called png_permit_mng_features with a mask that
+ * included PNG_FLAG_MNG_FILTER_64 and
+ * 4. The filter_method is 64 and
+ * 5. The color_type is RGB or RGBA
+ */
+ if ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)&&png_ptr->mng_features_permitted)
+ png_warning(png_ptr, "MNG features are not allowed in a PNG datastream");
+ if (filter_type != PNG_FILTER_TYPE_BASE)
+ {
+ if (!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
+ (filter_type == PNG_INTRAPIXEL_DIFFERENCING) &&
+ ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) &&
+ (color_type == PNG_COLOR_TYPE_RGB ||
+ color_type == PNG_COLOR_TYPE_RGB_ALPHA)))
+ png_error(png_ptr, "Unknown filter method in IHDR");
+ if (png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)
+ png_warning(png_ptr, "Invalid filter method in IHDR");
+ }
+#else
+ if (filter_type != PNG_FILTER_TYPE_BASE)
+ png_error(png_ptr, "Unknown filter method in IHDR");
+#endif
+
+ info_ptr->width = width;
+ info_ptr->height = height;
+ info_ptr->bit_depth = (png_byte)bit_depth;
+ info_ptr->color_type =(png_byte) color_type;
+ info_ptr->compression_type = (png_byte)compression_type;
+ info_ptr->filter_type = (png_byte)filter_type;
+ info_ptr->interlace_type = (png_byte)interlace_type;
+ if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+ info_ptr->channels = 1;
+ else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR)
+ info_ptr->channels = 3;
+ else
+ info_ptr->channels = 1;
+ if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)
+ info_ptr->channels++;
+ info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth);
+
+ /* check for potential overflow */
+ if (width > (PNG_UINT_32_MAX
+ >> 3) /* 8-byte RGBA pixels */
+ - 64 /* bigrowbuf hack */
+ - 1 /* filter byte */
+ - 7*8 /* rounding of width to multiple of 8 pixels */
+ - 8) /* extra max_pixel_depth pad */
+ info_ptr->rowbytes = (png_size_t)0;
+ else
+ info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, width);
+}
+
+#if defined(PNG_oFFs_SUPPORTED)
+void PNGAPI
+png_set_oFFs(png_structp png_ptr, png_infop info_ptr,
+ png_int_32 offset_x, png_int_32 offset_y, int unit_type)
+{
+ png_debug1(1, "in %s storage function\n", "oFFs");
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+
+ info_ptr->x_offset = offset_x;
+ info_ptr->y_offset = offset_y;
+ info_ptr->offset_unit_type = (png_byte)unit_type;
+ info_ptr->valid |= PNG_INFO_oFFs;
+}
+#endif
+
+#if defined(PNG_pCAL_SUPPORTED)
+void PNGAPI
+png_set_pCAL(png_structp png_ptr, png_infop info_ptr,
+ png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams,
+ png_charp units, png_charpp params)
+{
+ png_uint_32 length;
+ int i;
+
+ png_debug1(1, "in %s storage function\n", "pCAL");
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+
+ length = png_strlen(purpose) + 1;
+ png_debug1(3, "allocating purpose for info (%lu bytes)\n",
+ (unsigned long)length);
+ info_ptr->pcal_purpose = (png_charp)png_malloc_warn(png_ptr, length);
+ if (info_ptr->pcal_purpose == NULL)
+ {
+ png_warning(png_ptr, "Insufficient memory for pCAL purpose.");
+ return;
+ }
+ png_memcpy(info_ptr->pcal_purpose, purpose, (png_size_t)length);
+
+ png_debug(3, "storing X0, X1, type, and nparams in info\n");
+ info_ptr->pcal_X0 = X0;
+ info_ptr->pcal_X1 = X1;
+ info_ptr->pcal_type = (png_byte)type;
+ info_ptr->pcal_nparams = (png_byte)nparams;
+
+ length = png_strlen(units) + 1;
+ png_debug1(3, "allocating units for info (%lu bytes)\n",
+ (unsigned long)length);
+ info_ptr->pcal_units = (png_charp)png_malloc_warn(png_ptr, length);
+ if (info_ptr->pcal_units == NULL)
+ {
+ png_warning(png_ptr, "Insufficient memory for pCAL units.");
+ return;
+ }
+ png_memcpy(info_ptr->pcal_units, units, (png_size_t)length);
+
+ info_ptr->pcal_params = (png_charpp)png_malloc_warn(png_ptr,
+ (png_uint_32)((nparams + 1) * png_sizeof(png_charp)));
+ if (info_ptr->pcal_params == NULL)
+ {
+ png_warning(png_ptr, "Insufficient memory for pCAL params.");
+ return;
+ }
+
+ info_ptr->pcal_params[nparams] = NULL;
+
+ for (i = 0; i < nparams; i++)
+ {
+ length = png_strlen(params[i]) + 1;
+ png_debug2(3, "allocating parameter %d for info (%lu bytes)\n", i,
+ (unsigned long)length);
+ info_ptr->pcal_params[i] = (png_charp)png_malloc_warn(png_ptr, length);
+ if (info_ptr->pcal_params[i] == NULL)
+ {
+ png_warning(png_ptr, "Insufficient memory for pCAL parameter.");
+ return;
+ }
+ png_memcpy(info_ptr->pcal_params[i], params[i], (png_size_t)length);
+ }
+
+ info_ptr->valid |= PNG_INFO_pCAL;
+#ifdef PNG_FREE_ME_SUPPORTED
+ info_ptr->free_me |= PNG_FREE_PCAL;
+#endif
+}
+#endif
+
+#if defined(PNG_READ_sCAL_SUPPORTED) || defined(PNG_WRITE_sCAL_SUPPORTED)
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+void PNGAPI
+png_set_sCAL(png_structp png_ptr, png_infop info_ptr,
+ int unit, double width, double height)
+{
+ png_debug1(1, "in %s storage function\n", "sCAL");
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+
+ info_ptr->scal_unit = (png_byte)unit;
+ info_ptr->scal_pixel_width = width;
+ info_ptr->scal_pixel_height = height;
+
+ info_ptr->valid |= PNG_INFO_sCAL;
+}
+#else
+#ifdef PNG_FIXED_POINT_SUPPORTED
+void PNGAPI
+png_set_sCAL_s(png_structp png_ptr, png_infop info_ptr,
+ int unit, png_charp swidth, png_charp sheight)
+{
+ png_uint_32 length;
+
+ png_debug1(1, "in %s storage function\n", "sCAL");
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+
+ info_ptr->scal_unit = (png_byte)unit;
+
+ length = png_strlen(swidth) + 1;
+ png_debug1(3, "allocating unit for info (%u bytes)\n",
+ (unsigned int)length);
+ info_ptr->scal_s_width = (png_charp)png_malloc_warn(png_ptr, length);
+ if (info_ptr->scal_s_width == NULL)
+ {
+ png_warning(png_ptr,
+ "Memory allocation failed while processing sCAL.");
+ return;
+ }
+ png_memcpy(info_ptr->scal_s_width, swidth, (png_size_t)length);
+
+ length = png_strlen(sheight) + 1;
+ png_debug1(3, "allocating unit for info (%u bytes)\n",
+ (unsigned int)length);
+ info_ptr->scal_s_height = (png_charp)png_malloc_warn(png_ptr, length);
+ if (info_ptr->scal_s_height == NULL)
+ {
+ png_free (png_ptr, info_ptr->scal_s_width);
+ info_ptr->scal_s_width = NULL;
+ png_warning(png_ptr,
+ "Memory allocation failed while processing sCAL.");
+ return;
+ }
+ png_memcpy(info_ptr->scal_s_height, sheight, (png_size_t)length);
+ info_ptr->valid |= PNG_INFO_sCAL;
+#ifdef PNG_FREE_ME_SUPPORTED
+ info_ptr->free_me |= PNG_FREE_SCAL;
+#endif
+}
+#endif
+#endif
+#endif
+
+#if defined(PNG_pHYs_SUPPORTED)
+void PNGAPI
+png_set_pHYs(png_structp png_ptr, png_infop info_ptr,
+ png_uint_32 res_x, png_uint_32 res_y, int unit_type)
+{
+ png_debug1(1, "in %s storage function\n", "pHYs");
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+
+ info_ptr->x_pixels_per_unit = res_x;
+ info_ptr->y_pixels_per_unit = res_y;
+ info_ptr->phys_unit_type = (png_byte)unit_type;
+ info_ptr->valid |= PNG_INFO_pHYs;
+}
+#endif
+
+void PNGAPI
+png_set_PLTE(png_structp png_ptr, png_infop info_ptr,
+ png_colorp palette, int num_palette)
+{
+
+ png_debug1(1, "in %s storage function\n", "PLTE");
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+
+ if (num_palette < 0 || num_palette > PNG_MAX_PALETTE_LENGTH)
+ {
+ if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+ png_error(png_ptr, "Invalid palette length");
+ else
+ {
+ png_warning(png_ptr, "Invalid palette length");
+ return;
+ }
+ }
+
+ /*
+ * It may not actually be necessary to set png_ptr->palette here;
+ * we do it for backward compatibility with the way the png_handle_tRNS
+ * function used to do the allocation.
+ */
+#ifdef PNG_FREE_ME_SUPPORTED
+ png_free_data(png_ptr, info_ptr, PNG_FREE_PLTE, 0);
+#endif
+
+ /* Changed in libpng-1.2.1 to allocate PNG_MAX_PALETTE_LENGTH instead
+ of num_palette entries,
+ in case of an invalid PNG file that has too-large sample values. */
+ png_ptr->palette = (png_colorp)png_malloc(png_ptr,
+ PNG_MAX_PALETTE_LENGTH * png_sizeof(png_color));
+ png_memset(png_ptr->palette, 0, PNG_MAX_PALETTE_LENGTH *
+ png_sizeof(png_color));
+ png_memcpy(png_ptr->palette, palette, num_palette * png_sizeof(png_color));
+ info_ptr->palette = png_ptr->palette;
+ info_ptr->num_palette = png_ptr->num_palette = (png_uint_16)num_palette;
+
+#ifdef PNG_FREE_ME_SUPPORTED
+ info_ptr->free_me |= PNG_FREE_PLTE;
+#else
+ png_ptr->flags |= PNG_FLAG_FREE_PLTE;
+#endif
+
+ info_ptr->valid |= PNG_INFO_PLTE;
+}
+
+#if defined(PNG_sBIT_SUPPORTED)
+void PNGAPI
+png_set_sBIT(png_structp png_ptr, png_infop info_ptr,
+ png_color_8p sig_bit)
+{
+ png_debug1(1, "in %s storage function\n", "sBIT");
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+
+ png_memcpy(&(info_ptr->sig_bit), sig_bit, png_sizeof(png_color_8));
+ info_ptr->valid |= PNG_INFO_sBIT;
+}
+#endif
+
+#if defined(PNG_sRGB_SUPPORTED)
+void PNGAPI
+png_set_sRGB(png_structp png_ptr, png_infop info_ptr, int intent)
+{
+ png_debug1(1, "in %s storage function\n", "sRGB");
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+
+ info_ptr->srgb_intent = (png_byte)intent;
+ info_ptr->valid |= PNG_INFO_sRGB;
+}
+
+void PNGAPI
+png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr,
+ int intent)
+{
+#if defined(PNG_gAMA_SUPPORTED)
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+ float file_gamma;
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+ png_fixed_point int_file_gamma;
+#endif
+#endif
+#if defined(PNG_cHRM_SUPPORTED)
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+ float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+ png_fixed_point int_white_x, int_white_y, int_red_x, int_red_y, int_green_x,
+ int_green_y, int_blue_x, int_blue_y;
+#endif
+#endif
+ png_debug1(1, "in %s storage function\n", "sRGB_gAMA_and_cHRM");
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+
+ png_set_sRGB(png_ptr, info_ptr, intent);
+
+#if defined(PNG_gAMA_SUPPORTED)
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+ file_gamma = (float).45455;
+ png_set_gAMA(png_ptr, info_ptr, file_gamma);
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+ int_file_gamma = 45455L;
+ png_set_gAMA_fixed(png_ptr, info_ptr, int_file_gamma);
+#endif
+#endif
+
+#if defined(PNG_cHRM_SUPPORTED)
+#ifdef PNG_FIXED_POINT_SUPPORTED
+ int_white_x = 31270L;
+ int_white_y = 32900L;
+ int_red_x = 64000L;
+ int_red_y = 33000L;
+ int_green_x = 30000L;
+ int_green_y = 60000L;
+ int_blue_x = 15000L;
+ int_blue_y = 6000L;
+
+ png_set_cHRM_fixed(png_ptr, info_ptr,
+ int_white_x, int_white_y, int_red_x, int_red_y, int_green_x, int_green_y,
+ int_blue_x, int_blue_y);
+#endif
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+ white_x = (float).3127;
+ white_y = (float).3290;
+ red_x = (float).64;
+ red_y = (float).33;
+ green_x = (float).30;
+ green_y = (float).60;
+ blue_x = (float).15;
+ blue_y = (float).06;
+
+ png_set_cHRM(png_ptr, info_ptr,
+ white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);
+#endif
+#endif
+}
+#endif
+
+
+#if defined(PNG_iCCP_SUPPORTED)
+void PNGAPI
+png_set_iCCP(png_structp png_ptr, png_infop info_ptr,
+ png_charp name, int compression_type,
+ png_charp profile, png_uint_32 proflen)
+{
+ png_charp new_iccp_name;
+ png_charp new_iccp_profile;
+ png_uint_32 length;
+
+ png_debug1(1, "in %s storage function\n", "iCCP");
+ if (png_ptr == NULL || info_ptr == NULL || name == NULL || profile == NULL)
+ return;
+
+ length = png_strlen(name)+1;
+ new_iccp_name = (png_charp)png_malloc_warn(png_ptr, length);
+ if (new_iccp_name == NULL)
+ {
+ png_warning(png_ptr, "Insufficient memory to process iCCP chunk.");
+ return;
+ }
+ png_memcpy(new_iccp_name, name, length);
+ new_iccp_profile = (png_charp)png_malloc_warn(png_ptr, proflen);
+ if (new_iccp_profile == NULL)
+ {
+ png_free (png_ptr, new_iccp_name);
+ png_warning(png_ptr,
+ "Insufficient memory to process iCCP profile.");
+ return;
+ }
+ png_memcpy(new_iccp_profile, profile, (png_size_t)proflen);
+
+ png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, 0);
+
+ info_ptr->iccp_proflen = proflen;
+ info_ptr->iccp_name = new_iccp_name;
+ info_ptr->iccp_profile = new_iccp_profile;
+ /* Compression is always zero but is here so the API and info structure
+ * does not have to change if we introduce multiple compression types */
+ info_ptr->iccp_compression = (png_byte)compression_type;
+#ifdef PNG_FREE_ME_SUPPORTED
+ info_ptr->free_me |= PNG_FREE_ICCP;
+#endif
+ info_ptr->valid |= PNG_INFO_iCCP;
+}
+#endif
+
+#if defined(PNG_TEXT_SUPPORTED)
+void PNGAPI
+png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
+ int num_text)
+{
+ int ret;
+ ret = png_set_text_2(png_ptr, info_ptr, text_ptr, num_text);
+ if (ret)
+ png_error(png_ptr, "Insufficient memory to store text");
+}
+
+int /* PRIVATE */
+png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
+ int num_text)
+{
+ int i;
+
+ png_debug1(1, "in %s storage function\n", (png_ptr->chunk_name[0] == '\0' ?
+ "text" : (png_const_charp)png_ptr->chunk_name));
+
+ if (png_ptr == NULL || info_ptr == NULL || num_text == 0)
+ return(0);
+
+ /* Make sure we have enough space in the "text" array in info_struct
+ * to hold all of the incoming text_ptr objects.
+ */
+ if (info_ptr->num_text + num_text > info_ptr->max_text)
+ {
+ if (info_ptr->text != NULL)
+ {
+ png_textp old_text;
+ int old_max;
+
+ old_max = info_ptr->max_text;
+ info_ptr->max_text = info_ptr->num_text + num_text + 8;
+ old_text = info_ptr->text;
+ info_ptr->text = (png_textp)png_malloc_warn(png_ptr,
+ (png_uint_32)(info_ptr->max_text * png_sizeof(png_text)));
+ if (info_ptr->text == NULL)
+ {
+ png_free(png_ptr, old_text);
+ return(1);
+ }
+ png_memcpy(info_ptr->text, old_text, (png_size_t)(old_max *
+ png_sizeof(png_text)));
+ png_free(png_ptr, old_text);
+ }
+ else
+ {
+ info_ptr->max_text = num_text + 8;
+ info_ptr->num_text = 0;
+ info_ptr->text = (png_textp)png_malloc_warn(png_ptr,
+ (png_uint_32)(info_ptr->max_text * png_sizeof(png_text)));
+ if (info_ptr->text == NULL)
+ return(1);
+#ifdef PNG_FREE_ME_SUPPORTED
+ info_ptr->free_me |= PNG_FREE_TEXT;
+#endif
+ }
+ png_debug1(3, "allocated %d entries for info_ptr->text\n",
+ info_ptr->max_text);
+ }
+ for (i = 0; i < num_text; i++)
+ {
+ png_size_t text_length, key_len;
+ png_size_t lang_len, lang_key_len;
+ png_textp textp = &(info_ptr->text[info_ptr->num_text]);
+
+ if (text_ptr[i].key == NULL)
+ continue;
+
+ key_len = png_strlen(text_ptr[i].key);
+
+ if (text_ptr[i].compression <= 0)
+ {
+ lang_len = 0;
+ lang_key_len = 0;
+ }
+ else
+#ifdef PNG_iTXt_SUPPORTED
+ {
+ /* set iTXt data */
+ if (text_ptr[i].lang != NULL)
+ lang_len = png_strlen(text_ptr[i].lang);
+ else
+ lang_len = 0;
+ if (text_ptr[i].lang_key != NULL)
+ lang_key_len = png_strlen(text_ptr[i].lang_key);
+ else
+ lang_key_len = 0;
+ }
+#else
+ {
+ png_warning(png_ptr, "iTXt chunk not supported.");
+ continue;
+ }
+#endif
+
+ if (text_ptr[i].text == NULL || text_ptr[i].text[0] == '\0')
+ {
+ text_length = 0;
+#ifdef PNG_iTXt_SUPPORTED
+ if (text_ptr[i].compression > 0)
+ textp->compression = PNG_ITXT_COMPRESSION_NONE;
+ else
+#endif
+ textp->compression = PNG_TEXT_COMPRESSION_NONE;
+ }
+ else
+ {
+ text_length = png_strlen(text_ptr[i].text);
+ textp->compression = text_ptr[i].compression;
+ }
+
+ textp->key = (png_charp)png_malloc_warn(png_ptr,
+ (png_uint_32)
+ (key_len + text_length + lang_len + lang_key_len + 4));
+ if (textp->key == NULL)
+ return(1);
+ png_debug2(2, "Allocated %lu bytes at %x in png_set_text\n",
+ (png_uint_32)
+ (key_len + lang_len + lang_key_len + text_length + 4),
+ (int)textp->key);
+
+ png_memcpy(textp->key, text_ptr[i].key,
+ (png_size_t)(key_len));
+ *(textp->key + key_len) = '\0';
+#ifdef PNG_iTXt_SUPPORTED
+ if (text_ptr[i].compression > 0)
+ {
+ textp->lang = textp->key + key_len + 1;
+ png_memcpy(textp->lang, text_ptr[i].lang, lang_len);
+ *(textp->lang + lang_len) = '\0';
+ textp->lang_key = textp->lang + lang_len + 1;
+ png_memcpy(textp->lang_key, text_ptr[i].lang_key, lang_key_len);
+ *(textp->lang_key + lang_key_len) = '\0';
+ textp->text = textp->lang_key + lang_key_len + 1;
+ }
+ else
+#endif
+ {
+#ifdef PNG_iTXt_SUPPORTED
+ textp->lang=NULL;
+ textp->lang_key=NULL;
+#endif
+ textp->text = textp->key + key_len + 1;
+ }
+ if (text_length)
+ png_memcpy(textp->text, text_ptr[i].text,
+ (png_size_t)(text_length));
+ *(textp->text + text_length) = '\0';
+
+#ifdef PNG_iTXt_SUPPORTED
+ if (textp->compression > 0)
+ {
+ textp->text_length = 0;
+ textp->itxt_length = text_length;
+ }
+ else
+#endif
+ {
+ textp->text_length = text_length;
+#ifdef PNG_iTXt_SUPPORTED
+ textp->itxt_length = 0;
+#endif
+ }
+ info_ptr->num_text++;
+ png_debug1(3, "transferred text chunk %d\n", info_ptr->num_text);
+ }
+ return(0);
+}
+#endif
+
+#if defined(PNG_tIME_SUPPORTED)
+void PNGAPI
+png_set_tIME(png_structp png_ptr, png_infop info_ptr, png_timep mod_time)
+{
+ png_debug1(1, "in %s storage function\n", "tIME");
+ if (png_ptr == NULL || info_ptr == NULL ||
+ (png_ptr->mode & PNG_WROTE_tIME))
+ return;
+
+ png_memcpy(&(info_ptr->mod_time), mod_time, png_sizeof(png_time));
+ info_ptr->valid |= PNG_INFO_tIME;
+}
+#endif
+
+#if defined(PNG_tRNS_SUPPORTED)
+void PNGAPI
+png_set_tRNS(png_structp png_ptr, png_infop info_ptr,
+ png_bytep trans, int num_trans, png_color_16p trans_values)
+{
+ png_debug1(1, "in %s storage function\n", "tRNS");
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+
+ if (trans != NULL)
+ {
+ /*
+ * It may not actually be necessary to set png_ptr->trans here;
+ * we do it for backward compatibility with the way the png_handle_tRNS
+ * function used to do the allocation.
+ */
+
+#ifdef PNG_FREE_ME_SUPPORTED
+ png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0);
+#endif
+
+ /* Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1 */
+ png_ptr->trans = info_ptr->trans = (png_bytep)png_malloc(png_ptr,
+ (png_uint_32)PNG_MAX_PALETTE_LENGTH);
+ if (num_trans > 0 && num_trans <= PNG_MAX_PALETTE_LENGTH)
+ png_memcpy(info_ptr->trans, trans, (png_size_t)num_trans);
+ }
+
+ if (trans_values != NULL)
+ {
+ int sample_max = (1 << info_ptr->bit_depth);
+ if ((info_ptr->color_type == PNG_COLOR_TYPE_GRAY &&
+ (int)trans_values->gray > sample_max) ||
+ (info_ptr->color_type == PNG_COLOR_TYPE_RGB &&
+ ((int)trans_values->red > sample_max ||
+ (int)trans_values->green > sample_max ||
+ (int)trans_values->blue > sample_max)))
+ png_warning(png_ptr,
+ "tRNS chunk has out-of-range samples for bit_depth");
+ png_memcpy(&(info_ptr->trans_values), trans_values,
+ png_sizeof(png_color_16));
+ if (num_trans == 0)
+ num_trans = 1;
+ }
+
+ info_ptr->num_trans = (png_uint_16)num_trans;
+ if (num_trans != 0)
+ {
+ info_ptr->valid |= PNG_INFO_tRNS;
+#ifdef PNG_FREE_ME_SUPPORTED
+ info_ptr->free_me |= PNG_FREE_TRNS;
+#else
+ png_ptr->flags |= PNG_FLAG_FREE_TRNS;
+#endif
+ }
+}
+#endif
+
+#if defined(PNG_sPLT_SUPPORTED)
+void PNGAPI
+png_set_sPLT(png_structp png_ptr,
+ png_infop info_ptr, png_sPLT_tp entries, int nentries)
+/*
+ * entries - array of png_sPLT_t structures
+ * to be added to the list of palettes
+ * in the info structure.
+ * nentries - number of palette structures to be
+ * added.
+ */
+{
+ png_sPLT_tp np;
+ int i;
+
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+
+ np = (png_sPLT_tp)png_malloc_warn(png_ptr,
+ (info_ptr->splt_palettes_num + nentries) *
+ (png_uint_32)png_sizeof(png_sPLT_t));
+ if (np == NULL)
+ {
+ png_warning(png_ptr, "No memory for sPLT palettes.");
+ return;
+ }
+
+ png_memcpy(np, info_ptr->splt_palettes,
+ info_ptr->splt_palettes_num * png_sizeof(png_sPLT_t));
+ png_free(png_ptr, info_ptr->splt_palettes);
+ info_ptr->splt_palettes=NULL;
+
+ for (i = 0; i < nentries; i++)
+ {
+ png_sPLT_tp to = np + info_ptr->splt_palettes_num + i;
+ png_sPLT_tp from = entries + i;
+ png_uint_32 length;
+
+ length = png_strlen(from->name) + 1;
+ to->name = (png_charp)png_malloc_warn(png_ptr, length);
+ if (to->name == NULL)
+ {
+ png_warning(png_ptr,
+ "Out of memory while processing sPLT chunk");
+ continue;
+ }
+ png_memcpy(to->name, from->name, length);
+ to->entries = (png_sPLT_entryp)png_malloc_warn(png_ptr,
+ (png_uint_32)(from->nentries * png_sizeof(png_sPLT_entry)));
+ if (to->entries == NULL)
+ {
+ png_warning(png_ptr,
+ "Out of memory while processing sPLT chunk");
+ png_free(png_ptr, to->name);
+ to->name = NULL;
+ continue;
+ }
+ png_memcpy(to->entries, from->entries,
+ from->nentries * png_sizeof(png_sPLT_entry));
+ to->nentries = from->nentries;
+ to->depth = from->depth;
+ }
+
+ info_ptr->splt_palettes = np;
+ info_ptr->splt_palettes_num += nentries;
+ info_ptr->valid |= PNG_INFO_sPLT;
+#ifdef PNG_FREE_ME_SUPPORTED
+ info_ptr->free_me |= PNG_FREE_SPLT;
+#endif
+}
+#endif /* PNG_sPLT_SUPPORTED */
+
+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
+void PNGAPI
+png_set_unknown_chunks(png_structp png_ptr,
+ png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns)
+{
+ png_unknown_chunkp np;
+ int i;
+
+ if (png_ptr == NULL || info_ptr == NULL || num_unknowns == 0)
+ return;
+
+ np = (png_unknown_chunkp)png_malloc_warn(png_ptr,
+ (png_uint_32)((info_ptr->unknown_chunks_num + num_unknowns) *
+ png_sizeof(png_unknown_chunk)));
+ if (np == NULL)
+ {
+ png_warning(png_ptr,
+ "Out of memory while processing unknown chunk.");
+ return;
+ }
+
+ png_memcpy(np, info_ptr->unknown_chunks,
+ info_ptr->unknown_chunks_num * png_sizeof(png_unknown_chunk));
+ png_free(png_ptr, info_ptr->unknown_chunks);
+ info_ptr->unknown_chunks=NULL;
+
+ for (i = 0; i < num_unknowns; i++)
+ {
+ png_unknown_chunkp to = np + info_ptr->unknown_chunks_num + i;
+ png_unknown_chunkp from = unknowns + i;
+
+ png_memcpy((png_charp)to->name,
+ (png_charp)from->name,
+ png_sizeof(from->name));
+ to->name[png_sizeof(to->name)-1] = '\0';
+ to->size = from->size;
+ /* note our location in the read or write sequence */
+ to->location = (png_byte)(png_ptr->mode & 0xff);
+
+ if (from->size == 0)
+ to->data=NULL;
+ else
+ {
+ to->data = (png_bytep)png_malloc_warn(png_ptr,
+ (png_uint_32)from->size);
+ if (to->data == NULL)
+ {
+ png_warning(png_ptr,
+ "Out of memory while processing unknown chunk.");
+ to->size = 0;
+ }
+ else
+ png_memcpy(to->data, from->data, from->size);
+ }
+ }
+
+ info_ptr->unknown_chunks = np;
+ info_ptr->unknown_chunks_num += num_unknowns;
+#ifdef PNG_FREE_ME_SUPPORTED
+ info_ptr->free_me |= PNG_FREE_UNKN;
+#endif
+}
+void PNGAPI
+png_set_unknown_chunk_location(png_structp png_ptr, png_infop info_ptr,
+ int chunk, int location)
+{
+ if (png_ptr != NULL && info_ptr != NULL && chunk >= 0 && chunk <
+ (int)info_ptr->unknown_chunks_num)
+ info_ptr->unknown_chunks[chunk].location = (png_byte)location;
+}
+#endif
+
+#if defined(PNG_1_0_X) || defined(PNG_1_2_X)
+#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \
+ defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED)
+void PNGAPI
+png_permit_empty_plte (png_structp png_ptr, int empty_plte_permitted)
+{
+ /* This function is deprecated in favor of png_permit_mng_features()
+ and will be removed from libpng-1.3.0 */
+ png_debug(1, "in png_permit_empty_plte, DEPRECATED.\n");
+ if (png_ptr == NULL)
+ return;
+ png_ptr->mng_features_permitted = (png_byte)
+ ((png_ptr->mng_features_permitted & (~PNG_FLAG_MNG_EMPTY_PLTE)) |
+ ((empty_plte_permitted & PNG_FLAG_MNG_EMPTY_PLTE)));
+}
+#endif
+#endif
+
+#if defined(PNG_MNG_FEATURES_SUPPORTED)
+png_uint_32 PNGAPI
+png_permit_mng_features (png_structp png_ptr, png_uint_32 mng_features)
+{
+ png_debug(1, "in png_permit_mng_features\n");
+ if (png_ptr == NULL)
+ return (png_uint_32)0;
+ png_ptr->mng_features_permitted =
+ (png_byte)(mng_features & PNG_ALL_MNG_FEATURES);
+ return (png_uint_32)png_ptr->mng_features_permitted;
+}
+#endif
+
+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
+void PNGAPI
+png_set_keep_unknown_chunks(png_structp png_ptr, int keep, png_bytep
+ chunk_list, int num_chunks)
+{
+ png_bytep new_list, p;
+ int i, old_num_chunks;
+ if (png_ptr == NULL)
+ return;
+ if (num_chunks == 0)
+ {
+ if (keep == PNG_HANDLE_CHUNK_ALWAYS || keep == PNG_HANDLE_CHUNK_IF_SAFE)
+ png_ptr->flags |= PNG_FLAG_KEEP_UNKNOWN_CHUNKS;
+ else
+ png_ptr->flags &= ~PNG_FLAG_KEEP_UNKNOWN_CHUNKS;
+
+ if (keep == PNG_HANDLE_CHUNK_ALWAYS)
+ png_ptr->flags |= PNG_FLAG_KEEP_UNSAFE_CHUNKS;
+ else
+ png_ptr->flags &= ~PNG_FLAG_KEEP_UNSAFE_CHUNKS;
+ return;
+ }
+ if (chunk_list == NULL)
+ return;
+ old_num_chunks = png_ptr->num_chunk_list;
+ new_list=(png_bytep)png_malloc(png_ptr,
+ (png_uint_32)
+ (5*(num_chunks + old_num_chunks)));
+ if (png_ptr->chunk_list != NULL)
+ {
+ png_memcpy(new_list, png_ptr->chunk_list,
+ (png_size_t)(5*old_num_chunks));
+ png_free(png_ptr, png_ptr->chunk_list);
+ png_ptr->chunk_list=NULL;
+ }
+ png_memcpy(new_list + 5*old_num_chunks, chunk_list,
+ (png_size_t)(5*num_chunks));
+ for (p = new_list + 5*old_num_chunks + 4, i = 0; i<num_chunks; i++, p += 5)
+ *p=(png_byte)keep;
+ png_ptr->num_chunk_list = old_num_chunks + num_chunks;
+ png_ptr->chunk_list = new_list;
+#ifdef PNG_FREE_ME_SUPPORTED
+ png_ptr->free_me |= PNG_FREE_LIST;
+#endif
+}
+#endif
+
+#if defined(PNG_READ_USER_CHUNKS_SUPPORTED)
+void PNGAPI
+png_set_read_user_chunk_fn(png_structp png_ptr, png_voidp user_chunk_ptr,
+ png_user_chunk_ptr read_user_chunk_fn)
+{
+ png_debug(1, "in png_set_read_user_chunk_fn\n");
+ if (png_ptr == NULL)
+ return;
+ png_ptr->read_user_chunk_fn = read_user_chunk_fn;
+ png_ptr->user_chunk_ptr = user_chunk_ptr;
+}
+#endif
+
+#if defined(PNG_INFO_IMAGE_SUPPORTED)
+void PNGAPI
+png_set_rows(png_structp png_ptr, png_infop info_ptr, png_bytepp row_pointers)
+{
+ png_debug1(1, "in %s storage function\n", "rows");
+
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+
+ if (info_ptr->row_pointers && (info_ptr->row_pointers != row_pointers))
+ png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);
+ info_ptr->row_pointers = row_pointers;
+ if (row_pointers)
+ info_ptr->valid |= PNG_INFO_IDAT;
+}
+#endif
+
+#ifdef PNG_WRITE_SUPPORTED
+void PNGAPI
+png_set_compression_buffer_size(png_structp png_ptr,
+ png_uint_32 size)
+{
+ if (png_ptr == NULL)
+ return;
+ png_free(png_ptr, png_ptr->zbuf);
+ png_ptr->zbuf_size = (png_size_t)size;
+ png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, size);
+ png_ptr->zstream.next_out = png_ptr->zbuf;
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+}
+#endif
+
+void PNGAPI
+png_set_invalid(png_structp png_ptr, png_infop info_ptr, int mask)
+{
+ if (png_ptr && info_ptr)
+ info_ptr->valid &= ~mask;
+}
+
+
+#ifndef PNG_1_0_X
+#ifdef PNG_ASSEMBLER_CODE_SUPPORTED
+/* function was added to libpng 1.2.0 and should always exist by default */
+void PNGAPI
+png_set_asm_flags (png_structp png_ptr, png_uint_32 asm_flags)
+{
+/* Obsolete as of libpng-1.2.20 and will be removed from libpng-1.4.0 */
+ if (png_ptr != NULL)
+ png_ptr->asm_flags = 0;
+ asm_flags = asm_flags; /* Quiet the compiler */
+}
+
+/* this function was added to libpng 1.2.0 */
+void PNGAPI
+png_set_mmx_thresholds (png_structp png_ptr,
+ png_byte mmx_bitdepth_threshold,
+ png_uint_32 mmx_rowbytes_threshold)
+{
+/* Obsolete as of libpng-1.2.20 and will be removed from libpng-1.4.0 */
+ if (png_ptr == NULL)
+ return;
+ /* Quiet the compiler */
+ mmx_bitdepth_threshold = mmx_bitdepth_threshold;
+ mmx_rowbytes_threshold = mmx_rowbytes_threshold;
+}
+#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */
+
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED
+/* this function was added to libpng 1.2.6 */
+void PNGAPI
+png_set_user_limits (png_structp png_ptr, png_uint_32 user_width_max,
+ png_uint_32 user_height_max)
+{
+ /* Images with dimensions larger than these limits will be
+ * rejected by png_set_IHDR(). To accept any PNG datastream
+ * regardless of dimensions, set both limits to 0x7ffffffL.
+ */
+ if (png_ptr == NULL) return;
+ png_ptr->user_width_max = user_width_max;
+ png_ptr->user_height_max = user_height_max;
+}
+#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */
+
+#endif /* ?PNG_1_0_X */
+#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
--- /dev/null
+
+/* pngtrans.c - transforms the data in a row (used by both readers and writers)
+ *
+ * Last changed in libpng 1.2.30 [August 15, 2008]
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ */
+
+#define PNG_INTERNAL
+#include "png.h"
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
+
+#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
+/* turn on BGR-to-RGB mapping */
+void PNGAPI
+png_set_bgr(png_structp png_ptr)
+{
+ png_debug(1, "in png_set_bgr\n");
+ if (png_ptr == NULL) return;
+ png_ptr->transformations |= PNG_BGR;
+}
+#endif
+
+#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
+/* turn on 16 bit byte swapping */
+void PNGAPI
+png_set_swap(png_structp png_ptr)
+{
+ png_debug(1, "in png_set_swap\n");
+ if (png_ptr == NULL) return;
+ if (png_ptr->bit_depth == 16)
+ png_ptr->transformations |= PNG_SWAP_BYTES;
+}
+#endif
+
+#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
+/* turn on pixel packing */
+void PNGAPI
+png_set_packing(png_structp png_ptr)
+{
+ png_debug(1, "in png_set_packing\n");
+ if (png_ptr == NULL) return;
+ if (png_ptr->bit_depth < 8)
+ {
+ png_ptr->transformations |= PNG_PACK;
+ png_ptr->usr_bit_depth = 8;
+ }
+}
+#endif
+
+#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
+/* turn on packed pixel swapping */
+void PNGAPI
+png_set_packswap(png_structp png_ptr)
+{
+ png_debug(1, "in png_set_packswap\n");
+ if (png_ptr == NULL) return;
+ if (png_ptr->bit_depth < 8)
+ png_ptr->transformations |= PNG_PACKSWAP;
+}
+#endif
+
+#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
+void PNGAPI
+png_set_shift(png_structp png_ptr, png_color_8p true_bits)
+{
+ png_debug(1, "in png_set_shift\n");
+ if (png_ptr == NULL) return;
+ png_ptr->transformations |= PNG_SHIFT;
+ png_ptr->shift = *true_bits;
+}
+#endif
+
+#if defined(PNG_READ_INTERLACING_SUPPORTED) || \
+ defined(PNG_WRITE_INTERLACING_SUPPORTED)
+int PNGAPI
+png_set_interlace_handling(png_structp png_ptr)
+{
+ png_debug(1, "in png_set_interlace handling\n");
+ if (png_ptr && png_ptr->interlaced)
+ {
+ png_ptr->transformations |= PNG_INTERLACE;
+ return (7);
+ }
+
+ return (1);
+}
+#endif
+
+#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
+/* Add a filler byte on read, or remove a filler or alpha byte on write.
+ * The filler type has changed in v0.95 to allow future 2-byte fillers
+ * for 48-bit input data, as well as to avoid problems with some compilers
+ * that don't like bytes as parameters.
+ */
+void PNGAPI
+png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc)
+{
+ png_debug(1, "in png_set_filler\n");
+ if (png_ptr == NULL) return;
+ png_ptr->transformations |= PNG_FILLER;
+ png_ptr->filler = (png_byte)filler;
+ if (filler_loc == PNG_FILLER_AFTER)
+ png_ptr->flags |= PNG_FLAG_FILLER_AFTER;
+ else
+ png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER;
+
+ /* This should probably go in the "do_read_filler" routine.
+ * I attempted to do that in libpng-1.0.1a but that caused problems
+ * so I restored it in libpng-1.0.2a
+ */
+
+ if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
+ {
+ png_ptr->usr_channels = 4;
+ }
+
+ /* Also I added this in libpng-1.0.2a (what happens when we expand
+ * a less-than-8-bit grayscale to GA? */
+
+ if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY && png_ptr->bit_depth >= 8)
+ {
+ png_ptr->usr_channels = 2;
+ }
+}
+
+#if !defined(PNG_1_0_X)
+/* Added to libpng-1.2.7 */
+void PNGAPI
+png_set_add_alpha(png_structp png_ptr, png_uint_32 filler, int filler_loc)
+{
+ png_debug(1, "in png_set_add_alpha\n");
+ if (png_ptr == NULL) return;
+ png_set_filler(png_ptr, filler, filler_loc);
+ png_ptr->transformations |= PNG_ADD_ALPHA;
+}
+#endif
+
+#endif
+
+#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \
+ defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
+void PNGAPI
+png_set_swap_alpha(png_structp png_ptr)
+{
+ png_debug(1, "in png_set_swap_alpha\n");
+ if (png_ptr == NULL) return;
+ png_ptr->transformations |= PNG_SWAP_ALPHA;
+}
+#endif
+
+#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \
+ defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
+void PNGAPI
+png_set_invert_alpha(png_structp png_ptr)
+{
+ png_debug(1, "in png_set_invert_alpha\n");
+ if (png_ptr == NULL) return;
+ png_ptr->transformations |= PNG_INVERT_ALPHA;
+}
+#endif
+
+#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
+void PNGAPI
+png_set_invert_mono(png_structp png_ptr)
+{
+ png_debug(1, "in png_set_invert_mono\n");
+ if (png_ptr == NULL) return;
+ png_ptr->transformations |= PNG_INVERT_MONO;
+}
+
+/* invert monochrome grayscale data */
+void /* PRIVATE */
+png_do_invert(png_row_infop row_info, png_bytep row)
+{
+ png_debug(1, "in png_do_invert\n");
+ /* This test removed from libpng version 1.0.13 and 1.2.0:
+ * if (row_info->bit_depth == 1 &&
+ */
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+ if (row == NULL || row_info == NULL)
+ return;
+#endif
+ if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
+ {
+ png_bytep rp = row;
+ png_uint_32 i;
+ png_uint_32 istop = row_info->rowbytes;
+
+ for (i = 0; i < istop; i++)
+ {
+ *rp = (png_byte)(~(*rp));
+ rp++;
+ }
+ }
+ else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
+ row_info->bit_depth == 8)
+ {
+ png_bytep rp = row;
+ png_uint_32 i;
+ png_uint_32 istop = row_info->rowbytes;
+
+ for (i = 0; i < istop; i+=2)
+ {
+ *rp = (png_byte)(~(*rp));
+ rp+=2;
+ }
+ }
+ else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
+ row_info->bit_depth == 16)
+ {
+ png_bytep rp = row;
+ png_uint_32 i;
+ png_uint_32 istop = row_info->rowbytes;
+
+ for (i = 0; i < istop; i+=4)
+ {
+ *rp = (png_byte)(~(*rp));
+ *(rp+1) = (png_byte)(~(*(rp+1)));
+ rp+=4;
+ }
+ }
+}
+#endif
+
+#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
+/* swaps byte order on 16 bit depth images */
+void /* PRIVATE */
+png_do_swap(png_row_infop row_info, png_bytep row)
+{
+ png_debug(1, "in png_do_swap\n");
+ if (
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+ row != NULL && row_info != NULL &&
+#endif
+ row_info->bit_depth == 16)
+ {
+ png_bytep rp = row;
+ png_uint_32 i;
+ png_uint_32 istop= row_info->width * row_info->channels;
+
+ for (i = 0; i < istop; i++, rp += 2)
+ {
+ png_byte t = *rp;
+ *rp = *(rp + 1);
+ *(rp + 1) = t;
+ }
+ }
+}
+#endif
+
+#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
+static PNG_CONST png_byte onebppswaptable[256] = {
+ 0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,
+ 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
+ 0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,
+ 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
+ 0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,
+ 0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
+ 0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,
+ 0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
+ 0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,
+ 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,
+ 0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,
+ 0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
+ 0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,
+ 0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
+ 0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,
+ 0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
+ 0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,
+ 0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
+ 0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,
+ 0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
+ 0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,
+ 0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
+ 0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,
+ 0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
+ 0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,
+ 0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
+ 0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,
+ 0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
+ 0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,
+ 0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
+ 0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,
+ 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
+};
+
+static PNG_CONST png_byte twobppswaptable[256] = {
+ 0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0,
+ 0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0,
+ 0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4,
+ 0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4,
+ 0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8,
+ 0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8,
+ 0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC,
+ 0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC,
+ 0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1,
+ 0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1,
+ 0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5,
+ 0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5,
+ 0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9,
+ 0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9,
+ 0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD,
+ 0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD,
+ 0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2,
+ 0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2,
+ 0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6,
+ 0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6,
+ 0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA,
+ 0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA,
+ 0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE,
+ 0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE,
+ 0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3,
+ 0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3,
+ 0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7,
+ 0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7,
+ 0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB,
+ 0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB,
+ 0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF,
+ 0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF
+};
+
+static PNG_CONST png_byte fourbppswaptable[256] = {
+ 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
+ 0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0,
+ 0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71,
+ 0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1,
+ 0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72,
+ 0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2,
+ 0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73,
+ 0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3,
+ 0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74,
+ 0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4,
+ 0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75,
+ 0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5,
+ 0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76,
+ 0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6,
+ 0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77,
+ 0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7,
+ 0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78,
+ 0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8,
+ 0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79,
+ 0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9,
+ 0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A,
+ 0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA,
+ 0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B,
+ 0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB,
+ 0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C,
+ 0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC,
+ 0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D,
+ 0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD,
+ 0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E,
+ 0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE,
+ 0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F,
+ 0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF
+};
+
+/* swaps pixel packing order within bytes */
+void /* PRIVATE */
+png_do_packswap(png_row_infop row_info, png_bytep row)
+{
+ png_debug(1, "in png_do_packswap\n");
+ if (
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+ row != NULL && row_info != NULL &&
+#endif
+ row_info->bit_depth < 8)
+ {
+ png_bytep rp, end, table;
+
+ end = row + row_info->rowbytes;
+
+ if (row_info->bit_depth == 1)
+ table = (png_bytep)onebppswaptable;
+ else if (row_info->bit_depth == 2)
+ table = (png_bytep)twobppswaptable;
+ else if (row_info->bit_depth == 4)
+ table = (png_bytep)fourbppswaptable;
+ else
+ return;
+
+ for (rp = row; rp < end; rp++)
+ *rp = table[*rp];
+ }
+}
+#endif /* PNG_READ_PACKSWAP_SUPPORTED or PNG_WRITE_PACKSWAP_SUPPORTED */
+
+#if defined(PNG_WRITE_FILLER_SUPPORTED) || \
+ defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
+/* remove filler or alpha byte(s) */
+void /* PRIVATE */
+png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
+{
+ png_debug(1, "in png_do_strip_filler\n");
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+ if (row != NULL && row_info != NULL)
+#endif
+ {
+ png_bytep sp=row;
+ png_bytep dp=row;
+ png_uint_32 row_width=row_info->width;
+ png_uint_32 i;
+
+ if ((row_info->color_type == PNG_COLOR_TYPE_RGB ||
+ (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&
+ (flags & PNG_FLAG_STRIP_ALPHA))) &&
+ row_info->channels == 4)
+ {
+ if (row_info->bit_depth == 8)
+ {
+ /* This converts from RGBX or RGBA to RGB */
+ if (flags & PNG_FLAG_FILLER_AFTER)
+ {
+ dp+=3; sp+=4;
+ for (i = 1; i < row_width; i++)
+ {
+ *dp++ = *sp++;
+ *dp++ = *sp++;
+ *dp++ = *sp++;
+ sp++;
+ }
+ }
+ /* This converts from XRGB or ARGB to RGB */
+ else
+ {
+ for (i = 0; i < row_width; i++)
+ {
+ sp++;
+ *dp++ = *sp++;
+ *dp++ = *sp++;
+ *dp++ = *sp++;
+ }
+ }
+ row_info->pixel_depth = 24;
+ row_info->rowbytes = row_width * 3;
+ }
+ else /* if (row_info->bit_depth == 16) */
+ {
+ if (flags & PNG_FLAG_FILLER_AFTER)
+ {
+ /* This converts from RRGGBBXX or RRGGBBAA to RRGGBB */
+ sp += 8; dp += 6;
+ for (i = 1; i < row_width; i++)
+ {
+ /* This could be (although png_memcpy is probably slower):
+ png_memcpy(dp, sp, 6);
+ sp += 8;
+ dp += 6;
+ */
+
+ *dp++ = *sp++;
+ *dp++ = *sp++;
+ *dp++ = *sp++;
+ *dp++ = *sp++;
+ *dp++ = *sp++;
+ *dp++ = *sp++;
+ sp += 2;
+ }
+ }
+ else
+ {
+ /* This converts from XXRRGGBB or AARRGGBB to RRGGBB */
+ for (i = 0; i < row_width; i++)
+ {
+ /* This could be (although png_memcpy is probably slower):
+ png_memcpy(dp, sp, 6);
+ sp += 8;
+ dp += 6;
+ */
+
+ sp+=2;
+ *dp++ = *sp++;
+ *dp++ = *sp++;
+ *dp++ = *sp++;
+ *dp++ = *sp++;
+ *dp++ = *sp++;
+ *dp++ = *sp++;
+ }
+ }
+ row_info->pixel_depth = 48;
+ row_info->rowbytes = row_width * 6;
+ }
+ row_info->channels = 3;
+ }
+ else if ((row_info->color_type == PNG_COLOR_TYPE_GRAY ||
+ (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
+ (flags & PNG_FLAG_STRIP_ALPHA))) &&
+ row_info->channels == 2)
+ {
+ if (row_info->bit_depth == 8)
+ {
+ /* This converts from GX or GA to G */
+ if (flags & PNG_FLAG_FILLER_AFTER)
+ {
+ for (i = 0; i < row_width; i++)
+ {
+ *dp++ = *sp++;
+ sp++;
+ }
+ }
+ /* This converts from XG or AG to G */
+ else
+ {
+ for (i = 0; i < row_width; i++)
+ {
+ sp++;
+ *dp++ = *sp++;
+ }
+ }
+ row_info->pixel_depth = 8;
+ row_info->rowbytes = row_width;
+ }
+ else /* if (row_info->bit_depth == 16) */
+ {
+ if (flags & PNG_FLAG_FILLER_AFTER)
+ {
+ /* This converts from GGXX or GGAA to GG */
+ sp += 4; dp += 2;
+ for (i = 1; i < row_width; i++)
+ {
+ *dp++ = *sp++;
+ *dp++ = *sp++;
+ sp += 2;
+ }
+ }
+ else
+ {
+ /* This converts from XXGG or AAGG to GG */
+ for (i = 0; i < row_width; i++)
+ {
+ sp += 2;
+ *dp++ = *sp++;
+ *dp++ = *sp++;
+ }
+ }
+ row_info->pixel_depth = 16;
+ row_info->rowbytes = row_width * 2;
+ }
+ row_info->channels = 1;
+ }
+ if (flags & PNG_FLAG_STRIP_ALPHA)
+ row_info->color_type &= ~PNG_COLOR_MASK_ALPHA;
+ }
+}
+#endif
+
+#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
+/* swaps red and blue bytes within a pixel */
+void /* PRIVATE */
+png_do_bgr(png_row_infop row_info, png_bytep row)
+{
+ png_debug(1, "in png_do_bgr\n");
+ if (
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+ row != NULL && row_info != NULL &&
+#endif
+ (row_info->color_type & PNG_COLOR_MASK_COLOR))
+ {
+ png_uint_32 row_width = row_info->width;
+ if (row_info->bit_depth == 8)
+ {
+ if (row_info->color_type == PNG_COLOR_TYPE_RGB)
+ {
+ png_bytep rp;
+ png_uint_32 i;
+
+ for (i = 0, rp = row; i < row_width; i++, rp += 3)
+ {
+ png_byte save = *rp;
+ *rp = *(rp + 2);
+ *(rp + 2) = save;
+ }
+ }
+ else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+ {
+ png_bytep rp;
+ png_uint_32 i;
+
+ for (i = 0, rp = row; i < row_width; i++, rp += 4)
+ {
+ png_byte save = *rp;
+ *rp = *(rp + 2);
+ *(rp + 2) = save;
+ }
+ }
+ }
+ else if (row_info->bit_depth == 16)
+ {
+ if (row_info->color_type == PNG_COLOR_TYPE_RGB)
+ {
+ png_bytep rp;
+ png_uint_32 i;
+
+ for (i = 0, rp = row; i < row_width; i++, rp += 6)
+ {
+ png_byte save = *rp;
+ *rp = *(rp + 4);
+ *(rp + 4) = save;
+ save = *(rp + 1);
+ *(rp + 1) = *(rp + 5);
+ *(rp + 5) = save;
+ }
+ }
+ else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+ {
+ png_bytep rp;
+ png_uint_32 i;
+
+ for (i = 0, rp = row; i < row_width; i++, rp += 8)
+ {
+ png_byte save = *rp;
+ *rp = *(rp + 4);
+ *(rp + 4) = save;
+ save = *(rp + 1);
+ *(rp + 1) = *(rp + 5);
+ *(rp + 5) = save;
+ }
+ }
+ }
+ }
+}
+#endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */
+
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
+ defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \
+ defined(PNG_LEGACY_SUPPORTED)
+void PNGAPI
+png_set_user_transform_info(png_structp png_ptr, png_voidp
+ user_transform_ptr, int user_transform_depth, int user_transform_channels)
+{
+ png_debug(1, "in png_set_user_transform_info\n");
+ if (png_ptr == NULL) return;
+#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
+ png_ptr->user_transform_ptr = user_transform_ptr;
+ png_ptr->user_transform_depth = (png_byte)user_transform_depth;
+ png_ptr->user_transform_channels = (png_byte)user_transform_channels;
+#else
+ if (user_transform_ptr || user_transform_depth || user_transform_channels)
+ png_warning(png_ptr,
+ "This version of libpng does not support user transform info");
+#endif
+}
+#endif
+
+/* This function returns a pointer to the user_transform_ptr associated with
+ * the user transform functions. The application should free any memory
+ * associated with this pointer before png_write_destroy and png_read_destroy
+ * are called.
+ */
+png_voidp PNGAPI
+png_get_user_transform_ptr(png_structp png_ptr)
+{
+ if (png_ptr == NULL) return (NULL);
+#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
+ return ((png_voidp)png_ptr->user_transform_ptr);
+#else
+ return (NULL);
+#endif
+}
+#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
--- /dev/null
+
+/* pngwio.c - functions for data output
+ *
+ * Last changed in libpng 1.2.30 [August 15, 2008]
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * This file provides a location for all output. Users who need
+ * special handling are expected to write functions that have the same
+ * arguments as these and perform similar functions, but that possibly
+ * use different output methods. Note that you shouldn't change these
+ * functions, but rather write replacement functions and then change
+ * them at run time with png_set_write_fn(...).
+ */
+
+#define PNG_INTERNAL
+#include "png.h"
+#ifdef PNG_WRITE_SUPPORTED
+
+/* Write the data to whatever output you are using. The default routine
+ writes to a file pointer. Note that this routine sometimes gets called
+ with very small lengths, so you should implement some kind of simple
+ buffering if you are using unbuffered writes. This should never be asked
+ to write more than 64K on a 16 bit machine. */
+
+void /* PRIVATE */
+png_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+ if (png_ptr->write_data_fn != NULL )
+ (*(png_ptr->write_data_fn))(png_ptr, data, length);
+ else
+ png_error(png_ptr, "Call to NULL write function");
+}
+
+#if !defined(PNG_NO_STDIO)
+/* This is the function that does the actual writing of data. If you are
+ not writing to a standard C stream, you should create a replacement
+ write_data function and use it at run time with png_set_write_fn(), rather
+ than changing the library. */
+#ifndef USE_FAR_KEYWORD
+void PNGAPI
+png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+ png_uint_32 check;
+
+ if (png_ptr == NULL) return;
+#if defined(_WIN32_WCE)
+ if ( !WriteFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) )
+ check = 0;
+#else
+ check = fwrite(data, 1, length, (png_FILE_p)(png_ptr->io_ptr));
+#endif
+ if (check != length)
+ png_error(png_ptr, "Write Error");
+}
+#else
+/* this is the model-independent version. Since the standard I/O library
+ can't handle far buffers in the medium and small models, we have to copy
+ the data.
+*/
+
+#define NEAR_BUF_SIZE 1024
+#define MIN(a,b) (a <= b ? a : b)
+
+void PNGAPI
+png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+ png_uint_32 check;
+ png_byte *near_data; /* Needs to be "png_byte *" instead of "png_bytep" */
+ png_FILE_p io_ptr;
+
+ if (png_ptr == NULL) return;
+ /* Check if data really is near. If so, use usual code. */
+ near_data = (png_byte *)CVT_PTR_NOCHECK(data);
+ io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);
+ if ((png_bytep)near_data == data)
+ {
+#if defined(_WIN32_WCE)
+ if ( !WriteFile(io_ptr, near_data, length, &check, NULL) )
+ check = 0;
+#else
+ check = fwrite(near_data, 1, length, io_ptr);
+#endif
+ }
+ else
+ {
+ png_byte buf[NEAR_BUF_SIZE];
+ png_size_t written, remaining, err;
+ check = 0;
+ remaining = length;
+ do
+ {
+ written = MIN(NEAR_BUF_SIZE, remaining);
+ png_memcpy(buf, data, written); /* copy far buffer to near buffer */
+#if defined(_WIN32_WCE)
+ if ( !WriteFile(io_ptr, buf, written, &err, NULL) )
+ err = 0;
+#else
+ err = fwrite(buf, 1, written, io_ptr);
+#endif
+ if (err != written)
+ break;
+ else
+ check += err;
+ data += written;
+ remaining -= written;
+ }
+ while (remaining != 0);
+ }
+ if (check != length)
+ png_error(png_ptr, "Write Error");
+}
+
+#endif
+#endif
+
+/* This function is called to output any data pending writing (normally
+ to disk). After png_flush is called, there should be no data pending
+ writing in any buffers. */
+#if defined(PNG_WRITE_FLUSH_SUPPORTED)
+void /* PRIVATE */
+png_flush(png_structp png_ptr)
+{
+ if (png_ptr->output_flush_fn != NULL)
+ (*(png_ptr->output_flush_fn))(png_ptr);
+}
+
+#if !defined(PNG_NO_STDIO)
+void PNGAPI
+png_default_flush(png_structp png_ptr)
+{
+#if !defined(_WIN32_WCE)
+ png_FILE_p io_ptr;
+#endif
+ if (png_ptr == NULL) return;
+#if !defined(_WIN32_WCE)
+ io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr));
+ if (io_ptr != NULL)
+ fflush(io_ptr);
+#endif
+}
+#endif
+#endif
+
+/* This function allows the application to supply new output functions for
+ libpng if standard C streams aren't being used.
+
+ This function takes as its arguments:
+ png_ptr - pointer to a png output data structure
+ io_ptr - pointer to user supplied structure containing info about
+ the output functions. May be NULL.
+ write_data_fn - pointer to a new output function that takes as its
+ arguments a pointer to a png_struct, a pointer to
+ data to be written, and a 32-bit unsigned int that is
+ the number of bytes to be written. The new write
+ function should call png_error(png_ptr, "Error msg")
+ to exit and output any fatal error messages.
+ flush_data_fn - pointer to a new flush function that takes as its
+ arguments a pointer to a png_struct. After a call to
+ the flush function, there should be no data in any buffers
+ or pending transmission. If the output method doesn't do
+ any buffering of ouput, a function prototype must still be
+ supplied although it doesn't have to do anything. If
+ PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile
+ time, output_flush_fn will be ignored, although it must be
+ supplied for compatibility. */
+void PNGAPI
+png_set_write_fn(png_structp png_ptr, png_voidp io_ptr,
+ png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)
+{
+ if (png_ptr == NULL) return;
+ png_ptr->io_ptr = io_ptr;
+
+#if !defined(PNG_NO_STDIO)
+ if (write_data_fn != NULL)
+ png_ptr->write_data_fn = write_data_fn;
+ else
+ png_ptr->write_data_fn = png_default_write_data;
+#else
+ png_ptr->write_data_fn = write_data_fn;
+#endif
+
+#if defined(PNG_WRITE_FLUSH_SUPPORTED)
+#if !defined(PNG_NO_STDIO)
+ if (output_flush_fn != NULL)
+ png_ptr->output_flush_fn = output_flush_fn;
+ else
+ png_ptr->output_flush_fn = png_default_flush;
+#else
+ png_ptr->output_flush_fn = output_flush_fn;
+#endif
+#endif /* PNG_WRITE_FLUSH_SUPPORTED */
+
+ /* It is an error to read while writing a png file */
+ if (png_ptr->read_data_fn != NULL)
+ {
+ png_ptr->read_data_fn = NULL;
+ png_warning(png_ptr,
+ "Attempted to set both read_data_fn and write_data_fn in");
+ png_warning(png_ptr,
+ "the same structure. Resetting read_data_fn to NULL.");
+ }
+}
+
+#if defined(USE_FAR_KEYWORD)
+#if defined(_MSC_VER)
+void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check)
+{
+ void *near_ptr;
+ void FAR *far_ptr;
+ FP_OFF(near_ptr) = FP_OFF(ptr);
+ far_ptr = (void FAR *)near_ptr;
+ if (check != 0)
+ if (FP_SEG(ptr) != FP_SEG(far_ptr))
+ png_error(png_ptr, "segment lost in conversion");
+ return(near_ptr);
+}
+# else
+void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check)
+{
+ void *near_ptr;
+ void FAR *far_ptr;
+ near_ptr = (void FAR *)ptr;
+ far_ptr = (void FAR *)near_ptr;
+ if (check != 0)
+ if (far_ptr != ptr)
+ png_error(png_ptr, "segment lost in conversion");
+ return(near_ptr);
+}
+# endif
+# endif
+#endif /* PNG_WRITE_SUPPORTED */
--- /dev/null
+
+/* pngwrite.c - general routines to write a PNG file
+ *
+ * Last changed in libpng 1.2.31 [August 19, 2008]
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ */
+
+/* get internal access to png.h */
+#define PNG_INTERNAL
+#include "png.h"
+#ifdef PNG_WRITE_SUPPORTED
+
+/* Writes all the PNG information. This is the suggested way to use the
+ * library. If you have a new chunk to add, make a function to write it,
+ * and put it in the correct location here. If you want the chunk written
+ * after the image data, put it in png_write_end(). I strongly encourage
+ * you to supply a PNG_INFO_ flag, and check info_ptr->valid before writing
+ * the chunk, as that will keep the code from breaking if you want to just
+ * write a plain PNG file. If you have long comments, I suggest writing
+ * them in png_write_end(), and compressing them.
+ */
+void PNGAPI
+png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr)
+{
+ png_debug(1, "in png_write_info_before_PLTE\n");
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+ if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))
+ {
+ png_write_sig(png_ptr); /* write PNG signature */
+#if defined(PNG_MNG_FEATURES_SUPPORTED)
+ if ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)&&(png_ptr->mng_features_permitted))
+ {
+ png_warning(png_ptr, "MNG features are not allowed in a PNG datastream");
+ png_ptr->mng_features_permitted=0;
+ }
+#endif
+ /* write IHDR information. */
+ png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height,
+ info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type,
+ info_ptr->filter_type,
+#if defined(PNG_WRITE_INTERLACING_SUPPORTED)
+ info_ptr->interlace_type);
+#else
+ 0);
+#endif
+ /* the rest of these check to see if the valid field has the appropriate
+ flag set, and if it does, writes the chunk. */
+#if defined(PNG_WRITE_gAMA_SUPPORTED)
+ if (info_ptr->valid & PNG_INFO_gAMA)
+ {
+# ifdef PNG_FLOATING_POINT_SUPPORTED
+ png_write_gAMA(png_ptr, info_ptr->gamma);
+#else
+#ifdef PNG_FIXED_POINT_SUPPORTED
+ png_write_gAMA_fixed(png_ptr, info_ptr->int_gamma);
+# endif
+#endif
+ }
+#endif
+#if defined(PNG_WRITE_sRGB_SUPPORTED)
+ if (info_ptr->valid & PNG_INFO_sRGB)
+ png_write_sRGB(png_ptr, (int)info_ptr->srgb_intent);
+#endif
+#if defined(PNG_WRITE_iCCP_SUPPORTED)
+ if (info_ptr->valid & PNG_INFO_iCCP)
+ png_write_iCCP(png_ptr, info_ptr->iccp_name, PNG_COMPRESSION_TYPE_BASE,
+ info_ptr->iccp_profile, (int)info_ptr->iccp_proflen);
+#endif
+#if defined(PNG_WRITE_sBIT_SUPPORTED)
+ if (info_ptr->valid & PNG_INFO_sBIT)
+ png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type);
+#endif
+#if defined(PNG_WRITE_cHRM_SUPPORTED)
+ if (info_ptr->valid & PNG_INFO_cHRM)
+ {
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+ png_write_cHRM(png_ptr,
+ info_ptr->x_white, info_ptr->y_white,
+ info_ptr->x_red, info_ptr->y_red,
+ info_ptr->x_green, info_ptr->y_green,
+ info_ptr->x_blue, info_ptr->y_blue);
+#else
+# ifdef PNG_FIXED_POINT_SUPPORTED
+ png_write_cHRM_fixed(png_ptr,
+ info_ptr->int_x_white, info_ptr->int_y_white,
+ info_ptr->int_x_red, info_ptr->int_y_red,
+ info_ptr->int_x_green, info_ptr->int_y_green,
+ info_ptr->int_x_blue, info_ptr->int_y_blue);
+# endif
+#endif
+ }
+#endif
+#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)
+ if (info_ptr->unknown_chunks_num)
+ {
+ png_unknown_chunk *up;
+
+ png_debug(5, "writing extra chunks\n");
+
+ for (up = info_ptr->unknown_chunks;
+ up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
+ up++)
+ {
+ int keep=png_handle_as_unknown(png_ptr, up->name);
+ if (keep != PNG_HANDLE_CHUNK_NEVER &&
+ up->location && !(up->location & PNG_HAVE_PLTE) &&
+ !(up->location & PNG_HAVE_IDAT) &&
+ ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS ||
+ (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))
+ {
+ if (up->size == 0)
+ png_warning(png_ptr, "Writing zero-length unknown chunk");
+ png_write_chunk(png_ptr, up->name, up->data, up->size);
+ }
+ }
+ }
+#endif
+ png_ptr->mode |= PNG_WROTE_INFO_BEFORE_PLTE;
+ }
+}
+
+void PNGAPI
+png_write_info(png_structp png_ptr, png_infop info_ptr)
+{
+#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)
+ int i;
+#endif
+
+ png_debug(1, "in png_write_info\n");
+
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+
+ png_write_info_before_PLTE(png_ptr, info_ptr);
+
+ if (info_ptr->valid & PNG_INFO_PLTE)
+ png_write_PLTE(png_ptr, info_ptr->palette,
+ (png_uint_32)info_ptr->num_palette);
+ else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+ png_error(png_ptr, "Valid palette required for paletted images");
+
+#if defined(PNG_WRITE_tRNS_SUPPORTED)
+ if (info_ptr->valid & PNG_INFO_tRNS)
+ {
+#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
+ /* invert the alpha channel (in tRNS) */
+ if ((png_ptr->transformations & PNG_INVERT_ALPHA) &&
+ info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+ {
+ int j;
+ for (j=0; j<(int)info_ptr->num_trans; j++)
+ info_ptr->trans[j] = (png_byte)(255 - info_ptr->trans[j]);
+ }
+#endif
+ png_write_tRNS(png_ptr, info_ptr->trans, &(info_ptr->trans_values),
+ info_ptr->num_trans, info_ptr->color_type);
+ }
+#endif
+#if defined(PNG_WRITE_bKGD_SUPPORTED)
+ if (info_ptr->valid & PNG_INFO_bKGD)
+ png_write_bKGD(png_ptr, &(info_ptr->background), info_ptr->color_type);
+#endif
+#if defined(PNG_WRITE_hIST_SUPPORTED)
+ if (info_ptr->valid & PNG_INFO_hIST)
+ png_write_hIST(png_ptr, info_ptr->hist, info_ptr->num_palette);
+#endif
+#if defined(PNG_WRITE_oFFs_SUPPORTED)
+ if (info_ptr->valid & PNG_INFO_oFFs)
+ png_write_oFFs(png_ptr, info_ptr->x_offset, info_ptr->y_offset,
+ info_ptr->offset_unit_type);
+#endif
+#if defined(PNG_WRITE_pCAL_SUPPORTED)
+ if (info_ptr->valid & PNG_INFO_pCAL)
+ png_write_pCAL(png_ptr, info_ptr->pcal_purpose, info_ptr->pcal_X0,
+ info_ptr->pcal_X1, info_ptr->pcal_type, info_ptr->pcal_nparams,
+ info_ptr->pcal_units, info_ptr->pcal_params);
+#endif
+#if defined(PNG_WRITE_sCAL_SUPPORTED)
+ if (info_ptr->valid & PNG_INFO_sCAL)
+#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO)
+ png_write_sCAL(png_ptr, (int)info_ptr->scal_unit,
+ info_ptr->scal_pixel_width, info_ptr->scal_pixel_height);
+#else
+#ifdef PNG_FIXED_POINT_SUPPORTED
+ png_write_sCAL_s(png_ptr, (int)info_ptr->scal_unit,
+ info_ptr->scal_s_width, info_ptr->scal_s_height);
+#else
+ png_warning(png_ptr,
+ "png_write_sCAL not supported; sCAL chunk not written.");
+#endif
+#endif
+#endif
+#if defined(PNG_WRITE_pHYs_SUPPORTED)
+ if (info_ptr->valid & PNG_INFO_pHYs)
+ png_write_pHYs(png_ptr, info_ptr->x_pixels_per_unit,
+ info_ptr->y_pixels_per_unit, info_ptr->phys_unit_type);
+#endif
+#if defined(PNG_WRITE_tIME_SUPPORTED)
+ if (info_ptr->valid & PNG_INFO_tIME)
+ {
+ png_write_tIME(png_ptr, &(info_ptr->mod_time));
+ png_ptr->mode |= PNG_WROTE_tIME;
+ }
+#endif
+#if defined(PNG_WRITE_sPLT_SUPPORTED)
+ if (info_ptr->valid & PNG_INFO_sPLT)
+ for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
+ png_write_sPLT(png_ptr, info_ptr->splt_palettes + i);
+#endif
+#if defined(PNG_WRITE_TEXT_SUPPORTED)
+ /* Check to see if we need to write text chunks */
+ for (i = 0; i < info_ptr->num_text; i++)
+ {
+ png_debug2(2, "Writing header text chunk %d, type %d\n", i,
+ info_ptr->text[i].compression);
+ /* an internationalized chunk? */
+ if (info_ptr->text[i].compression > 0)
+ {
+#if defined(PNG_WRITE_iTXt_SUPPORTED)
+ /* write international chunk */
+ png_write_iTXt(png_ptr,
+ info_ptr->text[i].compression,
+ info_ptr->text[i].key,
+ info_ptr->text[i].lang,
+ info_ptr->text[i].lang_key,
+ info_ptr->text[i].text);
+#else
+ png_warning(png_ptr, "Unable to write international text");
+#endif
+ /* Mark this chunk as written */
+ info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
+ }
+ /* If we want a compressed text chunk */
+ else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_zTXt)
+ {
+#if defined(PNG_WRITE_zTXt_SUPPORTED)
+ /* write compressed chunk */
+ png_write_zTXt(png_ptr, info_ptr->text[i].key,
+ info_ptr->text[i].text, 0,
+ info_ptr->text[i].compression);
+#else
+ png_warning(png_ptr, "Unable to write compressed text");
+#endif
+ /* Mark this chunk as written */
+ info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
+ }
+ else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
+ {
+#if defined(PNG_WRITE_tEXt_SUPPORTED)
+ /* write uncompressed chunk */
+ png_write_tEXt(png_ptr, info_ptr->text[i].key,
+ info_ptr->text[i].text,
+ 0);
+#else
+ png_warning(png_ptr, "Unable to write uncompressed text");
+#endif
+ /* Mark this chunk as written */
+ info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
+ }
+ }
+#endif
+#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)
+ if (info_ptr->unknown_chunks_num)
+ {
+ png_unknown_chunk *up;
+
+ png_debug(5, "writing extra chunks\n");
+
+ for (up = info_ptr->unknown_chunks;
+ up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
+ up++)
+ {
+ int keep=png_handle_as_unknown(png_ptr, up->name);
+ if (keep != PNG_HANDLE_CHUNK_NEVER &&
+ up->location && (up->location & PNG_HAVE_PLTE) &&
+ !(up->location & PNG_HAVE_IDAT) &&
+ ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS ||
+ (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))
+ {
+ png_write_chunk(png_ptr, up->name, up->data, up->size);
+ }
+ }
+ }
+#endif
+}
+
+/* Writes the end of the PNG file. If you don't want to write comments or
+ * time information, you can pass NULL for info. If you already wrote these
+ * in png_write_info(), do not write them again here. If you have long
+ * comments, I suggest writing them here, and compressing them.
+ */
+void PNGAPI
+png_write_end(png_structp png_ptr, png_infop info_ptr)
+{
+ png_debug(1, "in png_write_end\n");
+ if (png_ptr == NULL)
+ return;
+ if (!(png_ptr->mode & PNG_HAVE_IDAT))
+ png_error(png_ptr, "No IDATs written into file");
+
+ /* see if user wants us to write information chunks */
+ if (info_ptr != NULL)
+ {
+#if defined(PNG_WRITE_TEXT_SUPPORTED)
+ int i; /* local index variable */
+#endif
+#if defined(PNG_WRITE_tIME_SUPPORTED)
+ /* check to see if user has supplied a time chunk */
+ if ((info_ptr->valid & PNG_INFO_tIME) &&
+ !(png_ptr->mode & PNG_WROTE_tIME))
+ png_write_tIME(png_ptr, &(info_ptr->mod_time));
+#endif
+#if defined(PNG_WRITE_TEXT_SUPPORTED)
+ /* loop through comment chunks */
+ for (i = 0; i < info_ptr->num_text; i++)
+ {
+ png_debug2(2, "Writing trailer text chunk %d, type %d\n", i,
+ info_ptr->text[i].compression);
+ /* an internationalized chunk? */
+ if (info_ptr->text[i].compression > 0)
+ {
+#if defined(PNG_WRITE_iTXt_SUPPORTED)
+ /* write international chunk */
+ png_write_iTXt(png_ptr,
+ info_ptr->text[i].compression,
+ info_ptr->text[i].key,
+ info_ptr->text[i].lang,
+ info_ptr->text[i].lang_key,
+ info_ptr->text[i].text);
+#else
+ png_warning(png_ptr, "Unable to write international text");
+#endif
+ /* Mark this chunk as written */
+ info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
+ }
+ else if (info_ptr->text[i].compression >= PNG_TEXT_COMPRESSION_zTXt)
+ {
+#if defined(PNG_WRITE_zTXt_SUPPORTED)
+ /* write compressed chunk */
+ png_write_zTXt(png_ptr, info_ptr->text[i].key,
+ info_ptr->text[i].text, 0,
+ info_ptr->text[i].compression);
+#else
+ png_warning(png_ptr, "Unable to write compressed text");
+#endif
+ /* Mark this chunk as written */
+ info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
+ }
+ else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
+ {
+#if defined(PNG_WRITE_tEXt_SUPPORTED)
+ /* write uncompressed chunk */
+ png_write_tEXt(png_ptr, info_ptr->text[i].key,
+ info_ptr->text[i].text, 0);
+#else
+ png_warning(png_ptr, "Unable to write uncompressed text");
+#endif
+
+ /* Mark this chunk as written */
+ info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
+ }
+ }
+#endif
+#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)
+ if (info_ptr->unknown_chunks_num)
+ {
+ png_unknown_chunk *up;
+
+ png_debug(5, "writing extra chunks\n");
+
+ for (up = info_ptr->unknown_chunks;
+ up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
+ up++)
+ {
+ int keep=png_handle_as_unknown(png_ptr, up->name);
+ if (keep != PNG_HANDLE_CHUNK_NEVER &&
+ up->location && (up->location & PNG_AFTER_IDAT) &&
+ ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS ||
+ (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))
+ {
+ png_write_chunk(png_ptr, up->name, up->data, up->size);
+ }
+ }
+ }
+#endif
+ }
+
+ png_ptr->mode |= PNG_AFTER_IDAT;
+
+ /* write end of PNG file */
+ png_write_IEND(png_ptr);
+ /* This flush, added in libpng-1.0.8, removed from libpng-1.0.9beta03,
+ * and restored again in libpng-1.2.30, may cause some applications that
+ * do not set png_ptr->output_flush_fn to crash. If your application
+ * experiences a problem, please try building libpng with
+ * PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED defined, and report the event to
+ * png-mng-implement at lists.sf.net . This kludge will be removed
+ * from libpng-1.4.0.
+ */
+#if defined(PNG_WRITE_FLUSH_SUPPORTED) && \
+ defined(PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED)
+ png_flush(png_ptr);
+#endif
+}
+
+#if defined(PNG_WRITE_tIME_SUPPORTED)
+#if !defined(_WIN32_WCE)
+/* "time.h" functions are not supported on WindowsCE */
+void PNGAPI
+png_convert_from_struct_tm(png_timep ptime, struct tm FAR * ttime)
+{
+ png_debug(1, "in png_convert_from_struct_tm\n");
+ ptime->year = (png_uint_16)(1900 + ttime->tm_year);
+ ptime->month = (png_byte)(ttime->tm_mon + 1);
+ ptime->day = (png_byte)ttime->tm_mday;
+ ptime->hour = (png_byte)ttime->tm_hour;
+ ptime->minute = (png_byte)ttime->tm_min;
+ ptime->second = (png_byte)ttime->tm_sec;
+}
+
+void PNGAPI
+png_convert_from_time_t(png_timep ptime, time_t ttime)
+{
+ struct tm *tbuf;
+
+ png_debug(1, "in png_convert_from_time_t\n");
+ tbuf = gmtime(&ttime);
+ png_convert_from_struct_tm(ptime, tbuf);
+}
+#endif
+#endif
+
+/* Initialize png_ptr structure, and allocate any memory needed */
+png_structp PNGAPI
+png_create_write_struct(png_const_charp user_png_ver, png_voidp error_ptr,
+ png_error_ptr error_fn, png_error_ptr warn_fn)
+{
+#ifdef PNG_USER_MEM_SUPPORTED
+ return (png_create_write_struct_2(user_png_ver, error_ptr, error_fn,
+ warn_fn, png_voidp_NULL, png_malloc_ptr_NULL, png_free_ptr_NULL));
+}
+
+/* Alternate initialize png_ptr structure, and allocate any memory needed */
+png_structp PNGAPI
+png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
+ png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
+ png_malloc_ptr malloc_fn, png_free_ptr free_fn)
+{
+#endif /* PNG_USER_MEM_SUPPORTED */
+#ifdef PNG_SETJMP_SUPPORTED
+ volatile
+#endif
+ png_structp png_ptr;
+#ifdef PNG_SETJMP_SUPPORTED
+#ifdef USE_FAR_KEYWORD
+ jmp_buf jmpbuf;
+#endif
+#endif
+ int i;
+ png_debug(1, "in png_create_write_struct\n");
+#ifdef PNG_USER_MEM_SUPPORTED
+ png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,
+ (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr);
+#else
+ png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);
+#endif /* PNG_USER_MEM_SUPPORTED */
+ if (png_ptr == NULL)
+ return (NULL);
+
+ /* added at libpng-1.2.6 */
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED
+ png_ptr->user_width_max=PNG_USER_WIDTH_MAX;
+ png_ptr->user_height_max=PNG_USER_HEIGHT_MAX;
+#endif
+
+#ifdef PNG_SETJMP_SUPPORTED
+#ifdef USE_FAR_KEYWORD
+ if (setjmp(jmpbuf))
+#else
+ if (setjmp(png_ptr->jmpbuf))
+#endif
+ {
+ png_free(png_ptr, png_ptr->zbuf);
+ png_ptr->zbuf=NULL;
+ png_destroy_struct(png_ptr);
+ return (NULL);
+ }
+#ifdef USE_FAR_KEYWORD
+ png_memcpy(png_ptr->jmpbuf, jmpbuf, png_sizeof(jmp_buf));
+#endif
+#endif
+
+#ifdef PNG_USER_MEM_SUPPORTED
+ png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);
+#endif /* PNG_USER_MEM_SUPPORTED */
+ png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);
+
+ if (user_png_ver)
+ {
+ i=0;
+ do
+ {
+ if (user_png_ver[i] != png_libpng_ver[i])
+ png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
+ } while (png_libpng_ver[i++]);
+ }
+
+ if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)
+ {
+ /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so
+ * we must recompile any applications that use any older library version.
+ * For versions after libpng 1.0, we will be compatible, so we need
+ * only check the first digit.
+ */
+ if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||
+ (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) ||
+ (user_png_ver[0] == '0' && user_png_ver[2] < '9'))
+ {
+#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)
+ char msg[80];
+ if (user_png_ver)
+ {
+ png_snprintf(msg, 80,
+ "Application was compiled with png.h from libpng-%.20s",
+ user_png_ver);
+ png_warning(png_ptr, msg);
+ }
+ png_snprintf(msg, 80,
+ "Application is running with png.c from libpng-%.20s",
+ png_libpng_ver);
+ png_warning(png_ptr, msg);
+#endif
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED
+ png_ptr->flags=0;
+#endif
+ png_error(png_ptr,
+ "Incompatible libpng version in application and library");
+ }
+ }
+
+ /* initialize zbuf - compression buffer */
+ png_ptr->zbuf_size = PNG_ZBUF_SIZE;
+ png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
+ (png_uint_32)png_ptr->zbuf_size);
+
+ png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL,
+ png_flush_ptr_NULL);
+
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
+ png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT,
+ 1, png_doublep_NULL, png_doublep_NULL);
+#endif
+
+#ifdef PNG_SETJMP_SUPPORTED
+/* Applications that neglect to set up their own setjmp() and then encounter
+ a png_error() will longjmp here. Since the jmpbuf is then meaningless we
+ abort instead of returning. */
+#ifdef USE_FAR_KEYWORD
+ if (setjmp(jmpbuf))
+ PNG_ABORT();
+ png_memcpy(png_ptr->jmpbuf, jmpbuf, png_sizeof(jmp_buf));
+#else
+ if (setjmp(png_ptr->jmpbuf))
+ PNG_ABORT();
+#endif
+#endif
+ return (png_ptr);
+}
+
+/* Initialize png_ptr structure, and allocate any memory needed */
+#if defined(PNG_1_0_X) || defined(PNG_1_2_X)
+/* Deprecated. */
+#undef png_write_init
+void PNGAPI
+png_write_init(png_structp png_ptr)
+{
+ /* We only come here via pre-1.0.7-compiled applications */
+ png_write_init_2(png_ptr, "1.0.6 or earlier", 0, 0);
+}
+
+void PNGAPI
+png_write_init_2(png_structp png_ptr, png_const_charp user_png_ver,
+ png_size_t png_struct_size, png_size_t png_info_size)
+{
+ /* We only come here via pre-1.0.12-compiled applications */
+ if (png_ptr == NULL) return;
+#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)
+ if (png_sizeof(png_struct) > png_struct_size ||
+ png_sizeof(png_info) > png_info_size)
+ {
+ char msg[80];
+ png_ptr->warning_fn=NULL;
+ if (user_png_ver)
+ {
+ png_snprintf(msg, 80,
+ "Application was compiled with png.h from libpng-%.20s",
+ user_png_ver);
+ png_warning(png_ptr, msg);
+ }
+ png_snprintf(msg, 80,
+ "Application is running with png.c from libpng-%.20s",
+ png_libpng_ver);
+ png_warning(png_ptr, msg);
+ }
+#endif
+ if (png_sizeof(png_struct) > png_struct_size)
+ {
+ png_ptr->error_fn=NULL;
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED
+ png_ptr->flags=0;
+#endif
+ png_error(png_ptr,
+ "The png struct allocated by the application for writing is too small.");
+ }
+ if (png_sizeof(png_info) > png_info_size)
+ {
+ png_ptr->error_fn=NULL;
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED
+ png_ptr->flags=0;
+#endif
+ png_error(png_ptr,
+ "The info struct allocated by the application for writing is too small.");
+ }
+ png_write_init_3(&png_ptr, user_png_ver, png_struct_size);
+}
+#endif /* PNG_1_0_X || PNG_1_2_X */
+
+
+void PNGAPI
+png_write_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver,
+ png_size_t png_struct_size)
+{
+ png_structp png_ptr=*ptr_ptr;
+#ifdef PNG_SETJMP_SUPPORTED
+ jmp_buf tmp_jmp; /* to save current jump buffer */
+#endif
+
+ int i = 0;
+
+ if (png_ptr == NULL)
+ return;
+
+ do
+ {
+ if (user_png_ver[i] != png_libpng_ver[i])
+ {
+#ifdef PNG_LEGACY_SUPPORTED
+ png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
+#else
+ png_ptr->warning_fn=NULL;
+ png_warning(png_ptr,
+ "Application uses deprecated png_write_init() and should be recompiled.");
+ break;
+#endif
+ }
+ } while (png_libpng_ver[i++]);
+
+ png_debug(1, "in png_write_init_3\n");
+
+#ifdef PNG_SETJMP_SUPPORTED
+ /* save jump buffer and error functions */
+ png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf));
+#endif
+
+ if (png_sizeof(png_struct) > png_struct_size)
+ {
+ png_destroy_struct(png_ptr);
+ png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);
+ *ptr_ptr = png_ptr;
+ }
+
+ /* reset all variables to 0 */
+ png_memset(png_ptr, 0, png_sizeof(png_struct));
+
+ /* added at libpng-1.2.6 */
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED
+ png_ptr->user_width_max=PNG_USER_WIDTH_MAX;
+ png_ptr->user_height_max=PNG_USER_HEIGHT_MAX;
+#endif
+
+#ifdef PNG_SETJMP_SUPPORTED
+ /* restore jump buffer */
+ png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf));
+#endif
+
+ png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL,
+ png_flush_ptr_NULL);
+
+ /* initialize zbuf - compression buffer */
+ png_ptr->zbuf_size = PNG_ZBUF_SIZE;
+ png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
+ (png_uint_32)png_ptr->zbuf_size);
+
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
+ png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT,
+ 1, png_doublep_NULL, png_doublep_NULL);
+#endif
+}
+
+/* Write a few rows of image data. If the image is interlaced,
+ * either you will have to write the 7 sub images, or, if you
+ * have called png_set_interlace_handling(), you will have to
+ * "write" the image seven times.
+ */
+void PNGAPI
+png_write_rows(png_structp png_ptr, png_bytepp row,
+ png_uint_32 num_rows)
+{
+ png_uint_32 i; /* row counter */
+ png_bytepp rp; /* row pointer */
+
+ png_debug(1, "in png_write_rows\n");
+
+ if (png_ptr == NULL)
+ return;
+
+ /* loop through the rows */
+ for (i = 0, rp = row; i < num_rows; i++, rp++)
+ {
+ png_write_row(png_ptr, *rp);
+ }
+}
+
+/* Write the image. You only need to call this function once, even
+ * if you are writing an interlaced image.
+ */
+void PNGAPI
+png_write_image(png_structp png_ptr, png_bytepp image)
+{
+ png_uint_32 i; /* row index */
+ int pass, num_pass; /* pass variables */
+ png_bytepp rp; /* points to current row */
+
+ if (png_ptr == NULL)
+ return;
+
+ png_debug(1, "in png_write_image\n");
+#if defined(PNG_WRITE_INTERLACING_SUPPORTED)
+ /* intialize interlace handling. If image is not interlaced,
+ this will set pass to 1 */
+ num_pass = png_set_interlace_handling(png_ptr);
+#else
+ num_pass = 1;
+#endif
+ /* loop through passes */
+ for (pass = 0; pass < num_pass; pass++)
+ {
+ /* loop through image */
+ for (i = 0, rp = image; i < png_ptr->height; i++, rp++)
+ {
+ png_write_row(png_ptr, *rp);
+ }
+ }
+}
+
+/* called by user to write a row of image data */
+void PNGAPI
+png_write_row(png_structp png_ptr, png_bytep row)
+{
+ if (png_ptr == NULL)
+ return;
+ png_debug2(1, "in png_write_row (row %ld, pass %d)\n",
+ png_ptr->row_number, png_ptr->pass);
+
+ /* initialize transformations and other stuff if first time */
+ if (png_ptr->row_number == 0 && png_ptr->pass == 0)
+ {
+ /* make sure we wrote the header info */
+ if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))
+ png_error(png_ptr,
+ "png_write_info was never called before png_write_row.");
+
+ /* check for transforms that have been set but were defined out */
+#if !defined(PNG_WRITE_INVERT_SUPPORTED) && defined(PNG_READ_INVERT_SUPPORTED)
+ if (png_ptr->transformations & PNG_INVERT_MONO)
+ png_warning(png_ptr, "PNG_WRITE_INVERT_SUPPORTED is not defined.");
+#endif
+#if !defined(PNG_WRITE_FILLER_SUPPORTED) && defined(PNG_READ_FILLER_SUPPORTED)
+ if (png_ptr->transformations & PNG_FILLER)
+ png_warning(png_ptr, "PNG_WRITE_FILLER_SUPPORTED is not defined.");
+#endif
+#if !defined(PNG_WRITE_PACKSWAP_SUPPORTED) && defined(PNG_READ_PACKSWAP_SUPPORTED)
+ if (png_ptr->transformations & PNG_PACKSWAP)
+ png_warning(png_ptr, "PNG_WRITE_PACKSWAP_SUPPORTED is not defined.");
+#endif
+#if !defined(PNG_WRITE_PACK_SUPPORTED) && defined(PNG_READ_PACK_SUPPORTED)
+ if (png_ptr->transformations & PNG_PACK)
+ png_warning(png_ptr, "PNG_WRITE_PACK_SUPPORTED is not defined.");
+#endif
+#if !defined(PNG_WRITE_SHIFT_SUPPORTED) && defined(PNG_READ_SHIFT_SUPPORTED)
+ if (png_ptr->transformations & PNG_SHIFT)
+ png_warning(png_ptr, "PNG_WRITE_SHIFT_SUPPORTED is not defined.");
+#endif
+#if !defined(PNG_WRITE_BGR_SUPPORTED) && defined(PNG_READ_BGR_SUPPORTED)
+ if (png_ptr->transformations & PNG_BGR)
+ png_warning(png_ptr, "PNG_WRITE_BGR_SUPPORTED is not defined.");
+#endif
+#if !defined(PNG_WRITE_SWAP_SUPPORTED) && defined(PNG_READ_SWAP_SUPPORTED)
+ if (png_ptr->transformations & PNG_SWAP_BYTES)
+ png_warning(png_ptr, "PNG_WRITE_SWAP_SUPPORTED is not defined.");
+#endif
+
+ png_write_start_row(png_ptr);
+ }
+
+#if defined(PNG_WRITE_INTERLACING_SUPPORTED)
+ /* if interlaced and not interested in row, return */
+ if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
+ {
+ switch (png_ptr->pass)
+ {
+ case 0:
+ if (png_ptr->row_number & 0x07)
+ {
+ png_write_finish_row(png_ptr);
+ return;
+ }
+ break;
+ case 1:
+ if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)
+ {
+ png_write_finish_row(png_ptr);
+ return;
+ }
+ break;
+ case 2:
+ if ((png_ptr->row_number & 0x07) != 4)
+ {
+ png_write_finish_row(png_ptr);
+ return;
+ }
+ break;
+ case 3:
+ if ((png_ptr->row_number & 0x03) || png_ptr->width < 3)
+ {
+ png_write_finish_row(png_ptr);
+ return;
+ }
+ break;
+ case 4:
+ if ((png_ptr->row_number & 0x03) != 2)
+ {
+ png_write_finish_row(png_ptr);
+ return;
+ }
+ break;
+ case 5:
+ if ((png_ptr->row_number & 0x01) || png_ptr->width < 2)
+ {
+ png_write_finish_row(png_ptr);
+ return;
+ }
+ break;
+ case 6:
+ if (!(png_ptr->row_number & 0x01))
+ {
+ png_write_finish_row(png_ptr);
+ return;
+ }
+ break;
+ }
+ }
+#endif
+
+ /* set up row info for transformations */
+ png_ptr->row_info.color_type = png_ptr->color_type;
+ png_ptr->row_info.width = png_ptr->usr_width;
+ png_ptr->row_info.channels = png_ptr->usr_channels;
+ png_ptr->row_info.bit_depth = png_ptr->usr_bit_depth;
+ png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *
+ png_ptr->row_info.channels);
+
+ png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,
+ png_ptr->row_info.width);
+
+ png_debug1(3, "row_info->color_type = %d\n", png_ptr->row_info.color_type);
+ png_debug1(3, "row_info->width = %lu\n", png_ptr->row_info.width);
+ png_debug1(3, "row_info->channels = %d\n", png_ptr->row_info.channels);
+ png_debug1(3, "row_info->bit_depth = %d\n", png_ptr->row_info.bit_depth);
+ png_debug1(3, "row_info->pixel_depth = %d\n", png_ptr->row_info.pixel_depth);
+ png_debug1(3, "row_info->rowbytes = %lu\n", png_ptr->row_info.rowbytes);
+
+ /* Copy user's row into buffer, leaving room for filter byte. */
+ png_memcpy_check(png_ptr, png_ptr->row_buf + 1, row,
+ png_ptr->row_info.rowbytes);
+
+#if defined(PNG_WRITE_INTERLACING_SUPPORTED)
+ /* handle interlacing */
+ if (png_ptr->interlaced && png_ptr->pass < 6 &&
+ (png_ptr->transformations & PNG_INTERLACE))
+ {
+ png_do_write_interlace(&(png_ptr->row_info),
+ png_ptr->row_buf + 1, png_ptr->pass);
+ /* this should always get caught above, but still ... */
+ if (!(png_ptr->row_info.width))
+ {
+ png_write_finish_row(png_ptr);
+ return;
+ }
+ }
+#endif
+
+ /* handle other transformations */
+ if (png_ptr->transformations)
+ png_do_write_transformations(png_ptr);
+
+#if defined(PNG_MNG_FEATURES_SUPPORTED)
+ /* Write filter_method 64 (intrapixel differencing) only if
+ * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
+ * 2. Libpng did not write a PNG signature (this filter_method is only
+ * used in PNG datastreams that are embedded in MNG datastreams) and
+ * 3. The application called png_permit_mng_features with a mask that
+ * included PNG_FLAG_MNG_FILTER_64 and
+ * 4. The filter_method is 64 and
+ * 5. The color_type is RGB or RGBA
+ */
+ if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
+ (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))
+ {
+ /* Intrapixel differencing */
+ png_do_write_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1);
+ }
+#endif
+
+ /* Find a filter if necessary, filter the row and write it out. */
+ png_write_find_filter(png_ptr, &(png_ptr->row_info));
+
+ if (png_ptr->write_row_fn != NULL)
+ (*(png_ptr->write_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
+}
+
+#if defined(PNG_WRITE_FLUSH_SUPPORTED)
+/* Set the automatic flush interval or 0 to turn flushing off */
+void PNGAPI
+png_set_flush(png_structp png_ptr, int nrows)
+{
+ png_debug(1, "in png_set_flush\n");
+ if (png_ptr == NULL)
+ return;
+ png_ptr->flush_dist = (nrows < 0 ? 0 : nrows);
+}
+
+/* flush the current output buffers now */
+void PNGAPI
+png_write_flush(png_structp png_ptr)
+{
+ int wrote_IDAT;
+
+ png_debug(1, "in png_write_flush\n");
+ if (png_ptr == NULL)
+ return;
+ /* We have already written out all of the data */
+ if (png_ptr->row_number >= png_ptr->num_rows)
+ return;
+
+ do
+ {
+ int ret;
+
+ /* compress the data */
+ ret = deflate(&png_ptr->zstream, Z_SYNC_FLUSH);
+ wrote_IDAT = 0;
+
+ /* check for compression errors */
+ if (ret != Z_OK)
+ {
+ if (png_ptr->zstream.msg != NULL)
+ png_error(png_ptr, png_ptr->zstream.msg);
+ else
+ png_error(png_ptr, "zlib error");
+ }
+
+ if (!(png_ptr->zstream.avail_out))
+ {
+ /* write the IDAT and reset the zlib output buffer */
+ png_write_IDAT(png_ptr, png_ptr->zbuf,
+ png_ptr->zbuf_size);
+ png_ptr->zstream.next_out = png_ptr->zbuf;
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+ wrote_IDAT = 1;
+ }
+ } while(wrote_IDAT == 1);
+
+ /* If there is any data left to be output, write it into a new IDAT */
+ if (png_ptr->zbuf_size != png_ptr->zstream.avail_out)
+ {
+ /* write the IDAT and reset the zlib output buffer */
+ png_write_IDAT(png_ptr, png_ptr->zbuf,
+ png_ptr->zbuf_size - png_ptr->zstream.avail_out);
+ png_ptr->zstream.next_out = png_ptr->zbuf;
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+ }
+ png_ptr->flush_rows = 0;
+ png_flush(png_ptr);
+}
+#endif /* PNG_WRITE_FLUSH_SUPPORTED */
+
+/* free all memory used by the write */
+void PNGAPI
+png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)
+{
+ png_structp png_ptr = NULL;
+ png_infop info_ptr = NULL;
+#ifdef PNG_USER_MEM_SUPPORTED
+ png_free_ptr free_fn = NULL;
+ png_voidp mem_ptr = NULL;
+#endif
+
+ png_debug(1, "in png_destroy_write_struct\n");
+ if (png_ptr_ptr != NULL)
+ {
+ png_ptr = *png_ptr_ptr;
+#ifdef PNG_USER_MEM_SUPPORTED
+ free_fn = png_ptr->free_fn;
+ mem_ptr = png_ptr->mem_ptr;
+#endif
+ }
+
+#ifdef PNG_USER_MEM_SUPPORTED
+ if (png_ptr != NULL)
+ {
+ free_fn = png_ptr->free_fn;
+ mem_ptr = png_ptr->mem_ptr;
+ }
+#endif
+
+ if (info_ptr_ptr != NULL)
+ info_ptr = *info_ptr_ptr;
+
+ if (info_ptr != NULL)
+ {
+ if (png_ptr != NULL)
+ {
+ png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
+
+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
+ if (png_ptr->num_chunk_list)
+ {
+ png_free(png_ptr, png_ptr->chunk_list);
+ png_ptr->chunk_list=NULL;
+ png_ptr->num_chunk_list = 0;
+ }
+#endif
+ }
+
+#ifdef PNG_USER_MEM_SUPPORTED
+ png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn,
+ (png_voidp)mem_ptr);
+#else
+ png_destroy_struct((png_voidp)info_ptr);
+#endif
+ *info_ptr_ptr = NULL;
+ }
+
+ if (png_ptr != NULL)
+ {
+ png_write_destroy(png_ptr);
+#ifdef PNG_USER_MEM_SUPPORTED
+ png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn,
+ (png_voidp)mem_ptr);
+#else
+ png_destroy_struct((png_voidp)png_ptr);
+#endif
+ *png_ptr_ptr = NULL;
+ }
+}
+
+
+/* Free any memory used in png_ptr struct (old method) */
+void /* PRIVATE */
+png_write_destroy(png_structp png_ptr)
+{
+#ifdef PNG_SETJMP_SUPPORTED
+ jmp_buf tmp_jmp; /* save jump buffer */
+#endif
+ png_error_ptr error_fn;
+ png_error_ptr warning_fn;
+ png_voidp error_ptr;
+#ifdef PNG_USER_MEM_SUPPORTED
+ png_free_ptr free_fn;
+#endif
+
+ png_debug(1, "in png_write_destroy\n");
+ /* free any memory zlib uses */
+ deflateEnd(&png_ptr->zstream);
+
+ /* free our memory. png_free checks NULL for us. */
+ png_free(png_ptr, png_ptr->zbuf);
+ png_free(png_ptr, png_ptr->row_buf);
+#ifndef PNG_NO_WRITE_FILTER
+ png_free(png_ptr, png_ptr->prev_row);
+ png_free(png_ptr, png_ptr->sub_row);
+ png_free(png_ptr, png_ptr->up_row);
+ png_free(png_ptr, png_ptr->avg_row);
+ png_free(png_ptr, png_ptr->paeth_row);
+#endif
+
+#if defined(PNG_TIME_RFC1123_SUPPORTED)
+ png_free(png_ptr, png_ptr->time_buffer);
+#endif
+
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
+ png_free(png_ptr, png_ptr->prev_filters);
+ png_free(png_ptr, png_ptr->filter_weights);
+ png_free(png_ptr, png_ptr->inv_filter_weights);
+ png_free(png_ptr, png_ptr->filter_costs);
+ png_free(png_ptr, png_ptr->inv_filter_costs);
+#endif
+
+#ifdef PNG_SETJMP_SUPPORTED
+ /* reset structure */
+ png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf));
+#endif
+
+ error_fn = png_ptr->error_fn;
+ warning_fn = png_ptr->warning_fn;
+ error_ptr = png_ptr->error_ptr;
+#ifdef PNG_USER_MEM_SUPPORTED
+ free_fn = png_ptr->free_fn;
+#endif
+
+ png_memset(png_ptr, 0, png_sizeof(png_struct));
+
+ png_ptr->error_fn = error_fn;
+ png_ptr->warning_fn = warning_fn;
+ png_ptr->error_ptr = error_ptr;
+#ifdef PNG_USER_MEM_SUPPORTED
+ png_ptr->free_fn = free_fn;
+#endif
+
+#ifdef PNG_SETJMP_SUPPORTED
+ png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf));
+#endif
+}
+
+/* Allow the application to select one or more row filters to use. */
+void PNGAPI
+png_set_filter(png_structp png_ptr, int method, int filters)
+{
+ png_debug(1, "in png_set_filter\n");
+ if (png_ptr == NULL)
+ return;
+#if defined(PNG_MNG_FEATURES_SUPPORTED)
+ if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
+ (method == PNG_INTRAPIXEL_DIFFERENCING))
+ method = PNG_FILTER_TYPE_BASE;
+#endif
+ if (method == PNG_FILTER_TYPE_BASE)
+ {
+ switch (filters & (PNG_ALL_FILTERS | 0x07))
+ {
+#ifndef PNG_NO_WRITE_FILTER
+ case 5:
+ case 6:
+ case 7: png_warning(png_ptr, "Unknown row filter for method 0");
+#endif /* PNG_NO_WRITE_FILTER */
+ case PNG_FILTER_VALUE_NONE:
+ png_ptr->do_filter=PNG_FILTER_NONE; break;
+#ifndef PNG_NO_WRITE_FILTER
+ case PNG_FILTER_VALUE_SUB:
+ png_ptr->do_filter=PNG_FILTER_SUB; break;
+ case PNG_FILTER_VALUE_UP:
+ png_ptr->do_filter=PNG_FILTER_UP; break;
+ case PNG_FILTER_VALUE_AVG:
+ png_ptr->do_filter=PNG_FILTER_AVG; break;
+ case PNG_FILTER_VALUE_PAETH:
+ png_ptr->do_filter=PNG_FILTER_PAETH; break;
+ default: png_ptr->do_filter = (png_byte)filters; break;
+#else
+ default: png_warning(png_ptr, "Unknown row filter for method 0");
+#endif /* PNG_NO_WRITE_FILTER */
+ }
+
+ /* If we have allocated the row_buf, this means we have already started
+ * with the image and we should have allocated all of the filter buffers
+ * that have been selected. If prev_row isn't already allocated, then
+ * it is too late to start using the filters that need it, since we
+ * will be missing the data in the previous row. If an application
+ * wants to start and stop using particular filters during compression,
+ * it should start out with all of the filters, and then add and
+ * remove them after the start of compression.
+ */
+ if (png_ptr->row_buf != NULL)
+ {
+#ifndef PNG_NO_WRITE_FILTER
+ if ((png_ptr->do_filter & PNG_FILTER_SUB) && png_ptr->sub_row == NULL)
+ {
+ png_ptr->sub_row = (png_bytep)png_malloc(png_ptr,
+ (png_ptr->rowbytes + 1));
+ png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;
+ }
+
+ if ((png_ptr->do_filter & PNG_FILTER_UP) && png_ptr->up_row == NULL)
+ {
+ if (png_ptr->prev_row == NULL)
+ {
+ png_warning(png_ptr, "Can't add Up filter after starting");
+ png_ptr->do_filter &= ~PNG_FILTER_UP;
+ }
+ else
+ {
+ png_ptr->up_row = (png_bytep)png_malloc(png_ptr,
+ (png_ptr->rowbytes + 1));
+ png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;
+ }
+ }
+
+ if ((png_ptr->do_filter & PNG_FILTER_AVG) && png_ptr->avg_row == NULL)
+ {
+ if (png_ptr->prev_row == NULL)
+ {
+ png_warning(png_ptr, "Can't add Average filter after starting");
+ png_ptr->do_filter &= ~PNG_FILTER_AVG;
+ }
+ else
+ {
+ png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,
+ (png_ptr->rowbytes + 1));
+ png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;
+ }
+ }
+
+ if ((png_ptr->do_filter & PNG_FILTER_PAETH) &&
+ png_ptr->paeth_row == NULL)
+ {
+ if (png_ptr->prev_row == NULL)
+ {
+ png_warning(png_ptr, "Can't add Paeth filter after starting");
+ png_ptr->do_filter &= (png_byte)(~PNG_FILTER_PAETH);
+ }
+ else
+ {
+ png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr,
+ (png_ptr->rowbytes + 1));
+ png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;
+ }
+ }
+
+ if (png_ptr->do_filter == PNG_NO_FILTERS)
+#endif /* PNG_NO_WRITE_FILTER */
+ png_ptr->do_filter = PNG_FILTER_NONE;
+ }
+ }
+ else
+ png_error(png_ptr, "Unknown custom filter method");
+}
+
+/* This allows us to influence the way in which libpng chooses the "best"
+ * filter for the current scanline. While the "minimum-sum-of-absolute-
+ * differences metric is relatively fast and effective, there is some
+ * question as to whether it can be improved upon by trying to keep the
+ * filtered data going to zlib more consistent, hopefully resulting in
+ * better compression.
+ */
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) /* GRR 970116 */
+void PNGAPI
+png_set_filter_heuristics(png_structp png_ptr, int heuristic_method,
+ int num_weights, png_doublep filter_weights,
+ png_doublep filter_costs)
+{
+ int i;
+
+ png_debug(1, "in png_set_filter_heuristics\n");
+ if (png_ptr == NULL)
+ return;
+ if (heuristic_method >= PNG_FILTER_HEURISTIC_LAST)
+ {
+ png_warning(png_ptr, "Unknown filter heuristic method");
+ return;
+ }
+
+ if (heuristic_method == PNG_FILTER_HEURISTIC_DEFAULT)
+ {
+ heuristic_method = PNG_FILTER_HEURISTIC_UNWEIGHTED;
+ }
+
+ if (num_weights < 0 || filter_weights == NULL ||
+ heuristic_method == PNG_FILTER_HEURISTIC_UNWEIGHTED)
+ {
+ num_weights = 0;
+ }
+
+ png_ptr->num_prev_filters = (png_byte)num_weights;
+ png_ptr->heuristic_method = (png_byte)heuristic_method;
+
+ if (num_weights > 0)
+ {
+ if (png_ptr->prev_filters == NULL)
+ {
+ png_ptr->prev_filters = (png_bytep)png_malloc(png_ptr,
+ (png_uint_32)(png_sizeof(png_byte) * num_weights));
+
+ /* To make sure that the weighting starts out fairly */
+ for (i = 0; i < num_weights; i++)
+ {
+ png_ptr->prev_filters[i] = 255;
+ }
+ }
+
+ if (png_ptr->filter_weights == NULL)
+ {
+ png_ptr->filter_weights = (png_uint_16p)png_malloc(png_ptr,
+ (png_uint_32)(png_sizeof(png_uint_16) * num_weights));
+
+ png_ptr->inv_filter_weights = (png_uint_16p)png_malloc(png_ptr,
+ (png_uint_32)(png_sizeof(png_uint_16) * num_weights));
+ for (i = 0; i < num_weights; i++)
+ {
+ png_ptr->inv_filter_weights[i] =
+ png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR;
+ }
+ }
+
+ for (i = 0; i < num_weights; i++)
+ {
+ if (filter_weights[i] < 0.0)
+ {
+ png_ptr->inv_filter_weights[i] =
+ png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR;
+ }
+ else
+ {
+ png_ptr->inv_filter_weights[i] =
+ (png_uint_16)((double)PNG_WEIGHT_FACTOR*filter_weights[i]+0.5);
+ png_ptr->filter_weights[i] =
+ (png_uint_16)((double)PNG_WEIGHT_FACTOR/filter_weights[i]+0.5);
+ }
+ }
+ }
+
+ /* If, in the future, there are other filter methods, this would
+ * need to be based on png_ptr->filter.
+ */
+ if (png_ptr->filter_costs == NULL)
+ {
+ png_ptr->filter_costs = (png_uint_16p)png_malloc(png_ptr,
+ (png_uint_32)(png_sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST));
+
+ png_ptr->inv_filter_costs = (png_uint_16p)png_malloc(png_ptr,
+ (png_uint_32)(png_sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST));
+
+ for (i = 0; i < PNG_FILTER_VALUE_LAST; i++)
+ {
+ png_ptr->inv_filter_costs[i] =
+ png_ptr->filter_costs[i] = PNG_COST_FACTOR;
+ }
+ }
+
+ /* Here is where we set the relative costs of the different filters. We
+ * should take the desired compression level into account when setting
+ * the costs, so that Paeth, for instance, has a high relative cost at low
+ * compression levels, while it has a lower relative cost at higher
+ * compression settings. The filter types are in order of increasing
+ * relative cost, so it would be possible to do this with an algorithm.
+ */
+ for (i = 0; i < PNG_FILTER_VALUE_LAST; i++)
+ {
+ if (filter_costs == NULL || filter_costs[i] < 0.0)
+ {
+ png_ptr->inv_filter_costs[i] =
+ png_ptr->filter_costs[i] = PNG_COST_FACTOR;
+ }
+ else if (filter_costs[i] >= 1.0)
+ {
+ png_ptr->inv_filter_costs[i] =
+ (png_uint_16)((double)PNG_COST_FACTOR / filter_costs[i] + 0.5);
+ png_ptr->filter_costs[i] =
+ (png_uint_16)((double)PNG_COST_FACTOR * filter_costs[i] + 0.5);
+ }
+ }
+}
+#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */
+
+void PNGAPI
+png_set_compression_level(png_structp png_ptr, int level)
+{
+ png_debug(1, "in png_set_compression_level\n");
+ if (png_ptr == NULL)
+ return;
+ png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_LEVEL;
+ png_ptr->zlib_level = level;
+}
+
+void PNGAPI
+png_set_compression_mem_level(png_structp png_ptr, int mem_level)
+{
+ png_debug(1, "in png_set_compression_mem_level\n");
+ if (png_ptr == NULL)
+ return;
+ png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL;
+ png_ptr->zlib_mem_level = mem_level;
+}
+
+void PNGAPI
+png_set_compression_strategy(png_structp png_ptr, int strategy)
+{
+ png_debug(1, "in png_set_compression_strategy\n");
+ if (png_ptr == NULL)
+ return;
+ png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_STRATEGY;
+ png_ptr->zlib_strategy = strategy;
+}
+
+void PNGAPI
+png_set_compression_window_bits(png_structp png_ptr, int window_bits)
+{
+ if (png_ptr == NULL)
+ return;
+ if (window_bits > 15)
+ png_warning(png_ptr, "Only compression windows <= 32k supported by PNG");
+ else if (window_bits < 8)
+ png_warning(png_ptr, "Only compression windows >= 256 supported by PNG");
+#ifndef WBITS_8_OK
+ /* avoid libpng bug with 256-byte windows */
+ if (window_bits == 8)
+ {
+ png_warning(png_ptr, "Compression window is being reset to 512");
+ window_bits=9;
+ }
+#endif
+ png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS;
+ png_ptr->zlib_window_bits = window_bits;
+}
+
+void PNGAPI
+png_set_compression_method(png_structp png_ptr, int method)
+{
+ png_debug(1, "in png_set_compression_method\n");
+ if (png_ptr == NULL)
+ return;
+ if (method != 8)
+ png_warning(png_ptr, "Only compression method 8 is supported by PNG");
+ png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_METHOD;
+ png_ptr->zlib_method = method;
+}
+
+void PNGAPI
+png_set_write_status_fn(png_structp png_ptr, png_write_status_ptr write_row_fn)
+{
+ if (png_ptr == NULL)
+ return;
+ png_ptr->write_row_fn = write_row_fn;
+}
+
+#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+void PNGAPI
+png_set_write_user_transform_fn(png_structp png_ptr, png_user_transform_ptr
+ write_user_transform_fn)
+{
+ png_debug(1, "in png_set_write_user_transform_fn\n");
+ if (png_ptr == NULL)
+ return;
+ png_ptr->transformations |= PNG_USER_TRANSFORM;
+ png_ptr->write_user_transform_fn = write_user_transform_fn;
+}
+#endif
+
+
+#if defined(PNG_INFO_IMAGE_SUPPORTED)
+void PNGAPI
+png_write_png(png_structp png_ptr, png_infop info_ptr,
+ int transforms, voidp params)
+{
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
+ /* invert the alpha channel from opacity to transparency */
+ if (transforms & PNG_TRANSFORM_INVERT_ALPHA)
+ png_set_invert_alpha(png_ptr);
+#endif
+
+ /* Write the file header information. */
+ png_write_info(png_ptr, info_ptr);
+
+ /* ------ these transformations don't touch the info structure ------- */
+
+#if defined(PNG_WRITE_INVERT_SUPPORTED)
+ /* invert monochrome pixels */
+ if (transforms & PNG_TRANSFORM_INVERT_MONO)
+ png_set_invert_mono(png_ptr);
+#endif
+
+#if defined(PNG_WRITE_SHIFT_SUPPORTED)
+ /* Shift the pixels up to a legal bit depth and fill in
+ * as appropriate to correctly scale the image.
+ */
+ if ((transforms & PNG_TRANSFORM_SHIFT)
+ && (info_ptr->valid & PNG_INFO_sBIT))
+ png_set_shift(png_ptr, &info_ptr->sig_bit);
+#endif
+
+#if defined(PNG_WRITE_PACK_SUPPORTED)
+ /* pack pixels into bytes */
+ if (transforms & PNG_TRANSFORM_PACKING)
+ png_set_packing(png_ptr);
+#endif
+
+#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
+ /* swap location of alpha bytes from ARGB to RGBA */
+ if (transforms & PNG_TRANSFORM_SWAP_ALPHA)
+ png_set_swap_alpha(png_ptr);
+#endif
+
+#if defined(PNG_WRITE_FILLER_SUPPORTED)
+ /* Get rid of filler (OR ALPHA) bytes, pack XRGB/RGBX/ARGB/RGBA into
+ * RGB (4 channels -> 3 channels). The second parameter is not used.
+ */
+ if (transforms & PNG_TRANSFORM_STRIP_FILLER)
+ png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);
+#endif
+
+#if defined(PNG_WRITE_BGR_SUPPORTED)
+ /* flip BGR pixels to RGB */
+ if (transforms & PNG_TRANSFORM_BGR)
+ png_set_bgr(png_ptr);
+#endif
+
+#if defined(PNG_WRITE_SWAP_SUPPORTED)
+ /* swap bytes of 16-bit files to most significant byte first */
+ if (transforms & PNG_TRANSFORM_SWAP_ENDIAN)
+ png_set_swap(png_ptr);
+#endif
+
+#if defined(PNG_WRITE_PACKSWAP_SUPPORTED)
+ /* swap bits of 1, 2, 4 bit packed pixel formats */
+ if (transforms & PNG_TRANSFORM_PACKSWAP)
+ png_set_packswap(png_ptr);
+#endif
+
+ /* ----------------------- end of transformations ------------------- */
+
+ /* write the bits */
+ if (info_ptr->valid & PNG_INFO_IDAT)
+ png_write_image(png_ptr, info_ptr->row_pointers);
+
+ /* It is REQUIRED to call this to finish writing the rest of the file */
+ png_write_end(png_ptr, info_ptr);
+
+ transforms = transforms; /* quiet compiler warnings */
+ params = params;
+}
+#endif
+#endif /* PNG_WRITE_SUPPORTED */
--- /dev/null
+
+/* pngwtran.c - transforms the data in a row for PNG writers
+ *
+ * Last changed in libpng 1.2.9 April 14, 2006
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1998-2006 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ */
+
+#define PNG_INTERNAL
+#include "png.h"
+#ifdef PNG_WRITE_SUPPORTED
+
+/* Transform the data according to the user's wishes. The order of
+ * transformations is significant.
+ */
+void /* PRIVATE */
+png_do_write_transformations(png_structp png_ptr)
+{
+ png_debug(1, "in png_do_write_transformations\n");
+
+ if (png_ptr == NULL)
+ return;
+
+#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+ if (png_ptr->transformations & PNG_USER_TRANSFORM)
+ if (png_ptr->write_user_transform_fn != NULL)
+ (*(png_ptr->write_user_transform_fn)) /* user write transform function */
+ (png_ptr, /* png_ptr */
+ &(png_ptr->row_info), /* row_info: */
+ /* png_uint_32 width; width of row */
+ /* png_uint_32 rowbytes; number of bytes in row */
+ /* png_byte color_type; color type of pixels */
+ /* png_byte bit_depth; bit depth of samples */
+ /* png_byte channels; number of channels (1-4) */
+ /* png_byte pixel_depth; bits per pixel (depth*channels) */
+ png_ptr->row_buf + 1); /* start of pixel data for row */
+#endif
+#if defined(PNG_WRITE_FILLER_SUPPORTED)
+ if (png_ptr->transformations & PNG_FILLER)
+ png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,
+ png_ptr->flags);
+#endif
+#if defined(PNG_WRITE_PACKSWAP_SUPPORTED)
+ if (png_ptr->transformations & PNG_PACKSWAP)
+ png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+#if defined(PNG_WRITE_PACK_SUPPORTED)
+ if (png_ptr->transformations & PNG_PACK)
+ png_do_pack(&(png_ptr->row_info), png_ptr->row_buf + 1,
+ (png_uint_32)png_ptr->bit_depth);
+#endif
+#if defined(PNG_WRITE_SWAP_SUPPORTED)
+ if (png_ptr->transformations & PNG_SWAP_BYTES)
+ png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+#if defined(PNG_WRITE_SHIFT_SUPPORTED)
+ if (png_ptr->transformations & PNG_SHIFT)
+ png_do_shift(&(png_ptr->row_info), png_ptr->row_buf + 1,
+ &(png_ptr->shift));
+#endif
+#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
+ if (png_ptr->transformations & PNG_SWAP_ALPHA)
+ png_do_write_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
+ if (png_ptr->transformations & PNG_INVERT_ALPHA)
+ png_do_write_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+#if defined(PNG_WRITE_BGR_SUPPORTED)
+ if (png_ptr->transformations & PNG_BGR)
+ png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+#if defined(PNG_WRITE_INVERT_SUPPORTED)
+ if (png_ptr->transformations & PNG_INVERT_MONO)
+ png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+}
+
+#if defined(PNG_WRITE_PACK_SUPPORTED)
+/* Pack pixels into bytes. Pass the true bit depth in bit_depth. The
+ * row_info bit depth should be 8 (one pixel per byte). The channels
+ * should be 1 (this only happens on grayscale and paletted images).
+ */
+void /* PRIVATE */
+png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
+{
+ png_debug(1, "in png_do_pack\n");
+ if (row_info->bit_depth == 8 &&
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+ row != NULL && row_info != NULL &&
+#endif
+ row_info->channels == 1)
+ {
+ switch ((int)bit_depth)
+ {
+ case 1:
+ {
+ png_bytep sp, dp;
+ int mask, v;
+ png_uint_32 i;
+ png_uint_32 row_width = row_info->width;
+
+ sp = row;
+ dp = row;
+ mask = 0x80;
+ v = 0;
+
+ for (i = 0; i < row_width; i++)
+ {
+ if (*sp != 0)
+ v |= mask;
+ sp++;
+ if (mask > 1)
+ mask >>= 1;
+ else
+ {
+ mask = 0x80;
+ *dp = (png_byte)v;
+ dp++;
+ v = 0;
+ }
+ }
+ if (mask != 0x80)
+ *dp = (png_byte)v;
+ break;
+ }
+ case 2:
+ {
+ png_bytep sp, dp;
+ int shift, v;
+ png_uint_32 i;
+ png_uint_32 row_width = row_info->width;
+
+ sp = row;
+ dp = row;
+ shift = 6;
+ v = 0;
+ for (i = 0; i < row_width; i++)
+ {
+ png_byte value;
+
+ value = (png_byte)(*sp & 0x03);
+ v |= (value << shift);
+ if (shift == 0)
+ {
+ shift = 6;
+ *dp = (png_byte)v;
+ dp++;
+ v = 0;
+ }
+ else
+ shift -= 2;
+ sp++;
+ }
+ if (shift != 6)
+ *dp = (png_byte)v;
+ break;
+ }
+ case 4:
+ {
+ png_bytep sp, dp;
+ int shift, v;
+ png_uint_32 i;
+ png_uint_32 row_width = row_info->width;
+
+ sp = row;
+ dp = row;
+ shift = 4;
+ v = 0;
+ for (i = 0; i < row_width; i++)
+ {
+ png_byte value;
+
+ value = (png_byte)(*sp & 0x0f);
+ v |= (value << shift);
+
+ if (shift == 0)
+ {
+ shift = 4;
+ *dp = (png_byte)v;
+ dp++;
+ v = 0;
+ }
+ else
+ shift -= 4;
+
+ sp++;
+ }
+ if (shift != 4)
+ *dp = (png_byte)v;
+ break;
+ }
+ }
+ row_info->bit_depth = (png_byte)bit_depth;
+ row_info->pixel_depth = (png_byte)(bit_depth * row_info->channels);
+ row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,
+ row_info->width);
+ }
+}
+#endif
+
+#if defined(PNG_WRITE_SHIFT_SUPPORTED)
+/* Shift pixel values to take advantage of whole range. Pass the
+ * true number of bits in bit_depth. The row should be packed
+ * according to row_info->bit_depth. Thus, if you had a row of
+ * bit depth 4, but the pixels only had values from 0 to 7, you
+ * would pass 3 as bit_depth, and this routine would translate the
+ * data to 0 to 15.
+ */
+void /* PRIVATE */
+png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)
+{
+ png_debug(1, "in png_do_shift\n");
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+ if (row != NULL && row_info != NULL &&
+#else
+ if (
+#endif
+ row_info->color_type != PNG_COLOR_TYPE_PALETTE)
+ {
+ int shift_start[4], shift_dec[4];
+ int channels = 0;
+
+ if (row_info->color_type & PNG_COLOR_MASK_COLOR)
+ {
+ shift_start[channels] = row_info->bit_depth - bit_depth->red;
+ shift_dec[channels] = bit_depth->red;
+ channels++;
+ shift_start[channels] = row_info->bit_depth - bit_depth->green;
+ shift_dec[channels] = bit_depth->green;
+ channels++;
+ shift_start[channels] = row_info->bit_depth - bit_depth->blue;
+ shift_dec[channels] = bit_depth->blue;
+ channels++;
+ }
+ else
+ {
+ shift_start[channels] = row_info->bit_depth - bit_depth->gray;
+ shift_dec[channels] = bit_depth->gray;
+ channels++;
+ }
+ if (row_info->color_type & PNG_COLOR_MASK_ALPHA)
+ {
+ shift_start[channels] = row_info->bit_depth - bit_depth->alpha;
+ shift_dec[channels] = bit_depth->alpha;
+ channels++;
+ }
+
+ /* with low row depths, could only be grayscale, so one channel */
+ if (row_info->bit_depth < 8)
+ {
+ png_bytep bp = row;
+ png_uint_32 i;
+ png_byte mask;
+ png_uint_32 row_bytes = row_info->rowbytes;
+
+ if (bit_depth->gray == 1 && row_info->bit_depth == 2)
+ mask = 0x55;
+ else if (row_info->bit_depth == 4 && bit_depth->gray == 3)
+ mask = 0x11;
+ else
+ mask = 0xff;
+
+ for (i = 0; i < row_bytes; i++, bp++)
+ {
+ png_uint_16 v;
+ int j;
+
+ v = *bp;
+ *bp = 0;
+ for (j = shift_start[0]; j > -shift_dec[0]; j -= shift_dec[0])
+ {
+ if (j > 0)
+ *bp |= (png_byte)((v << j) & 0xff);
+ else
+ *bp |= (png_byte)((v >> (-j)) & mask);
+ }
+ }
+ }
+ else if (row_info->bit_depth == 8)
+ {
+ png_bytep bp = row;
+ png_uint_32 i;
+ png_uint_32 istop = channels * row_info->width;
+
+ for (i = 0; i < istop; i++, bp++)
+ {
+
+ png_uint_16 v;
+ int j;
+ int c = (int)(i%channels);
+
+ v = *bp;
+ *bp = 0;
+ for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])
+ {
+ if (j > 0)
+ *bp |= (png_byte)((v << j) & 0xff);
+ else
+ *bp |= (png_byte)((v >> (-j)) & 0xff);
+ }
+ }
+ }
+ else
+ {
+ png_bytep bp;
+ png_uint_32 i;
+ png_uint_32 istop = channels * row_info->width;
+
+ for (bp = row, i = 0; i < istop; i++)
+ {
+ int c = (int)(i%channels);
+ png_uint_16 value, v;
+ int j;
+
+ v = (png_uint_16)(((png_uint_16)(*bp) << 8) + *(bp + 1));
+ value = 0;
+ for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])
+ {
+ if (j > 0)
+ value |= (png_uint_16)((v << j) & (png_uint_16)0xffff);
+ else
+ value |= (png_uint_16)((v >> (-j)) & (png_uint_16)0xffff);
+ }
+ *bp++ = (png_byte)(value >> 8);
+ *bp++ = (png_byte)(value & 0xff);
+ }
+ }
+ }
+}
+#endif
+
+#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
+void /* PRIVATE */
+png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)
+{
+ png_debug(1, "in png_do_write_swap_alpha\n");
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+ if (row != NULL && row_info != NULL)
+#endif
+ {
+ if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+ {
+ /* This converts from ARGB to RGBA */
+ if (row_info->bit_depth == 8)
+ {
+ png_bytep sp, dp;
+ png_uint_32 i;
+ png_uint_32 row_width = row_info->width;
+ for (i = 0, sp = dp = row; i < row_width; i++)
+ {
+ png_byte save = *(sp++);
+ *(dp++) = *(sp++);
+ *(dp++) = *(sp++);
+ *(dp++) = *(sp++);
+ *(dp++) = save;
+ }
+ }
+ /* This converts from AARRGGBB to RRGGBBAA */
+ else
+ {
+ png_bytep sp, dp;
+ png_uint_32 i;
+ png_uint_32 row_width = row_info->width;
+
+ for (i = 0, sp = dp = row; i < row_width; i++)
+ {
+ png_byte save[2];
+ save[0] = *(sp++);
+ save[1] = *(sp++);
+ *(dp++) = *(sp++);
+ *(dp++) = *(sp++);
+ *(dp++) = *(sp++);
+ *(dp++) = *(sp++);
+ *(dp++) = *(sp++);
+ *(dp++) = *(sp++);
+ *(dp++) = save[0];
+ *(dp++) = save[1];
+ }
+ }
+ }
+ else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+ {
+ /* This converts from AG to GA */
+ if (row_info->bit_depth == 8)
+ {
+ png_bytep sp, dp;
+ png_uint_32 i;
+ png_uint_32 row_width = row_info->width;
+
+ for (i = 0, sp = dp = row; i < row_width; i++)
+ {
+ png_byte save = *(sp++);
+ *(dp++) = *(sp++);
+ *(dp++) = save;
+ }
+ }
+ /* This converts from AAGG to GGAA */
+ else
+ {
+ png_bytep sp, dp;
+ png_uint_32 i;
+ png_uint_32 row_width = row_info->width;
+
+ for (i = 0, sp = dp = row; i < row_width; i++)
+ {
+ png_byte save[2];
+ save[0] = *(sp++);
+ save[1] = *(sp++);
+ *(dp++) = *(sp++);
+ *(dp++) = *(sp++);
+ *(dp++) = save[0];
+ *(dp++) = save[1];
+ }
+ }
+ }
+ }
+}
+#endif
+
+#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
+void /* PRIVATE */
+png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
+{
+ png_debug(1, "in png_do_write_invert_alpha\n");
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+ if (row != NULL && row_info != NULL)
+#endif
+ {
+ if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+ {
+ /* This inverts the alpha channel in RGBA */
+ if (row_info->bit_depth == 8)
+ {
+ png_bytep sp, dp;
+ png_uint_32 i;
+ png_uint_32 row_width = row_info->width;
+ for (i = 0, sp = dp = row; i < row_width; i++)
+ {
+ /* does nothing
+ *(dp++) = *(sp++);
+ *(dp++) = *(sp++);
+ *(dp++) = *(sp++);
+ */
+ sp+=3; dp = sp;
+ *(dp++) = (png_byte)(255 - *(sp++));
+ }
+ }
+ /* This inverts the alpha channel in RRGGBBAA */
+ else
+ {
+ png_bytep sp, dp;
+ png_uint_32 i;
+ png_uint_32 row_width = row_info->width;
+
+ for (i = 0, sp = dp = row; i < row_width; i++)
+ {
+ /* does nothing
+ *(dp++) = *(sp++);
+ *(dp++) = *(sp++);
+ *(dp++) = *(sp++);
+ *(dp++) = *(sp++);
+ *(dp++) = *(sp++);
+ *(dp++) = *(sp++);
+ */
+ sp+=6; dp = sp;
+ *(dp++) = (png_byte)(255 - *(sp++));
+ *(dp++) = (png_byte)(255 - *(sp++));
+ }
+ }
+ }
+ else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+ {
+ /* This inverts the alpha channel in GA */
+ if (row_info->bit_depth == 8)
+ {
+ png_bytep sp, dp;
+ png_uint_32 i;
+ png_uint_32 row_width = row_info->width;
+
+ for (i = 0, sp = dp = row; i < row_width; i++)
+ {
+ *(dp++) = *(sp++);
+ *(dp++) = (png_byte)(255 - *(sp++));
+ }
+ }
+ /* This inverts the alpha channel in GGAA */
+ else
+ {
+ png_bytep sp, dp;
+ png_uint_32 i;
+ png_uint_32 row_width = row_info->width;
+
+ for (i = 0, sp = dp = row; i < row_width; i++)
+ {
+ /* does nothing
+ *(dp++) = *(sp++);
+ *(dp++) = *(sp++);
+ */
+ sp+=2; dp = sp;
+ *(dp++) = (png_byte)(255 - *(sp++));
+ *(dp++) = (png_byte)(255 - *(sp++));
+ }
+ }
+ }
+ }
+}
+#endif
+
+#if defined(PNG_MNG_FEATURES_SUPPORTED)
+/* undoes intrapixel differencing */
+void /* PRIVATE */
+png_do_write_intrapixel(png_row_infop row_info, png_bytep row)
+{
+ png_debug(1, "in png_do_write_intrapixel\n");
+ if (
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+ row != NULL && row_info != NULL &&
+#endif
+ (row_info->color_type & PNG_COLOR_MASK_COLOR))
+ {
+ int bytes_per_pixel;
+ png_uint_32 row_width = row_info->width;
+ if (row_info->bit_depth == 8)
+ {
+ png_bytep rp;
+ png_uint_32 i;
+
+ if (row_info->color_type == PNG_COLOR_TYPE_RGB)
+ bytes_per_pixel = 3;
+ else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+ bytes_per_pixel = 4;
+ else
+ return;
+
+ for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
+ {
+ *(rp) = (png_byte)((*rp - *(rp+1))&0xff);
+ *(rp+2) = (png_byte)((*(rp+2) - *(rp+1))&0xff);
+ }
+ }
+ else if (row_info->bit_depth == 16)
+ {
+ png_bytep rp;
+ png_uint_32 i;
+
+ if (row_info->color_type == PNG_COLOR_TYPE_RGB)
+ bytes_per_pixel = 6;
+ else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+ bytes_per_pixel = 8;
+ else
+ return;
+
+ for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
+ {
+ png_uint_32 s0 = (*(rp ) << 8) | *(rp+1);
+ png_uint_32 s1 = (*(rp+2) << 8) | *(rp+3);
+ png_uint_32 s2 = (*(rp+4) << 8) | *(rp+5);
+ png_uint_32 red = (png_uint_32)((s0 - s1) & 0xffffL);
+ png_uint_32 blue = (png_uint_32)((s2 - s1) & 0xffffL);
+ *(rp ) = (png_byte)((red >> 8) & 0xff);
+ *(rp+1) = (png_byte)(red & 0xff);
+ *(rp+4) = (png_byte)((blue >> 8) & 0xff);
+ *(rp+5) = (png_byte)(blue & 0xff);
+ }
+ }
+ }
+}
+#endif /* PNG_MNG_FEATURES_SUPPORTED */
+#endif /* PNG_WRITE_SUPPORTED */
--- /dev/null
+
+/* pngwutil.c - utilities to write a PNG file
+ *
+ * Last changed in libpng 1.2.30 [August 15, 2008]
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ */
+
+#define PNG_INTERNAL
+#include "png.h"
+#ifdef PNG_WRITE_SUPPORTED
+
+/* Place a 32-bit number into a buffer in PNG byte order. We work
+ * with unsigned numbers for convenience, although one supported
+ * ancillary chunk uses signed (two's complement) numbers.
+ */
+void PNGAPI
+png_save_uint_32(png_bytep buf, png_uint_32 i)
+{
+ buf[0] = (png_byte)((i >> 24) & 0xff);
+ buf[1] = (png_byte)((i >> 16) & 0xff);
+ buf[2] = (png_byte)((i >> 8) & 0xff);
+ buf[3] = (png_byte)(i & 0xff);
+}
+
+/* The png_save_int_32 function assumes integers are stored in two's
+ * complement format. If this isn't the case, then this routine needs to
+ * be modified to write data in two's complement format.
+ */
+void PNGAPI
+png_save_int_32(png_bytep buf, png_int_32 i)
+{
+ buf[0] = (png_byte)((i >> 24) & 0xff);
+ buf[1] = (png_byte)((i >> 16) & 0xff);
+ buf[2] = (png_byte)((i >> 8) & 0xff);
+ buf[3] = (png_byte)(i & 0xff);
+}
+
+/* Place a 16-bit number into a buffer in PNG byte order.
+ * The parameter is declared unsigned int, not png_uint_16,
+ * just to avoid potential problems on pre-ANSI C compilers.
+ */
+void PNGAPI
+png_save_uint_16(png_bytep buf, unsigned int i)
+{
+ buf[0] = (png_byte)((i >> 8) & 0xff);
+ buf[1] = (png_byte)(i & 0xff);
+}
+
+/* Simple function to write the signature. If we have already written
+ * the magic bytes of the signature, or more likely, the PNG stream is
+ * being embedded into another stream and doesn't need its own signature,
+ * we should call png_set_sig_bytes() to tell libpng how many of the
+ * bytes have already been written.
+ */
+void /* PRIVATE */
+png_write_sig(png_structp png_ptr)
+{
+ png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
+
+ /* write the rest of the 8 byte signature */
+ png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes],
+ (png_size_t)(8 - png_ptr->sig_bytes));
+ if (png_ptr->sig_bytes < 3)
+ png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;
+}
+
+/* Write a PNG chunk all at once. The type is an array of ASCII characters
+ * representing the chunk name. The array must be at least 4 bytes in
+ * length, and does not need to be null terminated. To be safe, pass the
+ * pre-defined chunk names here, and if you need a new one, define it
+ * where the others are defined. The length is the length of the data.
+ * All the data must be present. If that is not possible, use the
+ * png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end()
+ * functions instead.
+ */
+void PNGAPI
+png_write_chunk(png_structp png_ptr, png_bytep chunk_name,
+ png_bytep data, png_size_t length)
+{
+ if (png_ptr == NULL) return;
+ png_write_chunk_start(png_ptr, chunk_name, (png_uint_32)length);
+ png_write_chunk_data(png_ptr, data, (png_size_t)length);
+ png_write_chunk_end(png_ptr);
+}
+
+/* Write the start of a PNG chunk. The type is the chunk type.
+ * The total_length is the sum of the lengths of all the data you will be
+ * passing in png_write_chunk_data().
+ */
+void PNGAPI
+png_write_chunk_start(png_structp png_ptr, png_bytep chunk_name,
+ png_uint_32 length)
+{
+ png_byte buf[8];
+
+ png_debug2(0, "Writing %s chunk, length = %lu\n", chunk_name,
+ (unsigned long)length);
+ if (png_ptr == NULL) return;
+
+ /* write the length and the chunk name */
+ png_save_uint_32(buf, length);
+ png_memcpy(buf + 4, chunk_name, 4);
+ png_write_data(png_ptr, buf, (png_size_t)8);
+ /* put the chunk name into png_ptr->chunk_name */
+ png_memcpy(png_ptr->chunk_name, chunk_name, 4);
+ /* reset the crc and run it over the chunk name */
+ png_reset_crc(png_ptr);
+ png_calculate_crc(png_ptr, chunk_name, (png_size_t)4);
+}
+
+/* Write the data of a PNG chunk started with png_write_chunk_start().
+ * Note that multiple calls to this function are allowed, and that the
+ * sum of the lengths from these calls *must* add up to the total_length
+ * given to png_write_chunk_start().
+ */
+void PNGAPI
+png_write_chunk_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+ /* write the data, and run the CRC over it */
+ if (png_ptr == NULL) return;
+ if (data != NULL && length > 0)
+ {
+ png_write_data(png_ptr, data, length);
+ /* update the CRC after writing the data,
+ * in case that the user I/O routine alters it.
+ */
+ png_calculate_crc(png_ptr, data, length);
+ }
+}
+
+/* Finish a chunk started with png_write_chunk_start(). */
+void PNGAPI
+png_write_chunk_end(png_structp png_ptr)
+{
+ png_byte buf[4];
+
+ if (png_ptr == NULL) return;
+
+ /* write the crc in a single operation */
+ png_save_uint_32(buf, png_ptr->crc);
+
+ png_write_data(png_ptr, buf, (png_size_t)4);
+}
+
+#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_iCCP_SUPPORTED)
+/*
+ * This pair of functions encapsulates the operation of (a) compressing a
+ * text string, and (b) issuing it later as a series of chunk data writes.
+ * The compression_state structure is shared context for these functions
+ * set up by the caller in order to make the whole mess thread-safe.
+ */
+
+typedef struct
+{
+ char *input; /* the uncompressed input data */
+ int input_len; /* its length */
+ int num_output_ptr; /* number of output pointers used */
+ int max_output_ptr; /* size of output_ptr */
+ png_charpp output_ptr; /* array of pointers to output */
+} compression_state;
+
+/* compress given text into storage in the png_ptr structure */
+static int /* PRIVATE */
+png_text_compress(png_structp png_ptr,
+ png_charp text, png_size_t text_len, int compression,
+ compression_state *comp)
+{
+ int ret;
+
+ comp->num_output_ptr = 0;
+ comp->max_output_ptr = 0;
+ comp->output_ptr = NULL;
+ comp->input = NULL;
+ comp->input_len = 0;
+
+ /* we may just want to pass the text right through */
+ if (compression == PNG_TEXT_COMPRESSION_NONE)
+ {
+ comp->input = text;
+ comp->input_len = text_len;
+ return((int)text_len);
+ }
+
+ if (compression >= PNG_TEXT_COMPRESSION_LAST)
+ {
+#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)
+ char msg[50];
+ png_snprintf(msg, 50, "Unknown compression type %d", compression);
+ png_warning(png_ptr, msg);
+#else
+ png_warning(png_ptr, "Unknown compression type");
+#endif
+ }
+
+ /* We can't write the chunk until we find out how much data we have,
+ * which means we need to run the compressor first and save the
+ * output. This shouldn't be a problem, as the vast majority of
+ * comments should be reasonable, but we will set up an array of
+ * malloc'd pointers to be sure.
+ *
+ * If we knew the application was well behaved, we could simplify this
+ * greatly by assuming we can always malloc an output buffer large
+ * enough to hold the compressed text ((1001 * text_len / 1000) + 12)
+ * and malloc this directly. The only time this would be a bad idea is
+ * if we can't malloc more than 64K and we have 64K of random input
+ * data, or if the input string is incredibly large (although this
+ * wouldn't cause a failure, just a slowdown due to swapping).
+ */
+
+ /* set up the compression buffers */
+ png_ptr->zstream.avail_in = (uInt)text_len;
+ png_ptr->zstream.next_in = (Bytef *)text;
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+ png_ptr->zstream.next_out = (Bytef *)png_ptr->zbuf;
+
+ /* this is the same compression loop as in png_write_row() */
+ do
+ {
+ /* compress the data */
+ ret = deflate(&png_ptr->zstream, Z_NO_FLUSH);
+ if (ret != Z_OK)
+ {
+ /* error */
+ if (png_ptr->zstream.msg != NULL)
+ png_error(png_ptr, png_ptr->zstream.msg);
+ else
+ png_error(png_ptr, "zlib error");
+ }
+ /* check to see if we need more room */
+ if (!(png_ptr->zstream.avail_out))
+ {
+ /* make sure the output array has room */
+ if (comp->num_output_ptr >= comp->max_output_ptr)
+ {
+ int old_max;
+
+ old_max = comp->max_output_ptr;
+ comp->max_output_ptr = comp->num_output_ptr + 4;
+ if (comp->output_ptr != NULL)
+ {
+ png_charpp old_ptr;
+
+ old_ptr = comp->output_ptr;
+ comp->output_ptr = (png_charpp)png_malloc(png_ptr,
+ (png_uint_32)
+ (comp->max_output_ptr * png_sizeof(png_charpp)));
+ png_memcpy(comp->output_ptr, old_ptr, old_max
+ * png_sizeof(png_charp));
+ png_free(png_ptr, old_ptr);
+ }
+ else
+ comp->output_ptr = (png_charpp)png_malloc(png_ptr,
+ (png_uint_32)
+ (comp->max_output_ptr * png_sizeof(png_charp)));
+ }
+
+ /* save the data */
+ comp->output_ptr[comp->num_output_ptr] =
+ (png_charp)png_malloc(png_ptr,
+ (png_uint_32)png_ptr->zbuf_size);
+ png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf,
+ png_ptr->zbuf_size);
+ comp->num_output_ptr++;
+
+ /* and reset the buffer */
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+ png_ptr->zstream.next_out = png_ptr->zbuf;
+ }
+ /* continue until we don't have any more to compress */
+ } while (png_ptr->zstream.avail_in);
+
+ /* finish the compression */
+ do
+ {
+ /* tell zlib we are finished */
+ ret = deflate(&png_ptr->zstream, Z_FINISH);
+
+ if (ret == Z_OK)
+ {
+ /* check to see if we need more room */
+ if (!(png_ptr->zstream.avail_out))
+ {
+ /* check to make sure our output array has room */
+ if (comp->num_output_ptr >= comp->max_output_ptr)
+ {
+ int old_max;
+
+ old_max = comp->max_output_ptr;
+ comp->max_output_ptr = comp->num_output_ptr + 4;
+ if (comp->output_ptr != NULL)
+ {
+ png_charpp old_ptr;
+
+ old_ptr = comp->output_ptr;
+ /* This could be optimized to realloc() */
+ comp->output_ptr = (png_charpp)png_malloc(png_ptr,
+ (png_uint_32)(comp->max_output_ptr *
+ png_sizeof(png_charp)));
+ png_memcpy(comp->output_ptr, old_ptr,
+ old_max * png_sizeof(png_charp));
+ png_free(png_ptr, old_ptr);
+ }
+ else
+ comp->output_ptr = (png_charpp)png_malloc(png_ptr,
+ (png_uint_32)(comp->max_output_ptr *
+ png_sizeof(png_charp)));
+ }
+
+ /* save off the data */
+ comp->output_ptr[comp->num_output_ptr] =
+ (png_charp)png_malloc(png_ptr,
+ (png_uint_32)png_ptr->zbuf_size);
+ png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf,
+ png_ptr->zbuf_size);
+ comp->num_output_ptr++;
+
+ /* and reset the buffer pointers */
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+ png_ptr->zstream.next_out = png_ptr->zbuf;
+ }
+ }
+ else if (ret != Z_STREAM_END)
+ {
+ /* we got an error */
+ if (png_ptr->zstream.msg != NULL)
+ png_error(png_ptr, png_ptr->zstream.msg);
+ else
+ png_error(png_ptr, "zlib error");
+ }
+ } while (ret != Z_STREAM_END);
+
+ /* text length is number of buffers plus last buffer */
+ text_len = png_ptr->zbuf_size * comp->num_output_ptr;
+ if (png_ptr->zstream.avail_out < png_ptr->zbuf_size)
+ text_len += png_ptr->zbuf_size - (png_size_t)png_ptr->zstream.avail_out;
+
+ return((int)text_len);
+}
+
+/* ship the compressed text out via chunk writes */
+static void /* PRIVATE */
+png_write_compressed_data_out(png_structp png_ptr, compression_state *comp)
+{
+ int i;
+
+ /* handle the no-compression case */
+ if (comp->input)
+ {
+ png_write_chunk_data(png_ptr, (png_bytep)comp->input,
+ (png_size_t)comp->input_len);
+ return;
+ }
+
+ /* write saved output buffers, if any */
+ for (i = 0; i < comp->num_output_ptr; i++)
+ {
+ png_write_chunk_data(png_ptr, (png_bytep)comp->output_ptr[i],
+ (png_size_t)png_ptr->zbuf_size);
+ png_free(png_ptr, comp->output_ptr[i]);
+ comp->output_ptr[i]=NULL;
+ }
+ if (comp->max_output_ptr != 0)
+ png_free(png_ptr, comp->output_ptr);
+ comp->output_ptr=NULL;
+ /* write anything left in zbuf */
+ if (png_ptr->zstream.avail_out < (png_uint_32)png_ptr->zbuf_size)
+ png_write_chunk_data(png_ptr, png_ptr->zbuf,
+ (png_size_t)(png_ptr->zbuf_size - png_ptr->zstream.avail_out));
+
+ /* reset zlib for another zTXt/iTXt or image data */
+ deflateReset(&png_ptr->zstream);
+ png_ptr->zstream.data_type = Z_BINARY;
+}
+#endif
+
+/* Write the IHDR chunk, and update the png_struct with the necessary
+ * information. Note that the rest of this code depends upon this
+ * information being correct.
+ */
+void /* PRIVATE */
+png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,
+ int bit_depth, int color_type, int compression_type, int filter_type,
+ int interlace_type)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_IHDR;
+#endif
+ int ret;
+
+ png_byte buf[13]; /* buffer to store the IHDR info */
+
+ png_debug(1, "in png_write_IHDR\n");
+ /* Check that we have valid input data from the application info */
+ switch (color_type)
+ {
+ case PNG_COLOR_TYPE_GRAY:
+ switch (bit_depth)
+ {
+ case 1:
+ case 2:
+ case 4:
+ case 8:
+ case 16: png_ptr->channels = 1; break;
+ default: png_error(png_ptr, "Invalid bit depth for grayscale image");
+ }
+ break;
+ case PNG_COLOR_TYPE_RGB:
+ if (bit_depth != 8 && bit_depth != 16)
+ png_error(png_ptr, "Invalid bit depth for RGB image");
+ png_ptr->channels = 3;
+ break;
+ case PNG_COLOR_TYPE_PALETTE:
+ switch (bit_depth)
+ {
+ case 1:
+ case 2:
+ case 4:
+ case 8: png_ptr->channels = 1; break;
+ default: png_error(png_ptr, "Invalid bit depth for paletted image");
+ }
+ break;
+ case PNG_COLOR_TYPE_GRAY_ALPHA:
+ if (bit_depth != 8 && bit_depth != 16)
+ png_error(png_ptr, "Invalid bit depth for grayscale+alpha image");
+ png_ptr->channels = 2;
+ break;
+ case PNG_COLOR_TYPE_RGB_ALPHA:
+ if (bit_depth != 8 && bit_depth != 16)
+ png_error(png_ptr, "Invalid bit depth for RGBA image");
+ png_ptr->channels = 4;
+ break;
+ default:
+ png_error(png_ptr, "Invalid image color type specified");
+ }
+
+ if (compression_type != PNG_COMPRESSION_TYPE_BASE)
+ {
+ png_warning(png_ptr, "Invalid compression type specified");
+ compression_type = PNG_COMPRESSION_TYPE_BASE;
+ }
+
+ /* Write filter_method 64 (intrapixel differencing) only if
+ * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
+ * 2. Libpng did not write a PNG signature (this filter_method is only
+ * used in PNG datastreams that are embedded in MNG datastreams) and
+ * 3. The application called png_permit_mng_features with a mask that
+ * included PNG_FLAG_MNG_FILTER_64 and
+ * 4. The filter_method is 64 and
+ * 5. The color_type is RGB or RGBA
+ */
+ if (
+#if defined(PNG_MNG_FEATURES_SUPPORTED)
+ !((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
+ ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) &&
+ (color_type == PNG_COLOR_TYPE_RGB ||
+ color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&
+ (filter_type == PNG_INTRAPIXEL_DIFFERENCING)) &&
+#endif
+ filter_type != PNG_FILTER_TYPE_BASE)
+ {
+ png_warning(png_ptr, "Invalid filter type specified");
+ filter_type = PNG_FILTER_TYPE_BASE;
+ }
+
+#ifdef PNG_WRITE_INTERLACING_SUPPORTED
+ if (interlace_type != PNG_INTERLACE_NONE &&
+ interlace_type != PNG_INTERLACE_ADAM7)
+ {
+ png_warning(png_ptr, "Invalid interlace type specified");
+ interlace_type = PNG_INTERLACE_ADAM7;
+ }
+#else
+ interlace_type=PNG_INTERLACE_NONE;
+#endif
+
+ /* save off the relevent information */
+ png_ptr->bit_depth = (png_byte)bit_depth;
+ png_ptr->color_type = (png_byte)color_type;
+ png_ptr->interlaced = (png_byte)interlace_type;
+#if defined(PNG_MNG_FEATURES_SUPPORTED)
+ png_ptr->filter_type = (png_byte)filter_type;
+#endif
+ png_ptr->compression_type = (png_byte)compression_type;
+ png_ptr->width = width;
+ png_ptr->height = height;
+
+ png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels);
+ png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, width);
+ /* set the usr info, so any transformations can modify it */
+ png_ptr->usr_width = png_ptr->width;
+ png_ptr->usr_bit_depth = png_ptr->bit_depth;
+ png_ptr->usr_channels = png_ptr->channels;
+
+ /* pack the header information into the buffer */
+ png_save_uint_32(buf, width);
+ png_save_uint_32(buf + 4, height);
+ buf[8] = (png_byte)bit_depth;
+ buf[9] = (png_byte)color_type;
+ buf[10] = (png_byte)compression_type;
+ buf[11] = (png_byte)filter_type;
+ buf[12] = (png_byte)interlace_type;
+
+ /* write the chunk */
+ png_write_chunk(png_ptr, (png_bytep)png_IHDR, buf, (png_size_t)13);
+
+ /* initialize zlib with PNG info */
+ png_ptr->zstream.zalloc = png_zalloc;
+ png_ptr->zstream.zfree = png_zfree;
+ png_ptr->zstream.opaque = (voidpf)png_ptr;
+ if (!(png_ptr->do_filter))
+ {
+ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE ||
+ png_ptr->bit_depth < 8)
+ png_ptr->do_filter = PNG_FILTER_NONE;
+ else
+ png_ptr->do_filter = PNG_ALL_FILTERS;
+ }
+ if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY))
+ {
+ if (png_ptr->do_filter != PNG_FILTER_NONE)
+ png_ptr->zlib_strategy = Z_FILTERED;
+ else
+ png_ptr->zlib_strategy = Z_DEFAULT_STRATEGY;
+ }
+ if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_LEVEL))
+ png_ptr->zlib_level = Z_DEFAULT_COMPRESSION;
+ if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL))
+ png_ptr->zlib_mem_level = 8;
+ if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS))
+ png_ptr->zlib_window_bits = 15;
+ if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_METHOD))
+ png_ptr->zlib_method = 8;
+ ret = deflateInit2(&png_ptr->zstream, png_ptr->zlib_level,
+ png_ptr->zlib_method, png_ptr->zlib_window_bits,
+ png_ptr->zlib_mem_level, png_ptr->zlib_strategy);
+ if (ret != Z_OK)
+ {
+ if (ret == Z_VERSION_ERROR) png_error(png_ptr,
+ "zlib failed to initialize compressor -- version error");
+ if (ret == Z_STREAM_ERROR) png_error(png_ptr,
+ "zlib failed to initialize compressor -- stream error");
+ if (ret == Z_MEM_ERROR) png_error(png_ptr,
+ "zlib failed to initialize compressor -- mem error");
+ png_error(png_ptr, "zlib failed to initialize compressor");
+ }
+ png_ptr->zstream.next_out = png_ptr->zbuf;
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+ /* libpng is not interested in zstream.data_type */
+ /* set it to a predefined value, to avoid its evaluation inside zlib */
+ png_ptr->zstream.data_type = Z_BINARY;
+
+ png_ptr->mode = PNG_HAVE_IHDR;
+}
+
+/* write the palette. We are careful not to trust png_color to be in the
+ * correct order for PNG, so people can redefine it to any convenient
+ * structure.
+ */
+void /* PRIVATE */
+png_write_PLTE(png_structp png_ptr, png_colorp palette, png_uint_32 num_pal)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_PLTE;
+#endif
+ png_uint_32 i;
+ png_colorp pal_ptr;
+ png_byte buf[3];
+
+ png_debug(1, "in png_write_PLTE\n");
+ if ((
+#if defined(PNG_MNG_FEATURES_SUPPORTED)
+ !(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) &&
+#endif
+ num_pal == 0) || num_pal > 256)
+ {
+ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+ {
+ png_error(png_ptr, "Invalid number of colors in palette");
+ }
+ else
+ {
+ png_warning(png_ptr, "Invalid number of colors in palette");
+ return;
+ }
+ }
+
+ if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR))
+ {
+ png_warning(png_ptr,
+ "Ignoring request to write a PLTE chunk in grayscale PNG");
+ return;
+ }
+
+ png_ptr->num_palette = (png_uint_16)num_pal;
+ png_debug1(3, "num_palette = %d\n", png_ptr->num_palette);
+
+ png_write_chunk_start(png_ptr, (png_bytep)png_PLTE,
+ (png_uint_32)(num_pal * 3));
+#ifndef PNG_NO_POINTER_INDEXING
+ for (i = 0, pal_ptr = palette; i < num_pal; i++, pal_ptr++)
+ {
+ buf[0] = pal_ptr->red;
+ buf[1] = pal_ptr->green;
+ buf[2] = pal_ptr->blue;
+ png_write_chunk_data(png_ptr, buf, (png_size_t)3);
+ }
+#else
+ /* This is a little slower but some buggy compilers need to do this instead */
+ pal_ptr=palette;
+ for (i = 0; i < num_pal; i++)
+ {
+ buf[0] = pal_ptr[i].red;
+ buf[1] = pal_ptr[i].green;
+ buf[2] = pal_ptr[i].blue;
+ png_write_chunk_data(png_ptr, buf, (png_size_t)3);
+ }
+#endif
+ png_write_chunk_end(png_ptr);
+ png_ptr->mode |= PNG_HAVE_PLTE;
+}
+
+/* write an IDAT chunk */
+void /* PRIVATE */
+png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_IDAT;
+#endif
+ png_debug(1, "in png_write_IDAT\n");
+
+ /* Optimize the CMF field in the zlib stream. */
+ /* This hack of the zlib stream is compliant to the stream specification. */
+ if (!(png_ptr->mode & PNG_HAVE_IDAT) &&
+ png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE)
+ {
+ unsigned int z_cmf = data[0]; /* zlib compression method and flags */
+ if ((z_cmf & 0x0f) == 8 && (z_cmf & 0xf0) <= 0x70)
+ {
+ /* Avoid memory underflows and multiplication overflows. */
+ /* The conditions below are practically always satisfied;
+ however, they still must be checked. */
+ if (length >= 2 &&
+ png_ptr->height < 16384 && png_ptr->width < 16384)
+ {
+ png_uint_32 uncompressed_idat_size = png_ptr->height *
+ ((png_ptr->width *
+ png_ptr->channels * png_ptr->bit_depth + 15) >> 3);
+ unsigned int z_cinfo = z_cmf >> 4;
+ unsigned int half_z_window_size = 1 << (z_cinfo + 7);
+ while (uncompressed_idat_size <= half_z_window_size &&
+ half_z_window_size >= 256)
+ {
+ z_cinfo--;
+ half_z_window_size >>= 1;
+ }
+ z_cmf = (z_cmf & 0x0f) | (z_cinfo << 4);
+ if (data[0] != (png_byte)z_cmf)
+ {
+ data[0] = (png_byte)z_cmf;
+ data[1] &= 0xe0;
+ data[1] += (png_byte)(0x1f - ((z_cmf << 8) + data[1]) % 0x1f);
+ }
+ }
+ }
+ else
+ png_error(png_ptr,
+ "Invalid zlib compression method or flags in IDAT");
+ }
+
+ png_write_chunk(png_ptr, (png_bytep)png_IDAT, data, length);
+ png_ptr->mode |= PNG_HAVE_IDAT;
+}
+
+/* write an IEND chunk */
+void /* PRIVATE */
+png_write_IEND(png_structp png_ptr)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_IEND;
+#endif
+ png_debug(1, "in png_write_IEND\n");
+ png_write_chunk(png_ptr, (png_bytep)png_IEND, png_bytep_NULL,
+ (png_size_t)0);
+ png_ptr->mode |= PNG_HAVE_IEND;
+}
+
+#if defined(PNG_WRITE_gAMA_SUPPORTED)
+/* write a gAMA chunk */
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+void /* PRIVATE */
+png_write_gAMA(png_structp png_ptr, double file_gamma)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_gAMA;
+#endif
+ png_uint_32 igamma;
+ png_byte buf[4];
+
+ png_debug(1, "in png_write_gAMA\n");
+ /* file_gamma is saved in 1/100,000ths */
+ igamma = (png_uint_32)(file_gamma * 100000.0 + 0.5);
+ png_save_uint_32(buf, igamma);
+ png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4);
+}
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+void /* PRIVATE */
+png_write_gAMA_fixed(png_structp png_ptr, png_fixed_point file_gamma)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_gAMA;
+#endif
+ png_byte buf[4];
+
+ png_debug(1, "in png_write_gAMA\n");
+ /* file_gamma is saved in 1/100,000ths */
+ png_save_uint_32(buf, (png_uint_32)file_gamma);
+ png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4);
+}
+#endif
+#endif
+
+#if defined(PNG_WRITE_sRGB_SUPPORTED)
+/* write a sRGB chunk */
+void /* PRIVATE */
+png_write_sRGB(png_structp png_ptr, int srgb_intent)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_sRGB;
+#endif
+ png_byte buf[1];
+
+ png_debug(1, "in png_write_sRGB\n");
+ if (srgb_intent >= PNG_sRGB_INTENT_LAST)
+ png_warning(png_ptr,
+ "Invalid sRGB rendering intent specified");
+ buf[0]=(png_byte)srgb_intent;
+ png_write_chunk(png_ptr, (png_bytep)png_sRGB, buf, (png_size_t)1);
+}
+#endif
+
+#if defined(PNG_WRITE_iCCP_SUPPORTED)
+/* write an iCCP chunk */
+void /* PRIVATE */
+png_write_iCCP(png_structp png_ptr, png_charp name, int compression_type,
+ png_charp profile, int profile_len)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_iCCP;
+#endif
+ png_size_t name_len;
+ png_charp new_name;
+ compression_state comp;
+ int embedded_profile_len = 0;
+
+ png_debug(1, "in png_write_iCCP\n");
+
+ comp.num_output_ptr = 0;
+ comp.max_output_ptr = 0;
+ comp.output_ptr = NULL;
+ comp.input = NULL;
+ comp.input_len = 0;
+
+ if (name == NULL || (name_len = png_check_keyword(png_ptr, name,
+ &new_name)) == 0)
+ {
+ png_warning(png_ptr, "Empty keyword in iCCP chunk");
+ return;
+ }
+
+ if (compression_type != PNG_COMPRESSION_TYPE_BASE)
+ png_warning(png_ptr, "Unknown compression type in iCCP chunk");
+
+ if (profile == NULL)
+ profile_len = 0;
+
+ if (profile_len > 3)
+ embedded_profile_len =
+ ((*( (png_bytep)profile ))<<24) |
+ ((*( (png_bytep)profile + 1))<<16) |
+ ((*( (png_bytep)profile + 2))<< 8) |
+ ((*( (png_bytep)profile + 3)) );
+
+ if (profile_len < embedded_profile_len)
+ {
+ png_warning(png_ptr,
+ "Embedded profile length too large in iCCP chunk");
+ return;
+ }
+
+ if (profile_len > embedded_profile_len)
+ {
+ png_warning(png_ptr,
+ "Truncating profile to actual length in iCCP chunk");
+ profile_len = embedded_profile_len;
+ }
+
+ if (profile_len)
+ profile_len = png_text_compress(png_ptr, profile,
+ (png_size_t)profile_len, PNG_COMPRESSION_TYPE_BASE, &comp);
+
+ /* make sure we include the NULL after the name and the compression type */
+ png_write_chunk_start(png_ptr, (png_bytep)png_iCCP,
+ (png_uint_32)(name_len + profile_len + 2));
+ new_name[name_len + 1] = 0x00;
+ png_write_chunk_data(png_ptr, (png_bytep)new_name,
+ (png_size_t)(name_len + 2));
+
+ if (profile_len)
+ png_write_compressed_data_out(png_ptr, &comp);
+
+ png_write_chunk_end(png_ptr);
+ png_free(png_ptr, new_name);
+}
+#endif
+
+#if defined(PNG_WRITE_sPLT_SUPPORTED)
+/* write a sPLT chunk */
+void /* PRIVATE */
+png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_sPLT;
+#endif
+ png_size_t name_len;
+ png_charp new_name;
+ png_byte entrybuf[10];
+ int entry_size = (spalette->depth == 8 ? 6 : 10);
+ int palette_size = entry_size * spalette->nentries;
+ png_sPLT_entryp ep;
+#ifdef PNG_NO_POINTER_INDEXING
+ int i;
+#endif
+
+ png_debug(1, "in png_write_sPLT\n");
+ if (spalette->name == NULL || (name_len = png_check_keyword(png_ptr,
+ spalette->name, &new_name))==0)
+ {
+ png_warning(png_ptr, "Empty keyword in sPLT chunk");
+ return;
+ }
+
+ /* make sure we include the NULL after the name */
+ png_write_chunk_start(png_ptr, (png_bytep)png_sPLT,
+ (png_uint_32)(name_len + 2 + palette_size));
+ png_write_chunk_data(png_ptr, (png_bytep)new_name,
+ (png_size_t)(name_len + 1));
+ png_write_chunk_data(png_ptr, (png_bytep)&spalette->depth, (png_size_t)1);
+
+ /* loop through each palette entry, writing appropriately */
+#ifndef PNG_NO_POINTER_INDEXING
+ for (ep = spalette->entries; ep<spalette->entries + spalette->nentries; ep++)
+ {
+ if (spalette->depth == 8)
+ {
+ entrybuf[0] = (png_byte)ep->red;
+ entrybuf[1] = (png_byte)ep->green;
+ entrybuf[2] = (png_byte)ep->blue;
+ entrybuf[3] = (png_byte)ep->alpha;
+ png_save_uint_16(entrybuf + 4, ep->frequency);
+ }
+ else
+ {
+ png_save_uint_16(entrybuf + 0, ep->red);
+ png_save_uint_16(entrybuf + 2, ep->green);
+ png_save_uint_16(entrybuf + 4, ep->blue);
+ png_save_uint_16(entrybuf + 6, ep->alpha);
+ png_save_uint_16(entrybuf + 8, ep->frequency);
+ }
+ png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size);
+ }
+#else
+ ep=spalette->entries;
+ for (i=0; i>spalette->nentries; i++)
+ {
+ if (spalette->depth == 8)
+ {
+ entrybuf[0] = (png_byte)ep[i].red;
+ entrybuf[1] = (png_byte)ep[i].green;
+ entrybuf[2] = (png_byte)ep[i].blue;
+ entrybuf[3] = (png_byte)ep[i].alpha;
+ png_save_uint_16(entrybuf + 4, ep[i].frequency);
+ }
+ else
+ {
+ png_save_uint_16(entrybuf + 0, ep[i].red);
+ png_save_uint_16(entrybuf + 2, ep[i].green);
+ png_save_uint_16(entrybuf + 4, ep[i].blue);
+ png_save_uint_16(entrybuf + 6, ep[i].alpha);
+ png_save_uint_16(entrybuf + 8, ep[i].frequency);
+ }
+ png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size);
+ }
+#endif
+
+ png_write_chunk_end(png_ptr);
+ png_free(png_ptr, new_name);
+}
+#endif
+
+#if defined(PNG_WRITE_sBIT_SUPPORTED)
+/* write the sBIT chunk */
+void /* PRIVATE */
+png_write_sBIT(png_structp png_ptr, png_color_8p sbit, int color_type)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_sBIT;
+#endif
+ png_byte buf[4];
+ png_size_t size;
+
+ png_debug(1, "in png_write_sBIT\n");
+ /* make sure we don't depend upon the order of PNG_COLOR_8 */
+ if (color_type & PNG_COLOR_MASK_COLOR)
+ {
+ png_byte maxbits;
+
+ maxbits = (png_byte)(color_type==PNG_COLOR_TYPE_PALETTE ? 8 :
+ png_ptr->usr_bit_depth);
+ if (sbit->red == 0 || sbit->red > maxbits ||
+ sbit->green == 0 || sbit->green > maxbits ||
+ sbit->blue == 0 || sbit->blue > maxbits)
+ {
+ png_warning(png_ptr, "Invalid sBIT depth specified");
+ return;
+ }
+ buf[0] = sbit->red;
+ buf[1] = sbit->green;
+ buf[2] = sbit->blue;
+ size = 3;
+ }
+ else
+ {
+ if (sbit->gray == 0 || sbit->gray > png_ptr->usr_bit_depth)
+ {
+ png_warning(png_ptr, "Invalid sBIT depth specified");
+ return;
+ }
+ buf[0] = sbit->gray;
+ size = 1;
+ }
+
+ if (color_type & PNG_COLOR_MASK_ALPHA)
+ {
+ if (sbit->alpha == 0 || sbit->alpha > png_ptr->usr_bit_depth)
+ {
+ png_warning(png_ptr, "Invalid sBIT depth specified");
+ return;
+ }
+ buf[size++] = sbit->alpha;
+ }
+
+ png_write_chunk(png_ptr, (png_bytep)png_sBIT, buf, size);
+}
+#endif
+
+#if defined(PNG_WRITE_cHRM_SUPPORTED)
+/* write the cHRM chunk */
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+void /* PRIVATE */
+png_write_cHRM(png_structp png_ptr, double white_x, double white_y,
+ double red_x, double red_y, double green_x, double green_y,
+ double blue_x, double blue_y)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_cHRM;
+#endif
+ png_byte buf[32];
+ png_uint_32 itemp;
+
+ png_debug(1, "in png_write_cHRM\n");
+ /* each value is saved in 1/100,000ths */
+ if (white_x < 0 || white_x > 0.8 || white_y < 0 || white_y > 0.8 ||
+ white_x + white_y > 1.0)
+ {
+ png_warning(png_ptr, "Invalid cHRM white point specified");
+#if !defined(PNG_NO_CONSOLE_IO)
+ fprintf(stderr, "white_x=%f, white_y=%f\n", white_x, white_y);
+#endif
+ return;
+ }
+ itemp = (png_uint_32)(white_x * 100000.0 + 0.5);
+ png_save_uint_32(buf, itemp);
+ itemp = (png_uint_32)(white_y * 100000.0 + 0.5);
+ png_save_uint_32(buf + 4, itemp);
+
+ if (red_x < 0 || red_y < 0 || red_x + red_y > 1.0)
+ {
+ png_warning(png_ptr, "Invalid cHRM red point specified");
+ return;
+ }
+ itemp = (png_uint_32)(red_x * 100000.0 + 0.5);
+ png_save_uint_32(buf + 8, itemp);
+ itemp = (png_uint_32)(red_y * 100000.0 + 0.5);
+ png_save_uint_32(buf + 12, itemp);
+
+ if (green_x < 0 || green_y < 0 || green_x + green_y > 1.0)
+ {
+ png_warning(png_ptr, "Invalid cHRM green point specified");
+ return;
+ }
+ itemp = (png_uint_32)(green_x * 100000.0 + 0.5);
+ png_save_uint_32(buf + 16, itemp);
+ itemp = (png_uint_32)(green_y * 100000.0 + 0.5);
+ png_save_uint_32(buf + 20, itemp);
+
+ if (blue_x < 0 || blue_y < 0 || blue_x + blue_y > 1.0)
+ {
+ png_warning(png_ptr, "Invalid cHRM blue point specified");
+ return;
+ }
+ itemp = (png_uint_32)(blue_x * 100000.0 + 0.5);
+ png_save_uint_32(buf + 24, itemp);
+ itemp = (png_uint_32)(blue_y * 100000.0 + 0.5);
+ png_save_uint_32(buf + 28, itemp);
+
+ png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32);
+}
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+void /* PRIVATE */
+png_write_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x,
+ png_fixed_point white_y, png_fixed_point red_x, png_fixed_point red_y,
+ png_fixed_point green_x, png_fixed_point green_y, png_fixed_point blue_x,
+ png_fixed_point blue_y)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_cHRM;
+#endif
+ png_byte buf[32];
+
+ png_debug(1, "in png_write_cHRM\n");
+ /* each value is saved in 1/100,000ths */
+ if (white_x > 80000L || white_y > 80000L || white_x + white_y > 100000L)
+ {
+ png_warning(png_ptr, "Invalid fixed cHRM white point specified");
+#if !defined(PNG_NO_CONSOLE_IO)
+ fprintf(stderr, "white_x=%ld, white_y=%ld\n", (unsigned long)white_x,
+ (unsigned long)white_y);
+#endif
+ return;
+ }
+ png_save_uint_32(buf, (png_uint_32)white_x);
+ png_save_uint_32(buf + 4, (png_uint_32)white_y);
+
+ if (red_x + red_y > 100000L)
+ {
+ png_warning(png_ptr, "Invalid cHRM fixed red point specified");
+ return;
+ }
+ png_save_uint_32(buf + 8, (png_uint_32)red_x);
+ png_save_uint_32(buf + 12, (png_uint_32)red_y);
+
+ if (green_x + green_y > 100000L)
+ {
+ png_warning(png_ptr, "Invalid fixed cHRM green point specified");
+ return;
+ }
+ png_save_uint_32(buf + 16, (png_uint_32)green_x);
+ png_save_uint_32(buf + 20, (png_uint_32)green_y);
+
+ if (blue_x + blue_y > 100000L)
+ {
+ png_warning(png_ptr, "Invalid fixed cHRM blue point specified");
+ return;
+ }
+ png_save_uint_32(buf + 24, (png_uint_32)blue_x);
+ png_save_uint_32(buf + 28, (png_uint_32)blue_y);
+
+ png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32);
+}
+#endif
+#endif
+
+#if defined(PNG_WRITE_tRNS_SUPPORTED)
+/* write the tRNS chunk */
+void /* PRIVATE */
+png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran,
+ int num_trans, int color_type)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_tRNS;
+#endif
+ png_byte buf[6];
+
+ png_debug(1, "in png_write_tRNS\n");
+ if (color_type == PNG_COLOR_TYPE_PALETTE)
+ {
+ if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette)
+ {
+ png_warning(png_ptr, "Invalid number of transparent colors specified");
+ return;
+ }
+ /* write the chunk out as it is */
+ png_write_chunk(png_ptr, (png_bytep)png_tRNS, trans,
+ (png_size_t)num_trans);
+ }
+ else if (color_type == PNG_COLOR_TYPE_GRAY)
+ {
+ /* one 16 bit value */
+ if (tran->gray >= (1 << png_ptr->bit_depth))
+ {
+ png_warning(png_ptr,
+ "Ignoring attempt to write tRNS chunk out-of-range for bit_depth");
+ return;
+ }
+ png_save_uint_16(buf, tran->gray);
+ png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)2);
+ }
+ else if (color_type == PNG_COLOR_TYPE_RGB)
+ {
+ /* three 16 bit values */
+ png_save_uint_16(buf, tran->red);
+ png_save_uint_16(buf + 2, tran->green);
+ png_save_uint_16(buf + 4, tran->blue);
+ if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))
+ {
+ png_warning(png_ptr,
+ "Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8");
+ return;
+ }
+ png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)6);
+ }
+ else
+ {
+ png_warning(png_ptr, "Can't write tRNS with an alpha channel");
+ }
+}
+#endif
+
+#if defined(PNG_WRITE_bKGD_SUPPORTED)
+/* write the background chunk */
+void /* PRIVATE */
+png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_bKGD;
+#endif
+ png_byte buf[6];
+
+ png_debug(1, "in png_write_bKGD\n");
+ if (color_type == PNG_COLOR_TYPE_PALETTE)
+ {
+ if (
+#if defined(PNG_MNG_FEATURES_SUPPORTED)
+ (png_ptr->num_palette ||
+ (!(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE))) &&
+#endif
+ back->index > png_ptr->num_palette)
+ {
+ png_warning(png_ptr, "Invalid background palette index");
+ return;
+ }
+ buf[0] = back->index;
+ png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)1);
+ }
+ else if (color_type & PNG_COLOR_MASK_COLOR)
+ {
+ png_save_uint_16(buf, back->red);
+ png_save_uint_16(buf + 2, back->green);
+ png_save_uint_16(buf + 4, back->blue);
+ if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))
+ {
+ png_warning(png_ptr,
+ "Ignoring attempt to write 16-bit bKGD chunk when bit_depth is 8");
+ return;
+ }
+ png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)6);
+ }
+ else
+ {
+ if (back->gray >= (1 << png_ptr->bit_depth))
+ {
+ png_warning(png_ptr,
+ "Ignoring attempt to write bKGD chunk out-of-range for bit_depth");
+ return;
+ }
+ png_save_uint_16(buf, back->gray);
+ png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)2);
+ }
+}
+#endif
+
+#if defined(PNG_WRITE_hIST_SUPPORTED)
+/* write the histogram */
+void /* PRIVATE */
+png_write_hIST(png_structp png_ptr, png_uint_16p hist, int num_hist)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_hIST;
+#endif
+ int i;
+ png_byte buf[3];
+
+ png_debug(1, "in png_write_hIST\n");
+ if (num_hist > (int)png_ptr->num_palette)
+ {
+ png_debug2(3, "num_hist = %d, num_palette = %d\n", num_hist,
+ png_ptr->num_palette);
+ png_warning(png_ptr, "Invalid number of histogram entries specified");
+ return;
+ }
+
+ png_write_chunk_start(png_ptr, (png_bytep)png_hIST,
+ (png_uint_32)(num_hist * 2));
+ for (i = 0; i < num_hist; i++)
+ {
+ png_save_uint_16(buf, hist[i]);
+ png_write_chunk_data(png_ptr, buf, (png_size_t)2);
+ }
+ png_write_chunk_end(png_ptr);
+}
+#endif
+
+#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \
+ defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)
+/* Check that the tEXt or zTXt keyword is valid per PNG 1.0 specification,
+ * and if invalid, correct the keyword rather than discarding the entire
+ * chunk. The PNG 1.0 specification requires keywords 1-79 characters in
+ * length, forbids leading or trailing whitespace, multiple internal spaces,
+ * and the non-break space (0x80) from ISO 8859-1. Returns keyword length.
+ *
+ * The new_key is allocated to hold the corrected keyword and must be freed
+ * by the calling routine. This avoids problems with trying to write to
+ * static keywords without having to have duplicate copies of the strings.
+ */
+png_size_t /* PRIVATE */
+png_check_keyword(png_structp png_ptr, png_charp key, png_charpp new_key)
+{
+ png_size_t key_len;
+ png_charp kp, dp;
+ int kflag;
+ int kwarn=0;
+
+ png_debug(1, "in png_check_keyword\n");
+ *new_key = NULL;
+
+ if (key == NULL || (key_len = png_strlen(key)) == 0)
+ {
+ png_warning(png_ptr, "zero length keyword");
+ return ((png_size_t)0);
+ }
+
+ png_debug1(2, "Keyword to be checked is '%s'\n", key);
+
+ *new_key = (png_charp)png_malloc_warn(png_ptr, (png_uint_32)(key_len + 2));
+ if (*new_key == NULL)
+ {
+ png_warning(png_ptr, "Out of memory while procesing keyword");
+ return ((png_size_t)0);
+ }
+
+ /* Replace non-printing characters with a blank and print a warning */
+ for (kp = key, dp = *new_key; *kp != '\0'; kp++, dp++)
+ {
+ if ((png_byte)*kp < 0x20 ||
+ ((png_byte)*kp > 0x7E && (png_byte)*kp < 0xA1))
+ {
+#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)
+ char msg[40];
+
+ png_snprintf(msg, 40,
+ "invalid keyword character 0x%02X", (png_byte)*kp);
+ png_warning(png_ptr, msg);
+#else
+ png_warning(png_ptr, "invalid character in keyword");
+#endif
+ *dp = ' ';
+ }
+ else
+ {
+ *dp = *kp;
+ }
+ }
+ *dp = '\0';
+
+ /* Remove any trailing white space. */
+ kp = *new_key + key_len - 1;
+ if (*kp == ' ')
+ {
+ png_warning(png_ptr, "trailing spaces removed from keyword");
+
+ while (*kp == ' ')
+ {
+ *(kp--) = '\0';
+ key_len--;
+ }
+ }
+
+ /* Remove any leading white space. */
+ kp = *new_key;
+ if (*kp == ' ')
+ {
+ png_warning(png_ptr, "leading spaces removed from keyword");
+
+ while (*kp == ' ')
+ {
+ kp++;
+ key_len--;
+ }
+ }
+
+ png_debug1(2, "Checking for multiple internal spaces in '%s'\n", kp);
+
+ /* Remove multiple internal spaces. */
+ for (kflag = 0, dp = *new_key; *kp != '\0'; kp++)
+ {
+ if (*kp == ' ' && kflag == 0)
+ {
+ *(dp++) = *kp;
+ kflag = 1;
+ }
+ else if (*kp == ' ')
+ {
+ key_len--;
+ kwarn=1;
+ }
+ else
+ {
+ *(dp++) = *kp;
+ kflag = 0;
+ }
+ }
+ *dp = '\0';
+ if (kwarn)
+ png_warning(png_ptr, "extra interior spaces removed from keyword");
+
+ if (key_len == 0)
+ {
+ png_free(png_ptr, *new_key);
+ *new_key=NULL;
+ png_warning(png_ptr, "Zero length keyword");
+ }
+
+ if (key_len > 79)
+ {
+ png_warning(png_ptr, "keyword length must be 1 - 79 characters");
+ new_key[79] = '\0';
+ key_len = 79;
+ }
+
+ return (key_len);
+}
+#endif
+
+#if defined(PNG_WRITE_tEXt_SUPPORTED)
+/* write a tEXt chunk */
+void /* PRIVATE */
+png_write_tEXt(png_structp png_ptr, png_charp key, png_charp text,
+ png_size_t text_len)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_tEXt;
+#endif
+ png_size_t key_len;
+ png_charp new_key;
+
+ png_debug(1, "in png_write_tEXt\n");
+ if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0)
+ {
+ png_warning(png_ptr, "Empty keyword in tEXt chunk");
+ return;
+ }
+
+ if (text == NULL || *text == '\0')
+ text_len = 0;
+ else
+ text_len = png_strlen(text);
+
+ /* make sure we include the 0 after the key */
+ png_write_chunk_start(png_ptr, (png_bytep)png_tEXt,
+ (png_uint_32)(key_len + text_len + 1));
+ /*
+ * We leave it to the application to meet PNG-1.0 requirements on the
+ * contents of the text. PNG-1.0 through PNG-1.2 discourage the use of
+ * any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them.
+ * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.
+ */
+ png_write_chunk_data(png_ptr, (png_bytep)new_key,
+ (png_size_t)(key_len + 1));
+ if (text_len)
+ png_write_chunk_data(png_ptr, (png_bytep)text, (png_size_t)text_len);
+
+ png_write_chunk_end(png_ptr);
+ png_free(png_ptr, new_key);
+}
+#endif
+
+#if defined(PNG_WRITE_zTXt_SUPPORTED)
+/* write a compressed text chunk */
+void /* PRIVATE */
+png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,
+ png_size_t text_len, int compression)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_zTXt;
+#endif
+ png_size_t key_len;
+ char buf[1];
+ png_charp new_key;
+ compression_state comp;
+
+ png_debug(1, "in png_write_zTXt\n");
+
+ comp.num_output_ptr = 0;
+ comp.max_output_ptr = 0;
+ comp.output_ptr = NULL;
+ comp.input = NULL;
+ comp.input_len = 0;
+
+ if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0)
+ {
+ png_warning(png_ptr, "Empty keyword in zTXt chunk");
+ png_free(png_ptr, new_key);
+ return;
+ }
+
+ if (text == NULL || *text == '\0' || compression==PNG_TEXT_COMPRESSION_NONE)
+ {
+ png_write_tEXt(png_ptr, new_key, text, (png_size_t)0);
+ png_free(png_ptr, new_key);
+ return;
+ }
+
+ text_len = png_strlen(text);
+
+ /* compute the compressed data; do it now for the length */
+ text_len = png_text_compress(png_ptr, text, text_len, compression,
+ &comp);
+
+ /* write start of chunk */
+ png_write_chunk_start(png_ptr, (png_bytep)png_zTXt,
+ (png_uint_32)(key_len+text_len + 2));
+ /* write key */
+ png_write_chunk_data(png_ptr, (png_bytep)new_key,
+ (png_size_t)(key_len + 1));
+ png_free(png_ptr, new_key);
+
+ buf[0] = (png_byte)compression;
+ /* write compression */
+ png_write_chunk_data(png_ptr, (png_bytep)buf, (png_size_t)1);
+ /* write the compressed data */
+ png_write_compressed_data_out(png_ptr, &comp);
+
+ /* close the chunk */
+ png_write_chunk_end(png_ptr);
+}
+#endif
+
+#if defined(PNG_WRITE_iTXt_SUPPORTED)
+/* write an iTXt chunk */
+void /* PRIVATE */
+png_write_iTXt(png_structp png_ptr, int compression, png_charp key,
+ png_charp lang, png_charp lang_key, png_charp text)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_iTXt;
+#endif
+ png_size_t lang_len, key_len, lang_key_len, text_len;
+ png_charp new_lang, new_key;
+ png_byte cbuf[2];
+ compression_state comp;
+
+ png_debug(1, "in png_write_iTXt\n");
+
+ comp.num_output_ptr = 0;
+ comp.max_output_ptr = 0;
+ comp.output_ptr = NULL;
+ comp.input = NULL;
+
+ if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0)
+ {
+ png_warning(png_ptr, "Empty keyword in iTXt chunk");
+ return;
+ }
+ if (lang == NULL || (lang_len = png_check_keyword(png_ptr, lang, &new_lang))==0)
+ {
+ png_warning(png_ptr, "Empty language field in iTXt chunk");
+ new_lang = NULL;
+ lang_len = 0;
+ }
+
+ if (lang_key == NULL)
+ lang_key_len = 0;
+ else
+ lang_key_len = png_strlen(lang_key);
+
+ if (text == NULL)
+ text_len = 0;
+ else
+ text_len = png_strlen(text);
+
+ /* compute the compressed data; do it now for the length */
+ text_len = png_text_compress(png_ptr, text, text_len, compression-2,
+ &comp);
+
+
+ /* make sure we include the compression flag, the compression byte,
+ * and the NULs after the key, lang, and lang_key parts */
+
+ png_write_chunk_start(png_ptr, (png_bytep)png_iTXt,
+ (png_uint_32)(
+ 5 /* comp byte, comp flag, terminators for key, lang and lang_key */
+ + key_len
+ + lang_len
+ + lang_key_len
+ + text_len));
+
+ /*
+ * We leave it to the application to meet PNG-1.0 requirements on the
+ * contents of the text. PNG-1.0 through PNG-1.2 discourage the use of
+ * any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them.
+ * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.
+ */
+ png_write_chunk_data(png_ptr, (png_bytep)new_key,
+ (png_size_t)(key_len + 1));
+
+ /* set the compression flag */
+ if (compression == PNG_ITXT_COMPRESSION_NONE || \
+ compression == PNG_TEXT_COMPRESSION_NONE)
+ cbuf[0] = 0;
+ else /* compression == PNG_ITXT_COMPRESSION_zTXt */
+ cbuf[0] = 1;
+ /* set the compression method */
+ cbuf[1] = 0;
+ png_write_chunk_data(png_ptr, cbuf, (png_size_t)2);
+
+ cbuf[0] = 0;
+ png_write_chunk_data(png_ptr, (new_lang ? (png_bytep)new_lang : cbuf),
+ (png_size_t)(lang_len + 1));
+ png_write_chunk_data(png_ptr, (lang_key ? (png_bytep)lang_key : cbuf),
+ (png_size_t)(lang_key_len + 1));
+ png_write_compressed_data_out(png_ptr, &comp);
+
+ png_write_chunk_end(png_ptr);
+ png_free(png_ptr, new_key);
+ png_free(png_ptr, new_lang);
+}
+#endif
+
+#if defined(PNG_WRITE_oFFs_SUPPORTED)
+/* write the oFFs chunk */
+void /* PRIVATE */
+png_write_oFFs(png_structp png_ptr, png_int_32 x_offset, png_int_32 y_offset,
+ int unit_type)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_oFFs;
+#endif
+ png_byte buf[9];
+
+ png_debug(1, "in png_write_oFFs\n");
+ if (unit_type >= PNG_OFFSET_LAST)
+ png_warning(png_ptr, "Unrecognized unit type for oFFs chunk");
+
+ png_save_int_32(buf, x_offset);
+ png_save_int_32(buf + 4, y_offset);
+ buf[8] = (png_byte)unit_type;
+
+ png_write_chunk(png_ptr, (png_bytep)png_oFFs, buf, (png_size_t)9);
+}
+#endif
+#if defined(PNG_WRITE_pCAL_SUPPORTED)
+/* write the pCAL chunk (described in the PNG extensions document) */
+void /* PRIVATE */
+png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0,
+ png_int_32 X1, int type, int nparams, png_charp units, png_charpp params)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_pCAL;
+#endif
+ png_size_t purpose_len, units_len, total_len;
+ png_uint_32p params_len;
+ png_byte buf[10];
+ png_charp new_purpose;
+ int i;
+
+ png_debug1(1, "in png_write_pCAL (%d parameters)\n", nparams);
+ if (type >= PNG_EQUATION_LAST)
+ png_warning(png_ptr, "Unrecognized equation type for pCAL chunk");
+
+ purpose_len = png_check_keyword(png_ptr, purpose, &new_purpose) + 1;
+ png_debug1(3, "pCAL purpose length = %d\n", (int)purpose_len);
+ units_len = png_strlen(units) + (nparams == 0 ? 0 : 1);
+ png_debug1(3, "pCAL units length = %d\n", (int)units_len);
+ total_len = purpose_len + units_len + 10;
+
+ params_len = (png_uint_32p)png_malloc(png_ptr,
+ (png_uint_32)(nparams * png_sizeof(png_uint_32)));
+
+ /* Find the length of each parameter, making sure we don't count the
+ null terminator for the last parameter. */
+ for (i = 0; i < nparams; i++)
+ {
+ params_len[i] = png_strlen(params[i]) + (i == nparams - 1 ? 0 : 1);
+ png_debug2(3, "pCAL parameter %d length = %lu\n", i,
+ (unsigned long) params_len[i]);
+ total_len += (png_size_t)params_len[i];
+ }
+
+ png_debug1(3, "pCAL total length = %d\n", (int)total_len);
+ png_write_chunk_start(png_ptr, (png_bytep)png_pCAL, (png_uint_32)total_len);
+ png_write_chunk_data(png_ptr, (png_bytep)new_purpose,
+ (png_size_t)purpose_len);
+ png_save_int_32(buf, X0);
+ png_save_int_32(buf + 4, X1);
+ buf[8] = (png_byte)type;
+ buf[9] = (png_byte)nparams;
+ png_write_chunk_data(png_ptr, buf, (png_size_t)10);
+ png_write_chunk_data(png_ptr, (png_bytep)units, (png_size_t)units_len);
+
+ png_free(png_ptr, new_purpose);
+
+ for (i = 0; i < nparams; i++)
+ {
+ png_write_chunk_data(png_ptr, (png_bytep)params[i],
+ (png_size_t)params_len[i]);
+ }
+
+ png_free(png_ptr, params_len);
+ png_write_chunk_end(png_ptr);
+}
+#endif
+
+#if defined(PNG_WRITE_sCAL_SUPPORTED)
+/* write the sCAL chunk */
+#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO)
+void /* PRIVATE */
+png_write_sCAL(png_structp png_ptr, int unit, double width, double height)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_sCAL;
+#endif
+ char buf[64];
+ png_size_t total_len;
+
+ png_debug(1, "in png_write_sCAL\n");
+
+ buf[0] = (char)unit;
+#if defined(_WIN32_WCE)
+/* sprintf() function is not supported on WindowsCE */
+ {
+ wchar_t wc_buf[32];
+ size_t wc_len;
+ swprintf(wc_buf, TEXT("%12.12e"), width);
+ wc_len = wcslen(wc_buf);
+ WideCharToMultiByte(CP_ACP, 0, wc_buf, -1, buf + 1, wc_len, NULL, NULL);
+ total_len = wc_len + 2;
+ swprintf(wc_buf, TEXT("%12.12e"), height);
+ wc_len = wcslen(wc_buf);
+ WideCharToMultiByte(CP_ACP, 0, wc_buf, -1, buf + total_len, wc_len,
+ NULL, NULL);
+ total_len += wc_len;
+ }
+#else
+ png_snprintf(buf + 1, 63, "%12.12e", width);
+ total_len = 1 + png_strlen(buf + 1) + 1;
+ png_snprintf(buf + total_len, 64-total_len, "%12.12e", height);
+ total_len += png_strlen(buf + total_len);
+#endif
+
+ png_debug1(3, "sCAL total length = %u\n", (unsigned int)total_len);
+ png_write_chunk(png_ptr, (png_bytep)png_sCAL, (png_bytep)buf, total_len);
+}
+#else
+#ifdef PNG_FIXED_POINT_SUPPORTED
+void /* PRIVATE */
+png_write_sCAL_s(png_structp png_ptr, int unit, png_charp width,
+ png_charp height)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_sCAL;
+#endif
+ png_byte buf[64];
+ png_size_t wlen, hlen, total_len;
+
+ png_debug(1, "in png_write_sCAL_s\n");
+
+ wlen = png_strlen(width);
+ hlen = png_strlen(height);
+ total_len = wlen + hlen + 2;
+ if (total_len > 64)
+ {
+ png_warning(png_ptr, "Can't write sCAL (buffer too small)");
+ return;
+ }
+
+ buf[0] = (png_byte)unit;
+ png_memcpy(buf + 1, width, wlen + 1); /* append the '\0' here */
+ png_memcpy(buf + wlen + 2, height, hlen); /* do NOT append the '\0' here */
+
+ png_debug1(3, "sCAL total length = %u\n", (unsigned int)total_len);
+ png_write_chunk(png_ptr, (png_bytep)png_sCAL, buf, total_len);
+}
+#endif
+#endif
+#endif
+
+#if defined(PNG_WRITE_pHYs_SUPPORTED)
+/* write the pHYs chunk */
+void /* PRIVATE */
+png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit,
+ png_uint_32 y_pixels_per_unit,
+ int unit_type)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_pHYs;
+#endif
+ png_byte buf[9];
+
+ png_debug(1, "in png_write_pHYs\n");
+ if (unit_type >= PNG_RESOLUTION_LAST)
+ png_warning(png_ptr, "Unrecognized unit type for pHYs chunk");
+
+ png_save_uint_32(buf, x_pixels_per_unit);
+ png_save_uint_32(buf + 4, y_pixels_per_unit);
+ buf[8] = (png_byte)unit_type;
+
+ png_write_chunk(png_ptr, (png_bytep)png_pHYs, buf, (png_size_t)9);
+}
+#endif
+
+#if defined(PNG_WRITE_tIME_SUPPORTED)
+/* Write the tIME chunk. Use either png_convert_from_struct_tm()
+ * or png_convert_from_time_t(), or fill in the structure yourself.
+ */
+void /* PRIVATE */
+png_write_tIME(png_structp png_ptr, png_timep mod_time)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ PNG_tIME;
+#endif
+ png_byte buf[7];
+
+ png_debug(1, "in png_write_tIME\n");
+ if (mod_time->month > 12 || mod_time->month < 1 ||
+ mod_time->day > 31 || mod_time->day < 1 ||
+ mod_time->hour > 23 || mod_time->second > 60)
+ {
+ png_warning(png_ptr, "Invalid time specified for tIME chunk");
+ return;
+ }
+
+ png_save_uint_16(buf, mod_time->year);
+ buf[2] = mod_time->month;
+ buf[3] = mod_time->day;
+ buf[4] = mod_time->hour;
+ buf[5] = mod_time->minute;
+ buf[6] = mod_time->second;
+
+ png_write_chunk(png_ptr, (png_bytep)png_tIME, buf, (png_size_t)7);
+}
+#endif
+
+/* initializes the row writing capability of libpng */
+void /* PRIVATE */
+png_write_start_row(png_structp png_ptr)
+{
+#ifdef PNG_WRITE_INTERLACING_SUPPORTED
+#ifdef PNG_USE_LOCAL_ARRAYS
+ /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
+
+ /* start of interlace block */
+ int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
+
+ /* offset to next interlace block */
+ int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
+
+ /* start of interlace block in the y direction */
+ int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
+
+ /* offset to next interlace block in the y direction */
+ int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
+#endif
+#endif
+
+ png_size_t buf_size;
+
+ png_debug(1, "in png_write_start_row\n");
+ buf_size = (png_size_t)(PNG_ROWBYTES(
+ png_ptr->usr_channels*png_ptr->usr_bit_depth, png_ptr->width) + 1);
+
+ /* set up row buffer */
+ png_ptr->row_buf = (png_bytep)png_malloc(png_ptr,
+ (png_uint_32)buf_size);
+ png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE;
+
+#ifndef PNG_NO_WRITE_FILTER
+ /* set up filtering buffer, if using this filter */
+ if (png_ptr->do_filter & PNG_FILTER_SUB)
+ {
+ png_ptr->sub_row = (png_bytep)png_malloc(png_ptr,
+ (png_uint_32)(png_ptr->rowbytes + 1));
+ png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;
+ }
+
+ /* We only need to keep the previous row if we are using one of these. */
+ if (png_ptr->do_filter & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH))
+ {
+ /* set up previous row buffer */
+ png_ptr->prev_row = (png_bytep)png_malloc(png_ptr,
+ (png_uint_32)buf_size);
+ png_memset(png_ptr->prev_row, 0, buf_size);
+
+ if (png_ptr->do_filter & PNG_FILTER_UP)
+ {
+ png_ptr->up_row = (png_bytep)png_malloc(png_ptr,
+ (png_uint_32)(png_ptr->rowbytes + 1));
+ png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;
+ }
+
+ if (png_ptr->do_filter & PNG_FILTER_AVG)
+ {
+ png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,
+ (png_uint_32)(png_ptr->rowbytes + 1));
+ png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;
+ }
+
+ if (png_ptr->do_filter & PNG_FILTER_PAETH)
+ {
+ png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr,
+ (png_uint_32)(png_ptr->rowbytes + 1));
+ png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;
+ }
+ }
+#endif /* PNG_NO_WRITE_FILTER */
+
+#ifdef PNG_WRITE_INTERLACING_SUPPORTED
+ /* if interlaced, we need to set up width and height of pass */
+ if (png_ptr->interlaced)
+ {
+ if (!(png_ptr->transformations & PNG_INTERLACE))
+ {
+ png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -
+ png_pass_ystart[0]) / png_pass_yinc[0];
+ png_ptr->usr_width = (png_ptr->width + png_pass_inc[0] - 1 -
+ png_pass_start[0]) / png_pass_inc[0];
+ }
+ else
+ {
+ png_ptr->num_rows = png_ptr->height;
+ png_ptr->usr_width = png_ptr->width;
+ }
+ }
+ else
+#endif
+ {
+ png_ptr->num_rows = png_ptr->height;
+ png_ptr->usr_width = png_ptr->width;
+ }
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+ png_ptr->zstream.next_out = png_ptr->zbuf;
+}
+
+/* Internal use only. Called when finished processing a row of data. */
+void /* PRIVATE */
+png_write_finish_row(png_structp png_ptr)
+{
+#ifdef PNG_WRITE_INTERLACING_SUPPORTED
+#ifdef PNG_USE_LOCAL_ARRAYS
+ /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
+
+ /* start of interlace block */
+ int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
+
+ /* offset to next interlace block */
+ int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
+
+ /* start of interlace block in the y direction */
+ int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
+
+ /* offset to next interlace block in the y direction */
+ int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
+#endif
+#endif
+
+ int ret;
+
+ png_debug(1, "in png_write_finish_row\n");
+ /* next row */
+ png_ptr->row_number++;
+
+ /* see if we are done */
+ if (png_ptr->row_number < png_ptr->num_rows)
+ return;
+
+#ifdef PNG_WRITE_INTERLACING_SUPPORTED
+ /* if interlaced, go to next pass */
+ if (png_ptr->interlaced)
+ {
+ png_ptr->row_number = 0;
+ if (png_ptr->transformations & PNG_INTERLACE)
+ {
+ png_ptr->pass++;
+ }
+ else
+ {
+ /* loop until we find a non-zero width or height pass */
+ do
+ {
+ png_ptr->pass++;
+ if (png_ptr->pass >= 7)
+ break;
+ png_ptr->usr_width = (png_ptr->width +
+ png_pass_inc[png_ptr->pass] - 1 -
+ png_pass_start[png_ptr->pass]) /
+ png_pass_inc[png_ptr->pass];
+ png_ptr->num_rows = (png_ptr->height +
+ png_pass_yinc[png_ptr->pass] - 1 -
+ png_pass_ystart[png_ptr->pass]) /
+ png_pass_yinc[png_ptr->pass];
+ if (png_ptr->transformations & PNG_INTERLACE)
+ break;
+ } while (png_ptr->usr_width == 0 || png_ptr->num_rows == 0);
+
+ }
+
+ /* reset the row above the image for the next pass */
+ if (png_ptr->pass < 7)
+ {
+ if (png_ptr->prev_row != NULL)
+ png_memset(png_ptr->prev_row, 0,
+ (png_size_t)(PNG_ROWBYTES(png_ptr->usr_channels*
+ png_ptr->usr_bit_depth, png_ptr->width)) + 1);
+ return;
+ }
+ }
+#endif
+
+ /* if we get here, we've just written the last row, so we need
+ to flush the compressor */
+ do
+ {
+ /* tell the compressor we are done */
+ ret = deflate(&png_ptr->zstream, Z_FINISH);
+ /* check for an error */
+ if (ret == Z_OK)
+ {
+ /* check to see if we need more room */
+ if (!(png_ptr->zstream.avail_out))
+ {
+ png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
+ png_ptr->zstream.next_out = png_ptr->zbuf;
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+ }
+ }
+ else if (ret != Z_STREAM_END)
+ {
+ if (png_ptr->zstream.msg != NULL)
+ png_error(png_ptr, png_ptr->zstream.msg);
+ else
+ png_error(png_ptr, "zlib error");
+ }
+ } while (ret != Z_STREAM_END);
+
+ /* write any extra space */
+ if (png_ptr->zstream.avail_out < png_ptr->zbuf_size)
+ {
+ png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size -
+ png_ptr->zstream.avail_out);
+ }
+
+ deflateReset(&png_ptr->zstream);
+ png_ptr->zstream.data_type = Z_BINARY;
+}
+
+#if defined(PNG_WRITE_INTERLACING_SUPPORTED)
+/* Pick out the correct pixels for the interlace pass.
+ * The basic idea here is to go through the row with a source
+ * pointer and a destination pointer (sp and dp), and copy the
+ * correct pixels for the pass. As the row gets compacted,
+ * sp will always be >= dp, so we should never overwrite anything.
+ * See the default: case for the easiest code to understand.
+ */
+void /* PRIVATE */
+png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
+{
+#ifdef PNG_USE_LOCAL_ARRAYS
+ /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
+
+ /* start of interlace block */
+ int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
+
+ /* offset to next interlace block */
+ int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
+#endif
+
+ png_debug(1, "in png_do_write_interlace\n");
+ /* we don't have to do anything on the last pass (6) */
+#if defined(PNG_USELESS_TESTS_SUPPORTED)
+ if (row != NULL && row_info != NULL && pass < 6)
+#else
+ if (pass < 6)
+#endif
+ {
+ /* each pixel depth is handled separately */
+ switch (row_info->pixel_depth)
+ {
+ case 1:
+ {
+ png_bytep sp;
+ png_bytep dp;
+ int shift;
+ int d;
+ int value;
+ png_uint_32 i;
+ png_uint_32 row_width = row_info->width;
+
+ dp = row;
+ d = 0;
+ shift = 7;
+ for (i = png_pass_start[pass]; i < row_width;
+ i += png_pass_inc[pass])
+ {
+ sp = row + (png_size_t)(i >> 3);
+ value = (int)(*sp >> (7 - (int)(i & 0x07))) & 0x01;
+ d |= (value << shift);
+
+ if (shift == 0)
+ {
+ shift = 7;
+ *dp++ = (png_byte)d;
+ d = 0;
+ }
+ else
+ shift--;
+
+ }
+ if (shift != 7)
+ *dp = (png_byte)d;
+ break;
+ }
+ case 2:
+ {
+ png_bytep sp;
+ png_bytep dp;
+ int shift;
+ int d;
+ int value;
+ png_uint_32 i;
+ png_uint_32 row_width = row_info->width;
+
+ dp = row;
+ shift = 6;
+ d = 0;
+ for (i = png_pass_start[pass]; i < row_width;
+ i += png_pass_inc[pass])
+ {
+ sp = row + (png_size_t)(i >> 2);
+ value = (*sp >> ((3 - (int)(i & 0x03)) << 1)) & 0x03;
+ d |= (value << shift);
+
+ if (shift == 0)
+ {
+ shift = 6;
+ *dp++ = (png_byte)d;
+ d = 0;
+ }
+ else
+ shift -= 2;
+ }
+ if (shift != 6)
+ *dp = (png_byte)d;
+ break;
+ }
+ case 4:
+ {
+ png_bytep sp;
+ png_bytep dp;
+ int shift;
+ int d;
+ int value;
+ png_uint_32 i;
+ png_uint_32 row_width = row_info->width;
+
+ dp = row;
+ shift = 4;
+ d = 0;
+ for (i = png_pass_start[pass]; i < row_width;
+ i += png_pass_inc[pass])
+ {
+ sp = row + (png_size_t)(i >> 1);
+ value = (*sp >> ((1 - (int)(i & 0x01)) << 2)) & 0x0f;
+ d |= (value << shift);
+
+ if (shift == 0)
+ {
+ shift = 4;
+ *dp++ = (png_byte)d;
+ d = 0;
+ }
+ else
+ shift -= 4;
+ }
+ if (shift != 4)
+ *dp = (png_byte)d;
+ break;
+ }
+ default:
+ {
+ png_bytep sp;
+ png_bytep dp;
+ png_uint_32 i;
+ png_uint_32 row_width = row_info->width;
+ png_size_t pixel_bytes;
+
+ /* start at the beginning */
+ dp = row;
+ /* find out how many bytes each pixel takes up */
+ pixel_bytes = (row_info->pixel_depth >> 3);
+ /* loop through the row, only looking at the pixels that
+ matter */
+ for (i = png_pass_start[pass]; i < row_width;
+ i += png_pass_inc[pass])
+ {
+ /* find out where the original pixel is */
+ sp = row + (png_size_t)i * pixel_bytes;
+ /* move the pixel */
+ if (dp != sp)
+ png_memcpy(dp, sp, pixel_bytes);
+ /* next pixel */
+ dp += pixel_bytes;
+ }
+ break;
+ }
+ }
+ /* set new row width */
+ row_info->width = (row_info->width +
+ png_pass_inc[pass] - 1 -
+ png_pass_start[pass]) /
+ png_pass_inc[pass];
+ row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,
+ row_info->width);
+ }
+}
+#endif
+
+/* This filters the row, chooses which filter to use, if it has not already
+ * been specified by the application, and then writes the row out with the
+ * chosen filter.
+ */
+#define PNG_MAXSUM (((png_uint_32)(-1)) >> 1)
+#define PNG_HISHIFT 10
+#define PNG_LOMASK ((png_uint_32)0xffffL)
+#define PNG_HIMASK ((png_uint_32)(~PNG_LOMASK >> PNG_HISHIFT))
+void /* PRIVATE */
+png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
+{
+ png_bytep best_row;
+#ifndef PNG_NO_WRITE_FILTER
+ png_bytep prev_row, row_buf;
+ png_uint_32 mins, bpp;
+ png_byte filter_to_do = png_ptr->do_filter;
+ png_uint_32 row_bytes = row_info->rowbytes;
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
+ int num_p_filters = (int)png_ptr->num_prev_filters;
+#endif
+
+ png_debug(1, "in png_write_find_filter\n");
+ /* find out how many bytes offset each pixel is */
+ bpp = (row_info->pixel_depth + 7) >> 3;
+
+ prev_row = png_ptr->prev_row;
+#endif
+ best_row = png_ptr->row_buf;
+#ifndef PNG_NO_WRITE_FILTER
+ row_buf = best_row;
+ mins = PNG_MAXSUM;
+
+ /* The prediction method we use is to find which method provides the
+ * smallest value when summing the absolute values of the distances
+ * from zero, using anything >= 128 as negative numbers. This is known
+ * as the "minimum sum of absolute differences" heuristic. Other
+ * heuristics are the "weighted minimum sum of absolute differences"
+ * (experimental and can in theory improve compression), and the "zlib
+ * predictive" method (not implemented yet), which does test compressions
+ * of lines using different filter methods, and then chooses the
+ * (series of) filter(s) that give minimum compressed data size (VERY
+ * computationally expensive).
+ *
+ * GRR 980525: consider also
+ * (1) minimum sum of absolute differences from running average (i.e.,
+ * keep running sum of non-absolute differences & count of bytes)
+ * [track dispersion, too? restart average if dispersion too large?]
+ * (1b) minimum sum of absolute differences from sliding average, probably
+ * with window size <= deflate window (usually 32K)
+ * (2) minimum sum of squared differences from zero or running average
+ * (i.e., ~ root-mean-square approach)
+ */
+
+
+ /* We don't need to test the 'no filter' case if this is the only filter
+ * that has been chosen, as it doesn't actually do anything to the data.
+ */
+ if ((filter_to_do & PNG_FILTER_NONE) &&
+ filter_to_do != PNG_FILTER_NONE)
+ {
+ png_bytep rp;
+ png_uint_32 sum = 0;
+ png_uint_32 i;
+ int v;
+
+ for (i = 0, rp = row_buf + 1; i < row_bytes; i++, rp++)
+ {
+ v = *rp;
+ sum += (v < 128) ? v : 256 - v;
+ }
+
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
+ if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
+ {
+ png_uint_32 sumhi, sumlo;
+ int j;
+ sumlo = sum & PNG_LOMASK;
+ sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; /* Gives us some footroom */
+
+ /* Reduce the sum if we match any of the previous rows */
+ for (j = 0; j < num_p_filters; j++)
+ {
+ if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE)
+ {
+ sumlo = (sumlo * png_ptr->filter_weights[j]) >>
+ PNG_WEIGHT_SHIFT;
+ sumhi = (sumhi * png_ptr->filter_weights[j]) >>
+ PNG_WEIGHT_SHIFT;
+ }
+ }
+
+ /* Factor in the cost of this filter (this is here for completeness,
+ * but it makes no sense to have a "cost" for the NONE filter, as
+ * it has the minimum possible computational cost - none).
+ */
+ sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >>
+ PNG_COST_SHIFT;
+ sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >>
+ PNG_COST_SHIFT;
+
+ if (sumhi > PNG_HIMASK)
+ sum = PNG_MAXSUM;
+ else
+ sum = (sumhi << PNG_HISHIFT) + sumlo;
+ }
+#endif
+ mins = sum;
+ }
+
+ /* sub filter */
+ if (filter_to_do == PNG_FILTER_SUB)
+ /* it's the only filter so no testing is needed */
+ {
+ png_bytep rp, lp, dp;
+ png_uint_32 i;
+ for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp;
+ i++, rp++, dp++)
+ {
+ *dp = *rp;
+ }
+ for (lp = row_buf + 1; i < row_bytes;
+ i++, rp++, lp++, dp++)
+ {
+ *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);
+ }
+ best_row = png_ptr->sub_row;
+ }
+
+ else if (filter_to_do & PNG_FILTER_SUB)
+ {
+ png_bytep rp, dp, lp;
+ png_uint_32 sum = 0, lmins = mins;
+ png_uint_32 i;
+ int v;
+
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
+ /* We temporarily increase the "minimum sum" by the factor we
+ * would reduce the sum of this filter, so that we can do the
+ * early exit comparison without scaling the sum each time.
+ */
+ if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
+ {
+ int j;
+ png_uint_32 lmhi, lmlo;
+ lmlo = lmins & PNG_LOMASK;
+ lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
+
+ for (j = 0; j < num_p_filters; j++)
+ {
+ if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB)
+ {
+ lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
+ PNG_WEIGHT_SHIFT;
+ lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
+ PNG_WEIGHT_SHIFT;
+ }
+ }
+
+ lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
+ PNG_COST_SHIFT;
+ lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
+ PNG_COST_SHIFT;
+
+ if (lmhi > PNG_HIMASK)
+ lmins = PNG_MAXSUM;
+ else
+ lmins = (lmhi << PNG_HISHIFT) + lmlo;
+ }
+#endif
+
+ for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp;
+ i++, rp++, dp++)
+ {
+ v = *dp = *rp;
+
+ sum += (v < 128) ? v : 256 - v;
+ }
+ for (lp = row_buf + 1; i < row_bytes;
+ i++, rp++, lp++, dp++)
+ {
+ v = *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);
+
+ sum += (v < 128) ? v : 256 - v;
+
+ if (sum > lmins) /* We are already worse, don't continue. */
+ break;
+ }
+
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
+ if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
+ {
+ int j;
+ png_uint_32 sumhi, sumlo;
+ sumlo = sum & PNG_LOMASK;
+ sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
+
+ for (j = 0; j < num_p_filters; j++)
+ {
+ if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB)
+ {
+ sumlo = (sumlo * png_ptr->inv_filter_weights[j]) >>
+ PNG_WEIGHT_SHIFT;
+ sumhi = (sumhi * png_ptr->inv_filter_weights[j]) >>
+ PNG_WEIGHT_SHIFT;
+ }
+ }
+
+ sumlo = (sumlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
+ PNG_COST_SHIFT;
+ sumhi = (sumhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
+ PNG_COST_SHIFT;
+
+ if (sumhi > PNG_HIMASK)
+ sum = PNG_MAXSUM;
+ else
+ sum = (sumhi << PNG_HISHIFT) + sumlo;
+ }
+#endif
+
+ if (sum < mins)
+ {
+ mins = sum;
+ best_row = png_ptr->sub_row;
+ }
+ }
+
+ /* up filter */
+ if (filter_to_do == PNG_FILTER_UP)
+ {
+ png_bytep rp, dp, pp;
+ png_uint_32 i;
+
+ for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1,
+ pp = prev_row + 1; i < row_bytes;
+ i++, rp++, pp++, dp++)
+ {
+ *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff);
+ }
+ best_row = png_ptr->up_row;
+ }
+
+ else if (filter_to_do & PNG_FILTER_UP)
+ {
+ png_bytep rp, dp, pp;
+ png_uint_32 sum = 0, lmins = mins;
+ png_uint_32 i;
+ int v;
+
+
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
+ if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
+ {
+ int j;
+ png_uint_32 lmhi, lmlo;
+ lmlo = lmins & PNG_LOMASK;
+ lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
+
+ for (j = 0; j < num_p_filters; j++)
+ {
+ if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP)
+ {
+ lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
+ PNG_WEIGHT_SHIFT;
+ lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
+ PNG_WEIGHT_SHIFT;
+ }
+ }
+
+ lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >>
+ PNG_COST_SHIFT;
+ lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >>
+ PNG_COST_SHIFT;
+
+ if (lmhi > PNG_HIMASK)
+ lmins = PNG_MAXSUM;
+ else
+ lmins = (lmhi << PNG_HISHIFT) + lmlo;
+ }
+#endif
+
+ for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1,
+ pp = prev_row + 1; i < row_bytes; i++)
+ {
+ v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
+
+ sum += (v < 128) ? v : 256 - v;
+
+ if (sum > lmins) /* We are already worse, don't continue. */
+ break;
+ }
+
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
+ if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
+ {
+ int j;
+ png_uint_32 sumhi, sumlo;
+ sumlo = sum & PNG_LOMASK;
+ sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
+
+ for (j = 0; j < num_p_filters; j++)
+ {
+ if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP)
+ {
+ sumlo = (sumlo * png_ptr->filter_weights[j]) >>
+ PNG_WEIGHT_SHIFT;
+ sumhi = (sumhi * png_ptr->filter_weights[j]) >>
+ PNG_WEIGHT_SHIFT;
+ }
+ }
+
+ sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >>
+ PNG_COST_SHIFT;
+ sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >>
+ PNG_COST_SHIFT;
+
+ if (sumhi > PNG_HIMASK)
+ sum = PNG_MAXSUM;
+ else
+ sum = (sumhi << PNG_HISHIFT) + sumlo;
+ }
+#endif
+
+ if (sum < mins)
+ {
+ mins = sum;
+ best_row = png_ptr->up_row;
+ }
+ }
+
+ /* avg filter */
+ if (filter_to_do == PNG_FILTER_AVG)
+ {
+ png_bytep rp, dp, pp, lp;
+ png_uint_32 i;
+ for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1,
+ pp = prev_row + 1; i < bpp; i++)
+ {
+ *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);
+ }
+ for (lp = row_buf + 1; i < row_bytes; i++)
+ {
+ *dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2))
+ & 0xff);
+ }
+ best_row = png_ptr->avg_row;
+ }
+
+ else if (filter_to_do & PNG_FILTER_AVG)
+ {
+ png_bytep rp, dp, pp, lp;
+ png_uint_32 sum = 0, lmins = mins;
+ png_uint_32 i;
+ int v;
+
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
+ if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
+ {
+ int j;
+ png_uint_32 lmhi, lmlo;
+ lmlo = lmins & PNG_LOMASK;
+ lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
+
+ for (j = 0; j < num_p_filters; j++)
+ {
+ if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_AVG)
+ {
+ lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
+ PNG_WEIGHT_SHIFT;
+ lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
+ PNG_WEIGHT_SHIFT;
+ }
+ }
+
+ lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >>
+ PNG_COST_SHIFT;
+ lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >>
+ PNG_COST_SHIFT;
+
+ if (lmhi > PNG_HIMASK)
+ lmins = PNG_MAXSUM;
+ else
+ lmins = (lmhi << PNG_HISHIFT) + lmlo;
+ }
+#endif
+
+ for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1,
+ pp = prev_row + 1; i < bpp; i++)
+ {
+ v = *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);
+
+ sum += (v < 128) ? v : 256 - v;
+ }
+ for (lp = row_buf + 1; i < row_bytes; i++)
+ {
+ v = *dp++ =
+ (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) & 0xff);
+
+ sum += (v < 128) ? v : 256 - v;
+
+ if (sum > lmins) /* We are already worse, don't continue. */
+ break;
+ }
+
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
+ if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
+ {
+ int j;
+ png_uint_32 sumhi, sumlo;
+ sumlo = sum & PNG_LOMASK;
+ sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
+
+ for (j = 0; j < num_p_filters; j++)
+ {
+ if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE)
+ {
+ sumlo = (sumlo * png_ptr->filter_weights[j]) >>
+ PNG_WEIGHT_SHIFT;
+ sumhi = (sumhi * png_ptr->filter_weights[j]) >>
+ PNG_WEIGHT_SHIFT;
+ }
+ }
+
+ sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >>
+ PNG_COST_SHIFT;
+ sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >>
+ PNG_COST_SHIFT;
+
+ if (sumhi > PNG_HIMASK)
+ sum = PNG_MAXSUM;
+ else
+ sum = (sumhi << PNG_HISHIFT) + sumlo;
+ }
+#endif
+
+ if (sum < mins)
+ {
+ mins = sum;
+ best_row = png_ptr->avg_row;
+ }
+ }
+
+ /* Paeth filter */
+ if (filter_to_do == PNG_FILTER_PAETH)
+ {
+ png_bytep rp, dp, pp, cp, lp;
+ png_uint_32 i;
+ for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1,
+ pp = prev_row + 1; i < bpp; i++)
+ {
+ *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
+ }
+
+ for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++)
+ {
+ int a, b, c, pa, pb, pc, p;
+
+ b = *pp++;
+ c = *cp++;
+ a = *lp++;
+
+ p = b - c;
+ pc = a - c;
+
+#ifdef PNG_USE_ABS
+ pa = abs(p);
+ pb = abs(pc);
+ pc = abs(p + pc);
+#else
+ pa = p < 0 ? -p : p;
+ pb = pc < 0 ? -pc : pc;
+ pc = (p + pc) < 0 ? -(p + pc) : p + pc;
+#endif
+
+ p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;
+
+ *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);
+ }
+ best_row = png_ptr->paeth_row;
+ }
+
+ else if (filter_to_do & PNG_FILTER_PAETH)
+ {
+ png_bytep rp, dp, pp, cp, lp;
+ png_uint_32 sum = 0, lmins = mins;
+ png_uint_32 i;
+ int v;
+
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
+ if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
+ {
+ int j;
+ png_uint_32 lmhi, lmlo;
+ lmlo = lmins & PNG_LOMASK;
+ lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
+
+ for (j = 0; j < num_p_filters; j++)
+ {
+ if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH)
+ {
+ lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
+ PNG_WEIGHT_SHIFT;
+ lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
+ PNG_WEIGHT_SHIFT;
+ }
+ }
+
+ lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >>
+ PNG_COST_SHIFT;
+ lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >>
+ PNG_COST_SHIFT;
+
+ if (lmhi > PNG_HIMASK)
+ lmins = PNG_MAXSUM;
+ else
+ lmins = (lmhi << PNG_HISHIFT) + lmlo;
+ }
+#endif
+
+ for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1,
+ pp = prev_row + 1; i < bpp; i++)
+ {
+ v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
+
+ sum += (v < 128) ? v : 256 - v;
+ }
+
+ for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++)
+ {
+ int a, b, c, pa, pb, pc, p;
+
+ b = *pp++;
+ c = *cp++;
+ a = *lp++;
+
+#ifndef PNG_SLOW_PAETH
+ p = b - c;
+ pc = a - c;
+#ifdef PNG_USE_ABS
+ pa = abs(p);
+ pb = abs(pc);
+ pc = abs(p + pc);
+#else
+ pa = p < 0 ? -p : p;
+ pb = pc < 0 ? -pc : pc;
+ pc = (p + pc) < 0 ? -(p + pc) : p + pc;
+#endif
+ p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;
+#else /* PNG_SLOW_PAETH */
+ p = a + b - c;
+ pa = abs(p - a);
+ pb = abs(p - b);
+ pc = abs(p - c);
+ if (pa <= pb && pa <= pc)
+ p = a;
+ else if (pb <= pc)
+ p = b;
+ else
+ p = c;
+#endif /* PNG_SLOW_PAETH */
+
+ v = *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);
+
+ sum += (v < 128) ? v : 256 - v;
+
+ if (sum > lmins) /* We are already worse, don't continue. */
+ break;
+ }
+
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
+ if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
+ {
+ int j;
+ png_uint_32 sumhi, sumlo;
+ sumlo = sum & PNG_LOMASK;
+ sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
+
+ for (j = 0; j < num_p_filters; j++)
+ {
+ if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH)
+ {
+ sumlo = (sumlo * png_ptr->filter_weights[j]) >>
+ PNG_WEIGHT_SHIFT;
+ sumhi = (sumhi * png_ptr->filter_weights[j]) >>
+ PNG_WEIGHT_SHIFT;
+ }
+ }
+
+ sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >>
+ PNG_COST_SHIFT;
+ sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >>
+ PNG_COST_SHIFT;
+
+ if (sumhi > PNG_HIMASK)
+ sum = PNG_MAXSUM;
+ else
+ sum = (sumhi << PNG_HISHIFT) + sumlo;
+ }
+#endif
+
+ if (sum < mins)
+ {
+ best_row = png_ptr->paeth_row;
+ }
+ }
+#endif /* PNG_NO_WRITE_FILTER */
+ /* Do the actual writing of the filtered row data from the chosen filter. */
+
+ png_write_filtered_row(png_ptr, best_row);
+
+#ifndef PNG_NO_WRITE_FILTER
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
+ /* Save the type of filter we picked this time for future calculations */
+ if (png_ptr->num_prev_filters > 0)
+ {
+ int j;
+ for (j = 1; j < num_p_filters; j++)
+ {
+ png_ptr->prev_filters[j] = png_ptr->prev_filters[j - 1];
+ }
+ png_ptr->prev_filters[j] = best_row[0];
+ }
+#endif
+#endif /* PNG_NO_WRITE_FILTER */
+}
+
+
+/* Do the actual writing of a previously filtered row. */
+void /* PRIVATE */
+png_write_filtered_row(png_structp png_ptr, png_bytep filtered_row)
+{
+ png_debug(1, "in png_write_filtered_row\n");
+ png_debug1(2, "filter = %d\n", filtered_row[0]);
+ /* set up the zlib input buffer */
+
+ png_ptr->zstream.next_in = filtered_row;
+ png_ptr->zstream.avail_in = (uInt)png_ptr->row_info.rowbytes + 1;
+ /* repeat until we have compressed all the data */
+ do
+ {
+ int ret; /* return of zlib */
+
+ /* compress the data */
+ ret = deflate(&png_ptr->zstream, Z_NO_FLUSH);
+ /* check for compression errors */
+ if (ret != Z_OK)
+ {
+ if (png_ptr->zstream.msg != NULL)
+ png_error(png_ptr, png_ptr->zstream.msg);
+ else
+ png_error(png_ptr, "zlib error");
+ }
+
+ /* see if it is time to write another IDAT */
+ if (!(png_ptr->zstream.avail_out))
+ {
+ /* write the IDAT and reset the zlib output buffer */
+ png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
+ png_ptr->zstream.next_out = png_ptr->zbuf;
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+ }
+ /* repeat until all data has been compressed */
+ } while (png_ptr->zstream.avail_in);
+
+ /* swap the current and previous rows */
+ if (png_ptr->prev_row != NULL)
+ {
+ png_bytep tptr;
+
+ tptr = png_ptr->prev_row;
+ png_ptr->prev_row = png_ptr->row_buf;
+ png_ptr->row_buf = tptr;
+ }
+
+ /* finish row - updates counters and flushes zlib if last row */
+ png_write_finish_row(png_ptr);
+
+#if defined(PNG_WRITE_FLUSH_SUPPORTED)
+ png_ptr->flush_rows++;
+
+ if (png_ptr->flush_dist > 0 &&
+ png_ptr->flush_rows >= png_ptr->flush_dist)
+ {
+ png_write_flush(png_ptr);
+ }
+#endif
+}
+#endif /* PNG_WRITE_SUPPORTED */
--- /dev/null
+Monty <monty@xiph.org>
+Greg Maxwell <greg@xiph.org>
+Ralph Giles <giles@xiph.org>
+Cristian Adam <cristian.adam@gmail.com>
+Tim Terriberry <tterribe@xiph.org>
+
+and the rest of the Xiph.Org Foundation.
--- /dev/null
+Copyright (c) 2002, Xiph.org Foundation
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+- Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+- Neither the name of the Xiph.org Foundation nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--- /dev/null
+obj = bitwise.o framing.o
+
+liba = ../libogg.a
+
+CFLAGS = -O3
+
+$(liba): $(obj)
+ $(AR) rcs $@ $(obj)
+
+.PHONY: clean
+clean:
+ rm -f $(obj) $(liba)
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE Ogg CONTAINER SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2010 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: packing variable sized words into an octet stream
+ last mod: $Id: bitwise.c 18051 2011-08-04 17:56:39Z giles $
+
+ ********************************************************************/
+
+/* We're 'LSb' endian; if we write a word but read individual bits,
+ then we'll read the lsb first */
+
+#include <string.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <ogg/ogg.h>
+
+#define BUFFER_INCREMENT 256
+
+static const unsigned long mask[]=
+{0x00000000,0x00000001,0x00000003,0x00000007,0x0000000f,
+ 0x0000001f,0x0000003f,0x0000007f,0x000000ff,0x000001ff,
+ 0x000003ff,0x000007ff,0x00000fff,0x00001fff,0x00003fff,
+ 0x00007fff,0x0000ffff,0x0001ffff,0x0003ffff,0x0007ffff,
+ 0x000fffff,0x001fffff,0x003fffff,0x007fffff,0x00ffffff,
+ 0x01ffffff,0x03ffffff,0x07ffffff,0x0fffffff,0x1fffffff,
+ 0x3fffffff,0x7fffffff,0xffffffff };
+
+static const unsigned int mask8B[]=
+{0x00,0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff};
+
+void oggpack_writeinit(oggpack_buffer *b){
+ memset(b,0,sizeof(*b));
+ b->ptr=b->buffer=_ogg_malloc(BUFFER_INCREMENT);
+ b->buffer[0]='\0';
+ b->storage=BUFFER_INCREMENT;
+}
+
+void oggpackB_writeinit(oggpack_buffer *b){
+ oggpack_writeinit(b);
+}
+
+int oggpack_writecheck(oggpack_buffer *b){
+ if(!b->ptr || !b->storage)return -1;
+ return 0;
+}
+
+int oggpackB_writecheck(oggpack_buffer *b){
+ return oggpack_writecheck(b);
+}
+
+void oggpack_writetrunc(oggpack_buffer *b,long bits){
+ long bytes=bits>>3;
+ if(b->ptr){
+ bits-=bytes*8;
+ b->ptr=b->buffer+bytes;
+ b->endbit=bits;
+ b->endbyte=bytes;
+ *b->ptr&=mask[bits];
+ }
+}
+
+void oggpackB_writetrunc(oggpack_buffer *b,long bits){
+ long bytes=bits>>3;
+ if(b->ptr){
+ bits-=bytes*8;
+ b->ptr=b->buffer+bytes;
+ b->endbit=bits;
+ b->endbyte=bytes;
+ *b->ptr&=mask8B[bits];
+ }
+}
+
+/* Takes only up to 32 bits. */
+void oggpack_write(oggpack_buffer *b,unsigned long value,int bits){
+ if(bits<0 || bits>32) goto err;
+ if(b->endbyte>=b->storage-4){
+ void *ret;
+ if(!b->ptr)return;
+ if(b->storage>LONG_MAX-BUFFER_INCREMENT) goto err;
+ ret=_ogg_realloc(b->buffer,b->storage+BUFFER_INCREMENT);
+ if(!ret) goto err;
+ b->buffer=ret;
+ b->storage+=BUFFER_INCREMENT;
+ b->ptr=b->buffer+b->endbyte;
+ }
+
+ value&=mask[bits];
+ bits+=b->endbit;
+
+ b->ptr[0]|=value<<b->endbit;
+
+ if(bits>=8){
+ b->ptr[1]=(unsigned char)(value>>(8-b->endbit));
+ if(bits>=16){
+ b->ptr[2]=(unsigned char)(value>>(16-b->endbit));
+ if(bits>=24){
+ b->ptr[3]=(unsigned char)(value>>(24-b->endbit));
+ if(bits>=32){
+ if(b->endbit)
+ b->ptr[4]=(unsigned char)(value>>(32-b->endbit));
+ else
+ b->ptr[4]=0;
+ }
+ }
+ }
+ }
+
+ b->endbyte+=bits/8;
+ b->ptr+=bits/8;
+ b->endbit=bits&7;
+ return;
+ err:
+ oggpack_writeclear(b);
+}
+
+/* Takes only up to 32 bits. */
+void oggpackB_write(oggpack_buffer *b,unsigned long value,int bits){
+ if(bits<0 || bits>32) goto err;
+ if(b->endbyte>=b->storage-4){
+ void *ret;
+ if(!b->ptr)return;
+ if(b->storage>LONG_MAX-BUFFER_INCREMENT) goto err;
+ ret=_ogg_realloc(b->buffer,b->storage+BUFFER_INCREMENT);
+ if(!ret) goto err;
+ b->buffer=ret;
+ b->storage+=BUFFER_INCREMENT;
+ b->ptr=b->buffer+b->endbyte;
+ }
+
+ value=(value&mask[bits])<<(32-bits);
+ bits+=b->endbit;
+
+ b->ptr[0]|=value>>(24+b->endbit);
+
+ if(bits>=8){
+ b->ptr[1]=(unsigned char)(value>>(16+b->endbit));
+ if(bits>=16){
+ b->ptr[2]=(unsigned char)(value>>(8+b->endbit));
+ if(bits>=24){
+ b->ptr[3]=(unsigned char)(value>>(b->endbit));
+ if(bits>=32){
+ if(b->endbit)
+ b->ptr[4]=(unsigned char)(value<<(8-b->endbit));
+ else
+ b->ptr[4]=0;
+ }
+ }
+ }
+ }
+
+ b->endbyte+=bits/8;
+ b->ptr+=bits/8;
+ b->endbit=bits&7;
+ return;
+ err:
+ oggpack_writeclear(b);
+}
+
+void oggpack_writealign(oggpack_buffer *b){
+ int bits=8-b->endbit;
+ if(bits<8)
+ oggpack_write(b,0,bits);
+}
+
+void oggpackB_writealign(oggpack_buffer *b){
+ int bits=8-b->endbit;
+ if(bits<8)
+ oggpackB_write(b,0,bits);
+}
+
+static void oggpack_writecopy_helper(oggpack_buffer *b,
+ void *source,
+ long bits,
+ void (*w)(oggpack_buffer *,
+ unsigned long,
+ int),
+ int msb){
+ unsigned char *ptr=(unsigned char *)source;
+
+ long bytes=bits/8;
+ bits-=bytes*8;
+
+ if(b->endbit){
+ int i;
+ /* unaligned copy. Do it the hard way. */
+ for(i=0;i<bytes;i++)
+ w(b,(unsigned long)(ptr[i]),8);
+ }else{
+ /* aligned block copy */
+ if(b->endbyte+bytes+1>=b->storage){
+ void *ret;
+ if(!b->ptr) goto err;
+ if(b->endbyte+bytes+BUFFER_INCREMENT>b->storage) goto err;
+ b->storage=b->endbyte+bytes+BUFFER_INCREMENT;
+ ret=_ogg_realloc(b->buffer,b->storage);
+ if(!ret) goto err;
+ b->buffer=ret;
+ b->ptr=b->buffer+b->endbyte;
+ }
+
+ memmove(b->ptr,source,bytes);
+ b->ptr+=bytes;
+ b->endbyte+=bytes;
+ *b->ptr=0;
+
+ }
+ if(bits){
+ if(msb)
+ w(b,(unsigned long)(ptr[bytes]>>(8-bits)),bits);
+ else
+ w(b,(unsigned long)(ptr[bytes]),bits);
+ }
+ return;
+ err:
+ oggpack_writeclear(b);
+}
+
+void oggpack_writecopy(oggpack_buffer *b,void *source,long bits){
+ oggpack_writecopy_helper(b,source,bits,oggpack_write,0);
+}
+
+void oggpackB_writecopy(oggpack_buffer *b,void *source,long bits){
+ oggpack_writecopy_helper(b,source,bits,oggpackB_write,1);
+}
+
+void oggpack_reset(oggpack_buffer *b){
+ if(!b->ptr)return;
+ b->ptr=b->buffer;
+ b->buffer[0]=0;
+ b->endbit=b->endbyte=0;
+}
+
+void oggpackB_reset(oggpack_buffer *b){
+ oggpack_reset(b);
+}
+
+void oggpack_writeclear(oggpack_buffer *b){
+ if(b->buffer)_ogg_free(b->buffer);
+ memset(b,0,sizeof(*b));
+}
+
+void oggpackB_writeclear(oggpack_buffer *b){
+ oggpack_writeclear(b);
+}
+
+void oggpack_readinit(oggpack_buffer *b,unsigned char *buf,int bytes){
+ memset(b,0,sizeof(*b));
+ b->buffer=b->ptr=buf;
+ b->storage=bytes;
+}
+
+void oggpackB_readinit(oggpack_buffer *b,unsigned char *buf,int bytes){
+ oggpack_readinit(b,buf,bytes);
+}
+
+/* Read in bits without advancing the bitptr; bits <= 32 */
+long oggpack_look(oggpack_buffer *b,int bits){
+ unsigned long ret;
+ unsigned long m;
+
+ if(bits<0 || bits>32) return -1;
+ m=mask[bits];
+ bits+=b->endbit;
+
+ if(b->endbyte >= b->storage-4){
+ /* not the main path */
+ if(b->endbyte > b->storage-((bits+7)>>3)) return -1;
+ /* special case to avoid reading b->ptr[0], which might be past the end of
+ the buffer; also skips some useless accounting */
+ else if(!bits)return(0L);
+ }
+
+ ret=b->ptr[0]>>b->endbit;
+ if(bits>8){
+ ret|=b->ptr[1]<<(8-b->endbit);
+ if(bits>16){
+ ret|=b->ptr[2]<<(16-b->endbit);
+ if(bits>24){
+ ret|=b->ptr[3]<<(24-b->endbit);
+ if(bits>32 && b->endbit)
+ ret|=b->ptr[4]<<(32-b->endbit);
+ }
+ }
+ }
+ return(m&ret);
+}
+
+/* Read in bits without advancing the bitptr; bits <= 32 */
+long oggpackB_look(oggpack_buffer *b,int bits){
+ unsigned long ret;
+ int m=32-bits;
+
+ if(m<0 || m>32) return -1;
+ bits+=b->endbit;
+
+ if(b->endbyte >= b->storage-4){
+ /* not the main path */
+ if(b->endbyte > b->storage-((bits+7)>>3)) return -1;
+ /* special case to avoid reading b->ptr[0], which might be past the end of
+ the buffer; also skips some useless accounting */
+ else if(!bits)return(0L);
+ }
+
+ ret=b->ptr[0]<<(24+b->endbit);
+ if(bits>8){
+ ret|=b->ptr[1]<<(16+b->endbit);
+ if(bits>16){
+ ret|=b->ptr[2]<<(8+b->endbit);
+ if(bits>24){
+ ret|=b->ptr[3]<<(b->endbit);
+ if(bits>32 && b->endbit)
+ ret|=b->ptr[4]>>(8-b->endbit);
+ }
+ }
+ }
+ return ((ret&0xffffffff)>>(m>>1))>>((m+1)>>1);
+}
+
+long oggpack_look1(oggpack_buffer *b){
+ if(b->endbyte>=b->storage)return(-1);
+ return((b->ptr[0]>>b->endbit)&1);
+}
+
+long oggpackB_look1(oggpack_buffer *b){
+ if(b->endbyte>=b->storage)return(-1);
+ return((b->ptr[0]>>(7-b->endbit))&1);
+}
+
+void oggpack_adv(oggpack_buffer *b,int bits){
+ bits+=b->endbit;
+
+ if(b->endbyte > b->storage-((bits+7)>>3)) goto overflow;
+
+ b->ptr+=bits/8;
+ b->endbyte+=bits/8;
+ b->endbit=bits&7;
+ return;
+
+ overflow:
+ b->ptr=NULL;
+ b->endbyte=b->storage;
+ b->endbit=1;
+}
+
+void oggpackB_adv(oggpack_buffer *b,int bits){
+ oggpack_adv(b,bits);
+}
+
+void oggpack_adv1(oggpack_buffer *b){
+ if(++(b->endbit)>7){
+ b->endbit=0;
+ b->ptr++;
+ b->endbyte++;
+ }
+}
+
+void oggpackB_adv1(oggpack_buffer *b){
+ oggpack_adv1(b);
+}
+
+/* bits <= 32 */
+long oggpack_read(oggpack_buffer *b,int bits){
+ long ret;
+ unsigned long m;
+
+ if(bits<0 || bits>32) goto err;
+ m=mask[bits];
+ bits+=b->endbit;
+
+ if(b->endbyte >= b->storage-4){
+ /* not the main path */
+ if(b->endbyte > b->storage-((bits+7)>>3)) goto overflow;
+ /* special case to avoid reading b->ptr[0], which might be past the end of
+ the buffer; also skips some useless accounting */
+ else if(!bits)return(0L);
+ }
+
+ ret=b->ptr[0]>>b->endbit;
+ if(bits>8){
+ ret|=b->ptr[1]<<(8-b->endbit);
+ if(bits>16){
+ ret|=b->ptr[2]<<(16-b->endbit);
+ if(bits>24){
+ ret|=b->ptr[3]<<(24-b->endbit);
+ if(bits>32 && b->endbit){
+ ret|=b->ptr[4]<<(32-b->endbit);
+ }
+ }
+ }
+ }
+ ret&=m;
+ b->ptr+=bits/8;
+ b->endbyte+=bits/8;
+ b->endbit=bits&7;
+ return ret;
+
+ overflow:
+ err:
+ b->ptr=NULL;
+ b->endbyte=b->storage;
+ b->endbit=1;
+ return -1L;
+}
+
+/* bits <= 32 */
+long oggpackB_read(oggpack_buffer *b,int bits){
+ long ret;
+ long m=32-bits;
+
+ if(m<0 || m>32) goto err;
+ bits+=b->endbit;
+
+ if(b->endbyte+4>=b->storage){
+ /* not the main path */
+ if(b->endbyte > b->storage-((bits+7)>>3)) goto overflow;
+ /* special case to avoid reading b->ptr[0], which might be past the end of
+ the buffer; also skips some useless accounting */
+ else if(!bits)return(0L);
+ }
+
+ ret=b->ptr[0]<<(24+b->endbit);
+ if(bits>8){
+ ret|=b->ptr[1]<<(16+b->endbit);
+ if(bits>16){
+ ret|=b->ptr[2]<<(8+b->endbit);
+ if(bits>24){
+ ret|=b->ptr[3]<<(b->endbit);
+ if(bits>32 && b->endbit)
+ ret|=b->ptr[4]>>(8-b->endbit);
+ }
+ }
+ }
+ ret=((ret&0xffffffffUL)>>(m>>1))>>((m+1)>>1);
+
+ b->ptr+=bits/8;
+ b->endbyte+=bits/8;
+ b->endbit=bits&7;
+ return ret;
+
+ overflow:
+ err:
+ b->ptr=NULL;
+ b->endbyte=b->storage;
+ b->endbit=1;
+ return -1L;
+}
+
+long oggpack_read1(oggpack_buffer *b){
+ long ret;
+
+ if(b->endbyte >= b->storage) goto overflow;
+ ret=(b->ptr[0]>>b->endbit)&1;
+
+ b->endbit++;
+ if(b->endbit>7){
+ b->endbit=0;
+ b->ptr++;
+ b->endbyte++;
+ }
+ return ret;
+
+ overflow:
+ b->ptr=NULL;
+ b->endbyte=b->storage;
+ b->endbit=1;
+ return -1L;
+}
+
+long oggpackB_read1(oggpack_buffer *b){
+ long ret;
+
+ if(b->endbyte >= b->storage) goto overflow;
+ ret=(b->ptr[0]>>(7-b->endbit))&1;
+
+ b->endbit++;
+ if(b->endbit>7){
+ b->endbit=0;
+ b->ptr++;
+ b->endbyte++;
+ }
+ return ret;
+
+ overflow:
+ b->ptr=NULL;
+ b->endbyte=b->storage;
+ b->endbit=1;
+ return -1L;
+}
+
+long oggpack_bytes(oggpack_buffer *b){
+ return(b->endbyte+(b->endbit+7)/8);
+}
+
+long oggpack_bits(oggpack_buffer *b){
+ return(b->endbyte*8+b->endbit);
+}
+
+long oggpackB_bytes(oggpack_buffer *b){
+ return oggpack_bytes(b);
+}
+
+long oggpackB_bits(oggpack_buffer *b){
+ return oggpack_bits(b);
+}
+
+unsigned char *oggpack_get_buffer(oggpack_buffer *b){
+ return(b->buffer);
+}
+
+unsigned char *oggpackB_get_buffer(oggpack_buffer *b){
+ return oggpack_get_buffer(b);
+}
+
+/* Self test of the bitwise routines; everything else is based on
+ them, so they damned well better be solid. */
+
+#ifdef _V_SELFTEST
+#include <stdio.h>
+
+static int ilog(unsigned int v){
+ int ret=0;
+ while(v){
+ ret++;
+ v>>=1;
+ }
+ return(ret);
+}
+
+oggpack_buffer o;
+oggpack_buffer r;
+
+void report(char *in){
+ fprintf(stderr,"%s",in);
+ exit(1);
+}
+
+void cliptest(unsigned long *b,int vals,int bits,int *comp,int compsize){
+ long bytes,i;
+ unsigned char *buffer;
+
+ oggpack_reset(&o);
+ for(i=0;i<vals;i++)
+ oggpack_write(&o,b[i],bits?bits:ilog(b[i]));
+ buffer=oggpack_get_buffer(&o);
+ bytes=oggpack_bytes(&o);
+ if(bytes!=compsize)report("wrong number of bytes!\n");
+ for(i=0;i<bytes;i++)if(buffer[i]!=comp[i]){
+ for(i=0;i<bytes;i++)fprintf(stderr,"%x %x\n",(int)buffer[i],(int)comp[i]);
+ report("wrote incorrect value!\n");
+ }
+ oggpack_readinit(&r,buffer,bytes);
+ for(i=0;i<vals;i++){
+ int tbit=bits?bits:ilog(b[i]);
+ if(oggpack_look(&r,tbit)==-1)
+ report("out of data!\n");
+ if(oggpack_look(&r,tbit)!=(b[i]&mask[tbit]))
+ report("looked at incorrect value!\n");
+ if(tbit==1)
+ if(oggpack_look1(&r)!=(b[i]&mask[tbit]))
+ report("looked at single bit incorrect value!\n");
+ if(tbit==1){
+ if(oggpack_read1(&r)!=(b[i]&mask[tbit]))
+ report("read incorrect single bit value!\n");
+ }else{
+ if(oggpack_read(&r,tbit)!=(b[i]&mask[tbit]))
+ report("read incorrect value!\n");
+ }
+ }
+ if(oggpack_bytes(&r)!=bytes)report("leftover bytes after read!\n");
+}
+
+void cliptestB(unsigned long *b,int vals,int bits,int *comp,int compsize){
+ long bytes,i;
+ unsigned char *buffer;
+
+ oggpackB_reset(&o);
+ for(i=0;i<vals;i++)
+ oggpackB_write(&o,b[i],bits?bits:ilog(b[i]));
+ buffer=oggpackB_get_buffer(&o);
+ bytes=oggpackB_bytes(&o);
+ if(bytes!=compsize)report("wrong number of bytes!\n");
+ for(i=0;i<bytes;i++)if(buffer[i]!=comp[i]){
+ for(i=0;i<bytes;i++)fprintf(stderr,"%x %x\n",(int)buffer[i],(int)comp[i]);
+ report("wrote incorrect value!\n");
+ }
+ oggpackB_readinit(&r,buffer,bytes);
+ for(i=0;i<vals;i++){
+ int tbit=bits?bits:ilog(b[i]);
+ if(oggpackB_look(&r,tbit)==-1)
+ report("out of data!\n");
+ if(oggpackB_look(&r,tbit)!=(b[i]&mask[tbit]))
+ report("looked at incorrect value!\n");
+ if(tbit==1)
+ if(oggpackB_look1(&r)!=(b[i]&mask[tbit]))
+ report("looked at single bit incorrect value!\n");
+ if(tbit==1){
+ if(oggpackB_read1(&r)!=(b[i]&mask[tbit]))
+ report("read incorrect single bit value!\n");
+ }else{
+ if(oggpackB_read(&r,tbit)!=(b[i]&mask[tbit]))
+ report("read incorrect value!\n");
+ }
+ }
+ if(oggpackB_bytes(&r)!=bytes)report("leftover bytes after read!\n");
+}
+
+int main(void){
+ unsigned char *buffer;
+ long bytes,i;
+ static unsigned long testbuffer1[]=
+ {18,12,103948,4325,543,76,432,52,3,65,4,56,32,42,34,21,1,23,32,546,456,7,
+ 567,56,8,8,55,3,52,342,341,4,265,7,67,86,2199,21,7,1,5,1,4};
+ int test1size=43;
+
+ static unsigned long testbuffer2[]=
+ {216531625L,1237861823,56732452,131,3212421,12325343,34547562,12313212,
+ 1233432,534,5,346435231,14436467,7869299,76326614,167548585,
+ 85525151,0,12321,1,349528352};
+ int test2size=21;
+
+ static unsigned long testbuffer3[]=
+ {1,0,14,0,1,0,12,0,1,0,0,0,1,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,1,1,1,1,1,0,0,1,
+ 0,1,30,1,1,1,0,0,1,0,0,0,12,0,11,0,1,0,0,1};
+ int test3size=56;
+
+ static unsigned long large[]=
+ {2136531625L,2137861823,56732452,131,3212421,12325343,34547562,12313212,
+ 1233432,534,5,2146435231,14436467,7869299,76326614,167548585,
+ 85525151,0,12321,1,2146528352};
+
+ int onesize=33;
+ static int one[33]={146,25,44,151,195,15,153,176,233,131,196,65,85,172,47,40,
+ 34,242,223,136,35,222,211,86,171,50,225,135,214,75,172,
+ 223,4};
+ static int oneB[33]={150,101,131,33,203,15,204,216,105,193,156,65,84,85,222,
+ 8,139,145,227,126,34,55,244,171,85,100,39,195,173,18,
+ 245,251,128};
+
+ int twosize=6;
+ static int two[6]={61,255,255,251,231,29};
+ static int twoB[6]={247,63,255,253,249,120};
+
+ int threesize=54;
+ static int three[54]={169,2,232,252,91,132,156,36,89,13,123,176,144,32,254,
+ 142,224,85,59,121,144,79,124,23,67,90,90,216,79,23,83,
+ 58,135,196,61,55,129,183,54,101,100,170,37,127,126,10,
+ 100,52,4,14,18,86,77,1};
+ static int threeB[54]={206,128,42,153,57,8,183,251,13,89,36,30,32,144,183,
+ 130,59,240,121,59,85,223,19,228,180,134,33,107,74,98,
+ 233,253,196,135,63,2,110,114,50,155,90,127,37,170,104,
+ 200,20,254,4,58,106,176,144,0};
+
+ int foursize=38;
+ static int four[38]={18,6,163,252,97,194,104,131,32,1,7,82,137,42,129,11,72,
+ 132,60,220,112,8,196,109,64,179,86,9,137,195,208,122,169,
+ 28,2,133,0,1};
+ static int fourB[38]={36,48,102,83,243,24,52,7,4,35,132,10,145,21,2,93,2,41,
+ 1,219,184,16,33,184,54,149,170,132,18,30,29,98,229,67,
+ 129,10,4,32};
+
+ int fivesize=45;
+ static int five[45]={169,2,126,139,144,172,30,4,80,72,240,59,130,218,73,62,
+ 241,24,210,44,4,20,0,248,116,49,135,100,110,130,181,169,
+ 84,75,159,2,1,0,132,192,8,0,0,18,22};
+ static int fiveB[45]={1,84,145,111,245,100,128,8,56,36,40,71,126,78,213,226,
+ 124,105,12,0,133,128,0,162,233,242,67,152,77,205,77,
+ 172,150,169,129,79,128,0,6,4,32,0,27,9,0};
+
+ int sixsize=7;
+ static int six[7]={17,177,170,242,169,19,148};
+ static int sixB[7]={136,141,85,79,149,200,41};
+
+ /* Test read/write together */
+ /* Later we test against pregenerated bitstreams */
+ oggpack_writeinit(&o);
+
+ fprintf(stderr,"\nSmall preclipped packing (LSb): ");
+ cliptest(testbuffer1,test1size,0,one,onesize);
+ fprintf(stderr,"ok.");
+
+ fprintf(stderr,"\nNull bit call (LSb): ");
+ cliptest(testbuffer3,test3size,0,two,twosize);
+ fprintf(stderr,"ok.");
+
+ fprintf(stderr,"\nLarge preclipped packing (LSb): ");
+ cliptest(testbuffer2,test2size,0,three,threesize);
+ fprintf(stderr,"ok.");
+
+ fprintf(stderr,"\n32 bit preclipped packing (LSb): ");
+ oggpack_reset(&o);
+ for(i=0;i<test2size;i++)
+ oggpack_write(&o,large[i],32);
+ buffer=oggpack_get_buffer(&o);
+ bytes=oggpack_bytes(&o);
+ oggpack_readinit(&r,buffer,bytes);
+ for(i=0;i<test2size;i++){
+ if(oggpack_look(&r,32)==-1)report("out of data. failed!");
+ if(oggpack_look(&r,32)!=large[i]){
+ fprintf(stderr,"%ld != %ld (%lx!=%lx):",oggpack_look(&r,32),large[i],
+ oggpack_look(&r,32),large[i]);
+ report("read incorrect value!\n");
+ }
+ oggpack_adv(&r,32);
+ }
+ if(oggpack_bytes(&r)!=bytes)report("leftover bytes after read!\n");
+ fprintf(stderr,"ok.");
+
+ fprintf(stderr,"\nSmall unclipped packing (LSb): ");
+ cliptest(testbuffer1,test1size,7,four,foursize);
+ fprintf(stderr,"ok.");
+
+ fprintf(stderr,"\nLarge unclipped packing (LSb): ");
+ cliptest(testbuffer2,test2size,17,five,fivesize);
+ fprintf(stderr,"ok.");
+
+ fprintf(stderr,"\nSingle bit unclipped packing (LSb): ");
+ cliptest(testbuffer3,test3size,1,six,sixsize);
+ fprintf(stderr,"ok.");
+
+ fprintf(stderr,"\nTesting read past end (LSb): ");
+ oggpack_readinit(&r,(unsigned char *)"\0\0\0\0\0\0\0\0",8);
+ for(i=0;i<64;i++){
+ if(oggpack_read(&r,1)!=0){
+ fprintf(stderr,"failed; got -1 prematurely.\n");
+ exit(1);
+ }
+ }
+ if(oggpack_look(&r,1)!=-1 ||
+ oggpack_read(&r,1)!=-1){
+ fprintf(stderr,"failed; read past end without -1.\n");
+ exit(1);
+ }
+ oggpack_readinit(&r,(unsigned char *)"\0\0\0\0\0\0\0\0",8);
+ if(oggpack_read(&r,30)!=0 || oggpack_read(&r,16)!=0){
+ fprintf(stderr,"failed 2; got -1 prematurely.\n");
+ exit(1);
+ }
+
+ if(oggpack_look(&r,18)!=0 ||
+ oggpack_look(&r,18)!=0){
+ fprintf(stderr,"failed 3; got -1 prematurely.\n");
+ exit(1);
+ }
+ if(oggpack_look(&r,19)!=-1 ||
+ oggpack_look(&r,19)!=-1){
+ fprintf(stderr,"failed; read past end without -1.\n");
+ exit(1);
+ }
+ if(oggpack_look(&r,32)!=-1 ||
+ oggpack_look(&r,32)!=-1){
+ fprintf(stderr,"failed; read past end without -1.\n");
+ exit(1);
+ }
+ oggpack_writeclear(&o);
+ fprintf(stderr,"ok.\n");
+
+ /********** lazy, cut-n-paste retest with MSb packing ***********/
+
+ /* Test read/write together */
+ /* Later we test against pregenerated bitstreams */
+ oggpackB_writeinit(&o);
+
+ fprintf(stderr,"\nSmall preclipped packing (MSb): ");
+ cliptestB(testbuffer1,test1size,0,oneB,onesize);
+ fprintf(stderr,"ok.");
+
+ fprintf(stderr,"\nNull bit call (MSb): ");
+ cliptestB(testbuffer3,test3size,0,twoB,twosize);
+ fprintf(stderr,"ok.");
+
+ fprintf(stderr,"\nLarge preclipped packing (MSb): ");
+ cliptestB(testbuffer2,test2size,0,threeB,threesize);
+ fprintf(stderr,"ok.");
+
+ fprintf(stderr,"\n32 bit preclipped packing (MSb): ");
+ oggpackB_reset(&o);
+ for(i=0;i<test2size;i++)
+ oggpackB_write(&o,large[i],32);
+ buffer=oggpackB_get_buffer(&o);
+ bytes=oggpackB_bytes(&o);
+ oggpackB_readinit(&r,buffer,bytes);
+ for(i=0;i<test2size;i++){
+ if(oggpackB_look(&r,32)==-1)report("out of data. failed!");
+ if(oggpackB_look(&r,32)!=large[i]){
+ fprintf(stderr,"%ld != %ld (%lx!=%lx):",oggpackB_look(&r,32),large[i],
+ oggpackB_look(&r,32),large[i]);
+ report("read incorrect value!\n");
+ }
+ oggpackB_adv(&r,32);
+ }
+ if(oggpackB_bytes(&r)!=bytes)report("leftover bytes after read!\n");
+ fprintf(stderr,"ok.");
+
+ fprintf(stderr,"\nSmall unclipped packing (MSb): ");
+ cliptestB(testbuffer1,test1size,7,fourB,foursize);
+ fprintf(stderr,"ok.");
+
+ fprintf(stderr,"\nLarge unclipped packing (MSb): ");
+ cliptestB(testbuffer2,test2size,17,fiveB,fivesize);
+ fprintf(stderr,"ok.");
+
+ fprintf(stderr,"\nSingle bit unclipped packing (MSb): ");
+ cliptestB(testbuffer3,test3size,1,sixB,sixsize);
+ fprintf(stderr,"ok.");
+
+ fprintf(stderr,"\nTesting read past end (MSb): ");
+ oggpackB_readinit(&r,(unsigned char *)"\0\0\0\0\0\0\0\0",8);
+ for(i=0;i<64;i++){
+ if(oggpackB_read(&r,1)!=0){
+ fprintf(stderr,"failed; got -1 prematurely.\n");
+ exit(1);
+ }
+ }
+ if(oggpackB_look(&r,1)!=-1 ||
+ oggpackB_read(&r,1)!=-1){
+ fprintf(stderr,"failed; read past end without -1.\n");
+ exit(1);
+ }
+ oggpackB_readinit(&r,(unsigned char *)"\0\0\0\0\0\0\0\0",8);
+ if(oggpackB_read(&r,30)!=0 || oggpackB_read(&r,16)!=0){
+ fprintf(stderr,"failed 2; got -1 prematurely.\n");
+ exit(1);
+ }
+
+ if(oggpackB_look(&r,18)!=0 ||
+ oggpackB_look(&r,18)!=0){
+ fprintf(stderr,"failed 3; got -1 prematurely.\n");
+ exit(1);
+ }
+ if(oggpackB_look(&r,19)!=-1 ||
+ oggpackB_look(&r,19)!=-1){
+ fprintf(stderr,"failed; read past end without -1.\n");
+ exit(1);
+ }
+ if(oggpackB_look(&r,32)!=-1 ||
+ oggpackB_look(&r,32)!=-1){
+ fprintf(stderr,"failed; read past end without -1.\n");
+ exit(1);
+ }
+ oggpackB_writeclear(&o);
+ fprintf(stderr,"ok.\n\n");
+
+
+ return(0);
+}
+#endif /* _V_SELFTEST */
+
+#undef BUFFER_INCREMENT
--- /dev/null
+#ifndef __CONFIG_TYPES_H__
+#define __CONFIG_TYPES_H__
+
+/* these are filled in by configure */
+#define INCLUDE_INTTYPES_H 1
+#define INCLUDE_STDINT_H 1
+#define INCLUDE_SYS_TYPES_H 1
+
+#if INCLUDE_INTTYPES_H
+# include <inttypes.h>
+#endif
+#if INCLUDE_STDINT_H
+# include <stdint.h>
+#endif
+#if INCLUDE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+
+typedef int16_t ogg_int16_t;
+typedef uint16_t ogg_uint16_t;
+typedef int32_t ogg_int32_t;
+typedef uint32_t ogg_uint32_t;
+typedef int64_t ogg_int64_t;
+
+#endif
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE Ogg CONTAINER SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2010 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: code raw packets into framed OggSquish stream and
+ decode Ogg streams back into raw packets
+ last mod: $Id: framing.c 18758 2013-01-08 16:29:56Z tterribe $
+
+ note: The CRC code is directly derived from public domain code by
+ Ross Williams (ross@guest.adelaide.edu.au). See docs/framing.html
+ for details.
+
+ ********************************************************************/
+
+#include <stdlib.h>
+#include <limits.h>
+#include <string.h>
+#include <ogg/ogg.h>
+
+/* A complete description of Ogg framing exists in docs/framing.html */
+
+int ogg_page_version(const ogg_page *og){
+ return((int)(og->header[4]));
+}
+
+int ogg_page_continued(const ogg_page *og){
+ return((int)(og->header[5]&0x01));
+}
+
+int ogg_page_bos(const ogg_page *og){
+ return((int)(og->header[5]&0x02));
+}
+
+int ogg_page_eos(const ogg_page *og){
+ return((int)(og->header[5]&0x04));
+}
+
+ogg_int64_t ogg_page_granulepos(const ogg_page *og){
+ unsigned char *page=og->header;
+ ogg_int64_t granulepos=page[13]&(0xff);
+ granulepos= (granulepos<<8)|(page[12]&0xff);
+ granulepos= (granulepos<<8)|(page[11]&0xff);
+ granulepos= (granulepos<<8)|(page[10]&0xff);
+ granulepos= (granulepos<<8)|(page[9]&0xff);
+ granulepos= (granulepos<<8)|(page[8]&0xff);
+ granulepos= (granulepos<<8)|(page[7]&0xff);
+ granulepos= (granulepos<<8)|(page[6]&0xff);
+ return(granulepos);
+}
+
+int ogg_page_serialno(const ogg_page *og){
+ return(og->header[14] |
+ (og->header[15]<<8) |
+ (og->header[16]<<16) |
+ (og->header[17]<<24));
+}
+
+long ogg_page_pageno(const ogg_page *og){
+ return(og->header[18] |
+ (og->header[19]<<8) |
+ (og->header[20]<<16) |
+ (og->header[21]<<24));
+}
+
+
+
+/* returns the number of packets that are completed on this page (if
+ the leading packet is begun on a previous page, but ends on this
+ page, it's counted */
+
+/* NOTE:
+ If a page consists of a packet begun on a previous page, and a new
+ packet begun (but not completed) on this page, the return will be:
+ ogg_page_packets(page) ==1,
+ ogg_page_continued(page) !=0
+
+ If a page happens to be a single packet that was begun on a
+ previous page, and spans to the next page (in the case of a three or
+ more page packet), the return will be:
+ ogg_page_packets(page) ==0,
+ ogg_page_continued(page) !=0
+*/
+
+int ogg_page_packets(const ogg_page *og){
+ int i,n=og->header[26],count=0;
+ for(i=0;i<n;i++)
+ if(og->header[27+i]<255)count++;
+ return(count);
+}
+
+
+#if 0
+/* helper to initialize lookup for direct-table CRC (illustrative; we
+ use the static init below) */
+
+static ogg_uint32_t _ogg_crc_entry(unsigned long index){
+ int i;
+ unsigned long r;
+
+ r = index << 24;
+ for (i=0; i<8; i++)
+ if (r & 0x80000000UL)
+ r = (r << 1) ^ 0x04c11db7; /* The same as the ethernet generator
+ polynomial, although we use an
+ unreflected alg and an init/final
+ of 0, not 0xffffffff */
+ else
+ r<<=1;
+ return (r & 0xffffffffUL);
+}
+#endif
+
+static const ogg_uint32_t crc_lookup[256]={
+ 0x00000000,0x04c11db7,0x09823b6e,0x0d4326d9,
+ 0x130476dc,0x17c56b6b,0x1a864db2,0x1e475005,
+ 0x2608edb8,0x22c9f00f,0x2f8ad6d6,0x2b4bcb61,
+ 0x350c9b64,0x31cd86d3,0x3c8ea00a,0x384fbdbd,
+ 0x4c11db70,0x48d0c6c7,0x4593e01e,0x4152fda9,
+ 0x5f15adac,0x5bd4b01b,0x569796c2,0x52568b75,
+ 0x6a1936c8,0x6ed82b7f,0x639b0da6,0x675a1011,
+ 0x791d4014,0x7ddc5da3,0x709f7b7a,0x745e66cd,
+ 0x9823b6e0,0x9ce2ab57,0x91a18d8e,0x95609039,
+ 0x8b27c03c,0x8fe6dd8b,0x82a5fb52,0x8664e6e5,
+ 0xbe2b5b58,0xbaea46ef,0xb7a96036,0xb3687d81,
+ 0xad2f2d84,0xa9ee3033,0xa4ad16ea,0xa06c0b5d,
+ 0xd4326d90,0xd0f37027,0xddb056fe,0xd9714b49,
+ 0xc7361b4c,0xc3f706fb,0xceb42022,0xca753d95,
+ 0xf23a8028,0xf6fb9d9f,0xfbb8bb46,0xff79a6f1,
+ 0xe13ef6f4,0xe5ffeb43,0xe8bccd9a,0xec7dd02d,
+ 0x34867077,0x30476dc0,0x3d044b19,0x39c556ae,
+ 0x278206ab,0x23431b1c,0x2e003dc5,0x2ac12072,
+ 0x128e9dcf,0x164f8078,0x1b0ca6a1,0x1fcdbb16,
+ 0x018aeb13,0x054bf6a4,0x0808d07d,0x0cc9cdca,
+ 0x7897ab07,0x7c56b6b0,0x71159069,0x75d48dde,
+ 0x6b93dddb,0x6f52c06c,0x6211e6b5,0x66d0fb02,
+ 0x5e9f46bf,0x5a5e5b08,0x571d7dd1,0x53dc6066,
+ 0x4d9b3063,0x495a2dd4,0x44190b0d,0x40d816ba,
+ 0xaca5c697,0xa864db20,0xa527fdf9,0xa1e6e04e,
+ 0xbfa1b04b,0xbb60adfc,0xb6238b25,0xb2e29692,
+ 0x8aad2b2f,0x8e6c3698,0x832f1041,0x87ee0df6,
+ 0x99a95df3,0x9d684044,0x902b669d,0x94ea7b2a,
+ 0xe0b41de7,0xe4750050,0xe9362689,0xedf73b3e,
+ 0xf3b06b3b,0xf771768c,0xfa325055,0xfef34de2,
+ 0xc6bcf05f,0xc27dede8,0xcf3ecb31,0xcbffd686,
+ 0xd5b88683,0xd1799b34,0xdc3abded,0xd8fba05a,
+ 0x690ce0ee,0x6dcdfd59,0x608edb80,0x644fc637,
+ 0x7a089632,0x7ec98b85,0x738aad5c,0x774bb0eb,
+ 0x4f040d56,0x4bc510e1,0x46863638,0x42472b8f,
+ 0x5c007b8a,0x58c1663d,0x558240e4,0x51435d53,
+ 0x251d3b9e,0x21dc2629,0x2c9f00f0,0x285e1d47,
+ 0x36194d42,0x32d850f5,0x3f9b762c,0x3b5a6b9b,
+ 0x0315d626,0x07d4cb91,0x0a97ed48,0x0e56f0ff,
+ 0x1011a0fa,0x14d0bd4d,0x19939b94,0x1d528623,
+ 0xf12f560e,0xf5ee4bb9,0xf8ad6d60,0xfc6c70d7,
+ 0xe22b20d2,0xe6ea3d65,0xeba91bbc,0xef68060b,
+ 0xd727bbb6,0xd3e6a601,0xdea580d8,0xda649d6f,
+ 0xc423cd6a,0xc0e2d0dd,0xcda1f604,0xc960ebb3,
+ 0xbd3e8d7e,0xb9ff90c9,0xb4bcb610,0xb07daba7,
+ 0xae3afba2,0xaafbe615,0xa7b8c0cc,0xa379dd7b,
+ 0x9b3660c6,0x9ff77d71,0x92b45ba8,0x9675461f,
+ 0x8832161a,0x8cf30bad,0x81b02d74,0x857130c3,
+ 0x5d8a9099,0x594b8d2e,0x5408abf7,0x50c9b640,
+ 0x4e8ee645,0x4a4ffbf2,0x470cdd2b,0x43cdc09c,
+ 0x7b827d21,0x7f436096,0x7200464f,0x76c15bf8,
+ 0x68860bfd,0x6c47164a,0x61043093,0x65c52d24,
+ 0x119b4be9,0x155a565e,0x18197087,0x1cd86d30,
+ 0x029f3d35,0x065e2082,0x0b1d065b,0x0fdc1bec,
+ 0x3793a651,0x3352bbe6,0x3e119d3f,0x3ad08088,
+ 0x2497d08d,0x2056cd3a,0x2d15ebe3,0x29d4f654,
+ 0xc5a92679,0xc1683bce,0xcc2b1d17,0xc8ea00a0,
+ 0xd6ad50a5,0xd26c4d12,0xdf2f6bcb,0xdbee767c,
+ 0xe3a1cbc1,0xe760d676,0xea23f0af,0xeee2ed18,
+ 0xf0a5bd1d,0xf464a0aa,0xf9278673,0xfde69bc4,
+ 0x89b8fd09,0x8d79e0be,0x803ac667,0x84fbdbd0,
+ 0x9abc8bd5,0x9e7d9662,0x933eb0bb,0x97ffad0c,
+ 0xafb010b1,0xab710d06,0xa6322bdf,0xa2f33668,
+ 0xbcb4666d,0xb8757bda,0xb5365d03,0xb1f740b4};
+
+/* init the encode/decode logical stream state */
+
+int ogg_stream_init(ogg_stream_state *os,int serialno){
+ if(os){
+ memset(os,0,sizeof(*os));
+ os->body_storage=16*1024;
+ os->lacing_storage=1024;
+
+ os->body_data=_ogg_malloc(os->body_storage*sizeof(*os->body_data));
+ os->lacing_vals=_ogg_malloc(os->lacing_storage*sizeof(*os->lacing_vals));
+ os->granule_vals=_ogg_malloc(os->lacing_storage*sizeof(*os->granule_vals));
+
+ if(!os->body_data || !os->lacing_vals || !os->granule_vals){
+ ogg_stream_clear(os);
+ return -1;
+ }
+
+ os->serialno=serialno;
+
+ return(0);
+ }
+ return(-1);
+}
+
+/* async/delayed error detection for the ogg_stream_state */
+int ogg_stream_check(ogg_stream_state *os){
+ if(!os || !os->body_data) return -1;
+ return 0;
+}
+
+/* _clear does not free os, only the non-flat storage within */
+int ogg_stream_clear(ogg_stream_state *os){
+ if(os){
+ if(os->body_data)_ogg_free(os->body_data);
+ if(os->lacing_vals)_ogg_free(os->lacing_vals);
+ if(os->granule_vals)_ogg_free(os->granule_vals);
+
+ memset(os,0,sizeof(*os));
+ }
+ return(0);
+}
+
+int ogg_stream_destroy(ogg_stream_state *os){
+ if(os){
+ ogg_stream_clear(os);
+ _ogg_free(os);
+ }
+ return(0);
+}
+
+/* Helpers for ogg_stream_encode; this keeps the structure and
+ what's happening fairly clear */
+
+static int _os_body_expand(ogg_stream_state *os,long needed){
+ if(os->body_storage-needed<=os->body_fill){
+ long body_storage;
+ void *ret;
+ if(os->body_storage>LONG_MAX-needed){
+ ogg_stream_clear(os);
+ return -1;
+ }
+ body_storage=os->body_storage+needed;
+ if(body_storage<LONG_MAX-1024)body_storage+=1024;
+ ret=_ogg_realloc(os->body_data,body_storage*sizeof(*os->body_data));
+ if(!ret){
+ ogg_stream_clear(os);
+ return -1;
+ }
+ os->body_storage=body_storage;
+ os->body_data=ret;
+ }
+ return 0;
+}
+
+static int _os_lacing_expand(ogg_stream_state *os,long needed){
+ if(os->lacing_storage-needed<=os->lacing_fill){
+ long lacing_storage;
+ void *ret;
+ if(os->lacing_storage>LONG_MAX-needed){
+ ogg_stream_clear(os);
+ return -1;
+ }
+ lacing_storage=os->lacing_storage+needed;
+ if(lacing_storage<LONG_MAX-32)lacing_storage+=32;
+ ret=_ogg_realloc(os->lacing_vals,lacing_storage*sizeof(*os->lacing_vals));
+ if(!ret){
+ ogg_stream_clear(os);
+ return -1;
+ }
+ os->lacing_vals=ret;
+ ret=_ogg_realloc(os->granule_vals,lacing_storage*
+ sizeof(*os->granule_vals));
+ if(!ret){
+ ogg_stream_clear(os);
+ return -1;
+ }
+ os->granule_vals=ret;
+ os->lacing_storage=lacing_storage;
+ }
+ return 0;
+}
+
+/* checksum the page */
+/* Direct table CRC; note that this will be faster in the future if we
+ perform the checksum simultaneously with other copies */
+
+void ogg_page_checksum_set(ogg_page *og){
+ if(og){
+ ogg_uint32_t crc_reg=0;
+ int i;
+
+ /* safety; needed for API behavior, but not framing code */
+ og->header[22]=0;
+ og->header[23]=0;
+ og->header[24]=0;
+ og->header[25]=0;
+
+ for(i=0;i<og->header_len;i++)
+ crc_reg=(crc_reg<<8)^crc_lookup[((crc_reg >> 24)&0xff)^og->header[i]];
+ for(i=0;i<og->body_len;i++)
+ crc_reg=(crc_reg<<8)^crc_lookup[((crc_reg >> 24)&0xff)^og->body[i]];
+
+ og->header[22]=(unsigned char)(crc_reg&0xff);
+ og->header[23]=(unsigned char)((crc_reg>>8)&0xff);
+ og->header[24]=(unsigned char)((crc_reg>>16)&0xff);
+ og->header[25]=(unsigned char)((crc_reg>>24)&0xff);
+ }
+}
+
+/* submit data to the internal buffer of the framing engine */
+int ogg_stream_iovecin(ogg_stream_state *os, ogg_iovec_t *iov, int count,
+ long e_o_s, ogg_int64_t granulepos){
+
+ long bytes = 0, lacing_vals;
+ int i;
+
+ if(ogg_stream_check(os)) return -1;
+ if(!iov) return 0;
+
+ for (i = 0; i < count; ++i){
+ if(iov[i].iov_len>LONG_MAX) return -1;
+ if(bytes>LONG_MAX-(long)iov[i].iov_len) return -1;
+ bytes += (long)iov[i].iov_len;
+ }
+ lacing_vals=bytes/255+1;
+
+ if(os->body_returned){
+ /* advance packet data according to the body_returned pointer. We
+ had to keep it around to return a pointer into the buffer last
+ call */
+
+ os->body_fill-=os->body_returned;
+ if(os->body_fill)
+ memmove(os->body_data,os->body_data+os->body_returned,
+ os->body_fill);
+ os->body_returned=0;
+ }
+
+ /* make sure we have the buffer storage */
+ if(_os_body_expand(os,bytes) || _os_lacing_expand(os,lacing_vals))
+ return -1;
+
+ /* Copy in the submitted packet. Yes, the copy is a waste; this is
+ the liability of overly clean abstraction for the time being. It
+ will actually be fairly easy to eliminate the extra copy in the
+ future */
+
+ for (i = 0; i < count; ++i) {
+ memcpy(os->body_data+os->body_fill, iov[i].iov_base, iov[i].iov_len);
+ os->body_fill += (int)iov[i].iov_len;
+ }
+
+ /* Store lacing vals for this packet */
+ for(i=0;i<lacing_vals-1;i++){
+ os->lacing_vals[os->lacing_fill+i]=255;
+ os->granule_vals[os->lacing_fill+i]=os->granulepos;
+ }
+ os->lacing_vals[os->lacing_fill+i]=bytes%255;
+ os->granulepos=os->granule_vals[os->lacing_fill+i]=granulepos;
+
+ /* flag the first segment as the beginning of the packet */
+ os->lacing_vals[os->lacing_fill]|= 0x100;
+
+ os->lacing_fill+=lacing_vals;
+
+ /* for the sake of completeness */
+ os->packetno++;
+
+ if(e_o_s)os->e_o_s=1;
+
+ return(0);
+}
+
+int ogg_stream_packetin(ogg_stream_state *os,ogg_packet *op){
+ ogg_iovec_t iov;
+ iov.iov_base = op->packet;
+ iov.iov_len = op->bytes;
+ return ogg_stream_iovecin(os, &iov, 1, op->e_o_s, op->granulepos);
+}
+
+/* Conditionally flush a page; force==0 will only flush nominal-size
+ pages, force==1 forces us to flush a page regardless of page size
+ so long as there's any data available at all. */
+static int ogg_stream_flush_i(ogg_stream_state *os,ogg_page *og, int force, int nfill){
+ int i;
+ int vals=0;
+ int maxvals=(os->lacing_fill>255?255:os->lacing_fill);
+ int bytes=0;
+ long acc=0;
+ ogg_int64_t granule_pos=-1;
+
+ if(ogg_stream_check(os)) return(0);
+ if(maxvals==0) return(0);
+
+ /* construct a page */
+ /* decide how many segments to include */
+
+ /* If this is the initial header case, the first page must only include
+ the initial header packet */
+ if(os->b_o_s==0){ /* 'initial header page' case */
+ granule_pos=0;
+ for(vals=0;vals<maxvals;vals++){
+ if((os->lacing_vals[vals]&0x0ff)<255){
+ vals++;
+ break;
+ }
+ }
+ }else{
+
+ /* The extra packets_done, packet_just_done logic here attempts to do two things:
+ 1) Don't unneccessarily span pages.
+ 2) Unless necessary, don't flush pages if there are less than four packets on
+ them; this expands page size to reduce unneccessary overhead if incoming packets
+ are large.
+ These are not necessary behaviors, just 'always better than naive flushing'
+ without requiring an application to explicitly request a specific optimized
+ behavior. We'll want an explicit behavior setup pathway eventually as well. */
+
+ int packets_done=0;
+ int packet_just_done=0;
+ for(vals=0;vals<maxvals;vals++){
+ if(acc>nfill && packet_just_done>=4){
+ force=1;
+ break;
+ }
+ acc+=os->lacing_vals[vals]&0x0ff;
+ if((os->lacing_vals[vals]&0xff)<255){
+ granule_pos=os->granule_vals[vals];
+ packet_just_done=++packets_done;
+ }else
+ packet_just_done=0;
+ }
+ if(vals==255)force=1;
+ }
+
+ if(!force) return(0);
+
+ /* construct the header in temp storage */
+ memcpy(os->header,"OggS",4);
+
+ /* stream structure version */
+ os->header[4]=0x00;
+
+ /* continued packet flag? */
+ os->header[5]=0x00;
+ if((os->lacing_vals[0]&0x100)==0)os->header[5]|=0x01;
+ /* first page flag? */
+ if(os->b_o_s==0)os->header[5]|=0x02;
+ /* last page flag? */
+ if(os->e_o_s && os->lacing_fill==vals)os->header[5]|=0x04;
+ os->b_o_s=1;
+
+ /* 64 bits of PCM position */
+ for(i=6;i<14;i++){
+ os->header[i]=(unsigned char)(granule_pos&0xff);
+ granule_pos>>=8;
+ }
+
+ /* 32 bits of stream serial number */
+ {
+ long serialno=os->serialno;
+ for(i=14;i<18;i++){
+ os->header[i]=(unsigned char)(serialno&0xff);
+ serialno>>=8;
+ }
+ }
+
+ /* 32 bits of page counter (we have both counter and page header
+ because this val can roll over) */
+ if(os->pageno==-1)os->pageno=0; /* because someone called
+ stream_reset; this would be a
+ strange thing to do in an
+ encode stream, but it has
+ plausible uses */
+ {
+ long pageno=os->pageno++;
+ for(i=18;i<22;i++){
+ os->header[i]=(unsigned char)(pageno&0xff);
+ pageno>>=8;
+ }
+ }
+
+ /* zero for computation; filled in later */
+ os->header[22]=0;
+ os->header[23]=0;
+ os->header[24]=0;
+ os->header[25]=0;
+
+ /* segment table */
+ os->header[26]=(unsigned char)(vals&0xff);
+ for(i=0;i<vals;i++)
+ bytes+=os->header[i+27]=(unsigned char)(os->lacing_vals[i]&0xff);
+
+ /* set pointers in the ogg_page struct */
+ og->header=os->header;
+ og->header_len=os->header_fill=vals+27;
+ og->body=os->body_data+os->body_returned;
+ og->body_len=bytes;
+
+ /* advance the lacing data and set the body_returned pointer */
+
+ os->lacing_fill-=vals;
+ memmove(os->lacing_vals,os->lacing_vals+vals,os->lacing_fill*sizeof(*os->lacing_vals));
+ memmove(os->granule_vals,os->granule_vals+vals,os->lacing_fill*sizeof(*os->granule_vals));
+ os->body_returned+=bytes;
+
+ /* calculate the checksum */
+
+ ogg_page_checksum_set(og);
+
+ /* done */
+ return(1);
+}
+
+/* This will flush remaining packets into a page (returning nonzero),
+ even if there is not enough data to trigger a flush normally
+ (undersized page). If there are no packets or partial packets to
+ flush, ogg_stream_flush returns 0. Note that ogg_stream_flush will
+ try to flush a normal sized page like ogg_stream_pageout; a call to
+ ogg_stream_flush does not guarantee that all packets have flushed.
+ Only a return value of 0 from ogg_stream_flush indicates all packet
+ data is flushed into pages.
+
+ since ogg_stream_flush will flush the last page in a stream even if
+ it's undersized, you almost certainly want to use ogg_stream_pageout
+ (and *not* ogg_stream_flush) unless you specifically need to flush
+ a page regardless of size in the middle of a stream. */
+
+int ogg_stream_flush(ogg_stream_state *os,ogg_page *og){
+ return ogg_stream_flush_i(os,og,1,4096);
+}
+
+/* Like the above, but an argument is provided to adjust the nominal
+ page size for applications which are smart enough to provide their
+ own delay based flushing */
+
+int ogg_stream_flush_fill(ogg_stream_state *os,ogg_page *og, int nfill){
+ return ogg_stream_flush_i(os,og,1,nfill);
+}
+
+/* This constructs pages from buffered packet segments. The pointers
+returned are to static buffers; do not free. The returned buffers are
+good only until the next call (using the same ogg_stream_state) */
+
+int ogg_stream_pageout(ogg_stream_state *os, ogg_page *og){
+ int force=0;
+ if(ogg_stream_check(os)) return 0;
+
+ if((os->e_o_s&&os->lacing_fill) || /* 'were done, now flush' case */
+ (os->lacing_fill&&!os->b_o_s)) /* 'initial header page' case */
+ force=1;
+
+ return(ogg_stream_flush_i(os,og,force,4096));
+}
+
+/* Like the above, but an argument is provided to adjust the nominal
+page size for applications which are smart enough to provide their
+own delay based flushing */
+
+int ogg_stream_pageout_fill(ogg_stream_state *os, ogg_page *og, int nfill){
+ int force=0;
+ if(ogg_stream_check(os)) return 0;
+
+ if((os->e_o_s&&os->lacing_fill) || /* 'were done, now flush' case */
+ (os->lacing_fill&&!os->b_o_s)) /* 'initial header page' case */
+ force=1;
+
+ return(ogg_stream_flush_i(os,og,force,nfill));
+}
+
+int ogg_stream_eos(ogg_stream_state *os){
+ if(ogg_stream_check(os)) return 1;
+ return os->e_o_s;
+}
+
+/* DECODING PRIMITIVES: packet streaming layer **********************/
+
+/* This has two layers to place more of the multi-serialno and paging
+ control in the application's hands. First, we expose a data buffer
+ using ogg_sync_buffer(). The app either copies into the
+ buffer, or passes it directly to read(), etc. We then call
+ ogg_sync_wrote() to tell how many bytes we just added.
+
+ Pages are returned (pointers into the buffer in ogg_sync_state)
+ by ogg_sync_pageout(). The page is then submitted to
+ ogg_stream_pagein() along with the appropriate
+ ogg_stream_state* (ie, matching serialno). We then get raw
+ packets out calling ogg_stream_packetout() with a
+ ogg_stream_state. */
+
+/* initialize the struct to a known state */
+int ogg_sync_init(ogg_sync_state *oy){
+ if(oy){
+ oy->storage = -1; /* used as a readiness flag */
+ memset(oy,0,sizeof(*oy));
+ }
+ return(0);
+}
+
+/* clear non-flat storage within */
+int ogg_sync_clear(ogg_sync_state *oy){
+ if(oy){
+ if(oy->data)_ogg_free(oy->data);
+ memset(oy,0,sizeof(*oy));
+ }
+ return(0);
+}
+
+int ogg_sync_destroy(ogg_sync_state *oy){
+ if(oy){
+ ogg_sync_clear(oy);
+ _ogg_free(oy);
+ }
+ return(0);
+}
+
+int ogg_sync_check(ogg_sync_state *oy){
+ if(oy->storage<0) return -1;
+ return 0;
+}
+
+char *ogg_sync_buffer(ogg_sync_state *oy, long size){
+ if(ogg_sync_check(oy)) return NULL;
+
+ /* first, clear out any space that has been previously returned */
+ if(oy->returned){
+ oy->fill-=oy->returned;
+ if(oy->fill>0)
+ memmove(oy->data,oy->data+oy->returned,oy->fill);
+ oy->returned=0;
+ }
+
+ if(size>oy->storage-oy->fill){
+ /* We need to extend the internal buffer */
+ long newsize=size+oy->fill+4096; /* an extra page to be nice */
+ void *ret;
+
+ if(oy->data)
+ ret=_ogg_realloc(oy->data,newsize);
+ else
+ ret=_ogg_malloc(newsize);
+ if(!ret){
+ ogg_sync_clear(oy);
+ return NULL;
+ }
+ oy->data=ret;
+ oy->storage=newsize;
+ }
+
+ /* expose a segment at least as large as requested at the fill mark */
+ return((char *)oy->data+oy->fill);
+}
+
+int ogg_sync_wrote(ogg_sync_state *oy, long bytes){
+ if(ogg_sync_check(oy))return -1;
+ if(oy->fill+bytes>oy->storage)return -1;
+ oy->fill+=bytes;
+ return(0);
+}
+
+/* sync the stream. This is meant to be useful for finding page
+ boundaries.
+
+ return values for this:
+ -n) skipped n bytes
+ 0) page not ready; more data (no bytes skipped)
+ n) page synced at current location; page length n bytes
+
+*/
+
+long ogg_sync_pageseek(ogg_sync_state *oy,ogg_page *og){
+ unsigned char *page=oy->data+oy->returned;
+ unsigned char *next;
+ long bytes=oy->fill-oy->returned;
+
+ if(ogg_sync_check(oy))return 0;
+
+ if(oy->headerbytes==0){
+ int headerbytes,i;
+ if(bytes<27)return(0); /* not enough for a header */
+
+ /* verify capture pattern */
+ if(memcmp(page,"OggS",4))goto sync_fail;
+
+ headerbytes=page[26]+27;
+ if(bytes<headerbytes)return(0); /* not enough for header + seg table */
+
+ /* count up body length in the segment table */
+
+ for(i=0;i<page[26];i++)
+ oy->bodybytes+=page[27+i];
+ oy->headerbytes=headerbytes;
+ }
+
+ if(oy->bodybytes+oy->headerbytes>bytes)return(0);
+
+ /* The whole test page is buffered. Verify the checksum */
+ {
+ /* Grab the checksum bytes, set the header field to zero */
+ char chksum[4];
+ ogg_page log;
+
+ memcpy(chksum,page+22,4);
+ memset(page+22,0,4);
+
+ /* set up a temp page struct and recompute the checksum */
+ log.header=page;
+ log.header_len=oy->headerbytes;
+ log.body=page+oy->headerbytes;
+ log.body_len=oy->bodybytes;
+ ogg_page_checksum_set(&log);
+
+ /* Compare */
+ if(memcmp(chksum,page+22,4)){
+ /* D'oh. Mismatch! Corrupt page (or miscapture and not a page
+ at all) */
+ /* replace the computed checksum with the one actually read in */
+ memcpy(page+22,chksum,4);
+
+ /* Bad checksum. Lose sync */
+ goto sync_fail;
+ }
+ }
+
+ /* yes, have a whole page all ready to go */
+ {
+ unsigned char *page=oy->data+oy->returned;
+ long bytes;
+
+ if(og){
+ og->header=page;
+ og->header_len=oy->headerbytes;
+ og->body=page+oy->headerbytes;
+ og->body_len=oy->bodybytes;
+ }
+
+ oy->unsynced=0;
+ oy->returned+=(bytes=oy->headerbytes+oy->bodybytes);
+ oy->headerbytes=0;
+ oy->bodybytes=0;
+ return(bytes);
+ }
+
+ sync_fail:
+
+ oy->headerbytes=0;
+ oy->bodybytes=0;
+
+ /* search for possible capture */
+ next=memchr(page+1,'O',bytes-1);
+ if(!next)
+ next=oy->data+oy->fill;
+
+ oy->returned=(int)(next-oy->data);
+ return((long)-(next-page));
+}
+
+/* sync the stream and get a page. Keep trying until we find a page.
+ Suppress 'sync errors' after reporting the first.
+
+ return values:
+ -1) recapture (hole in data)
+ 0) need more data
+ 1) page returned
+
+ Returns pointers into buffered data; invalidated by next call to
+ _stream, _clear, _init, or _buffer */
+
+int ogg_sync_pageout(ogg_sync_state *oy, ogg_page *og){
+
+ if(ogg_sync_check(oy))return 0;
+
+ /* all we need to do is verify a page at the head of the stream
+ buffer. If it doesn't verify, we look for the next potential
+ frame */
+
+ for(;;){
+ long ret=ogg_sync_pageseek(oy,og);
+ if(ret>0){
+ /* have a page */
+ return(1);
+ }
+ if(ret==0){
+ /* need more data */
+ return(0);
+ }
+
+ /* head did not start a synced page... skipped some bytes */
+ if(!oy->unsynced){
+ oy->unsynced=1;
+ return(-1);
+ }
+
+ /* loop. keep looking */
+
+ }
+}
+
+/* add the incoming page to the stream state; we decompose the page
+ into packet segments here as well. */
+
+int ogg_stream_pagein(ogg_stream_state *os, ogg_page *og){
+ unsigned char *header=og->header;
+ unsigned char *body=og->body;
+ long bodysize=og->body_len;
+ int segptr=0;
+
+ int version=ogg_page_version(og);
+ int continued=ogg_page_continued(og);
+ int bos=ogg_page_bos(og);
+ int eos=ogg_page_eos(og);
+ ogg_int64_t granulepos=ogg_page_granulepos(og);
+ int serialno=ogg_page_serialno(og);
+ long pageno=ogg_page_pageno(og);
+ int segments=header[26];
+
+ if(ogg_stream_check(os)) return -1;
+
+ /* clean up 'returned data' */
+ {
+ long lr=os->lacing_returned;
+ long br=os->body_returned;
+
+ /* body data */
+ if(br){
+ os->body_fill-=br;
+ if(os->body_fill)
+ memmove(os->body_data,os->body_data+br,os->body_fill);
+ os->body_returned=0;
+ }
+
+ if(lr){
+ /* segment table */
+ if(os->lacing_fill-lr){
+ memmove(os->lacing_vals,os->lacing_vals+lr,
+ (os->lacing_fill-lr)*sizeof(*os->lacing_vals));
+ memmove(os->granule_vals,os->granule_vals+lr,
+ (os->lacing_fill-lr)*sizeof(*os->granule_vals));
+ }
+ os->lacing_fill-=lr;
+ os->lacing_packet-=lr;
+ os->lacing_returned=0;
+ }
+ }
+
+ /* check the serial number */
+ if(serialno!=os->serialno)return(-1);
+ if(version>0)return(-1);
+
+ if(_os_lacing_expand(os,segments+1)) return -1;
+
+ /* are we in sequence? */
+ if(pageno!=os->pageno){
+ int i;
+
+ /* unroll previous partial packet (if any) */
+ for(i=os->lacing_packet;i<os->lacing_fill;i++)
+ os->body_fill-=os->lacing_vals[i]&0xff;
+ os->lacing_fill=os->lacing_packet;
+
+ /* make a note of dropped data in segment table */
+ if(os->pageno!=-1){
+ os->lacing_vals[os->lacing_fill++]=0x400;
+ os->lacing_packet++;
+ }
+ }
+
+ /* are we a 'continued packet' page? If so, we may need to skip
+ some segments */
+ if(continued){
+ if(os->lacing_fill<1 ||
+ os->lacing_vals[os->lacing_fill-1]==0x400){
+ bos=0;
+ for(;segptr<segments;segptr++){
+ int val=header[27+segptr];
+ body+=val;
+ bodysize-=val;
+ if(val<255){
+ segptr++;
+ break;
+ }
+ }
+ }
+ }
+
+ if(bodysize){
+ if(_os_body_expand(os,bodysize)) return -1;
+ memcpy(os->body_data+os->body_fill,body,bodysize);
+ os->body_fill+=bodysize;
+ }
+
+ {
+ int saved=-1;
+ while(segptr<segments){
+ int val=header[27+segptr];
+ os->lacing_vals[os->lacing_fill]=val;
+ os->granule_vals[os->lacing_fill]=-1;
+
+ if(bos){
+ os->lacing_vals[os->lacing_fill]|=0x100;
+ bos=0;
+ }
+
+ if(val<255)saved=os->lacing_fill;
+
+ os->lacing_fill++;
+ segptr++;
+
+ if(val<255)os->lacing_packet=os->lacing_fill;
+ }
+
+ /* set the granulepos on the last granuleval of the last full packet */
+ if(saved!=-1){
+ os->granule_vals[saved]=granulepos;
+ }
+
+ }
+
+ if(eos){
+ os->e_o_s=1;
+ if(os->lacing_fill>0)
+ os->lacing_vals[os->lacing_fill-1]|=0x200;
+ }
+
+ os->pageno=pageno+1;
+
+ return(0);
+}
+
+/* clear things to an initial state. Good to call, eg, before seeking */
+int ogg_sync_reset(ogg_sync_state *oy){
+ if(ogg_sync_check(oy))return -1;
+
+ oy->fill=0;
+ oy->returned=0;
+ oy->unsynced=0;
+ oy->headerbytes=0;
+ oy->bodybytes=0;
+ return(0);
+}
+
+int ogg_stream_reset(ogg_stream_state *os){
+ if(ogg_stream_check(os)) return -1;
+
+ os->body_fill=0;
+ os->body_returned=0;
+
+ os->lacing_fill=0;
+ os->lacing_packet=0;
+ os->lacing_returned=0;
+
+ os->header_fill=0;
+
+ os->e_o_s=0;
+ os->b_o_s=0;
+ os->pageno=-1;
+ os->packetno=0;
+ os->granulepos=0;
+
+ return(0);
+}
+
+int ogg_stream_reset_serialno(ogg_stream_state *os,int serialno){
+ if(ogg_stream_check(os)) return -1;
+ ogg_stream_reset(os);
+ os->serialno=serialno;
+ return(0);
+}
+
+static int _packetout(ogg_stream_state *os,ogg_packet *op,int adv){
+
+ /* The last part of decode. We have the stream broken into packet
+ segments. Now we need to group them into packets (or return the
+ out of sync markers) */
+
+ int ptr=os->lacing_returned;
+
+ if(os->lacing_packet<=ptr)return(0);
+
+ if(os->lacing_vals[ptr]&0x400){
+ /* we need to tell the codec there's a gap; it might need to
+ handle previous packet dependencies. */
+ os->lacing_returned++;
+ os->packetno++;
+ return(-1);
+ }
+
+ if(!op && !adv)return(1); /* just using peek as an inexpensive way
+ to ask if there's a whole packet
+ waiting */
+
+ /* Gather the whole packet. We'll have no holes or a partial packet */
+ {
+ int size=os->lacing_vals[ptr]&0xff;
+ long bytes=size;
+ int eos=os->lacing_vals[ptr]&0x200; /* last packet of the stream? */
+ int bos=os->lacing_vals[ptr]&0x100; /* first packet of the stream? */
+
+ while(size==255){
+ int val=os->lacing_vals[++ptr];
+ size=val&0xff;
+ if(val&0x200)eos=0x200;
+ bytes+=size;
+ }
+
+ if(op){
+ op->e_o_s=eos;
+ op->b_o_s=bos;
+ op->packet=os->body_data+os->body_returned;
+ op->packetno=os->packetno;
+ op->granulepos=os->granule_vals[ptr];
+ op->bytes=bytes;
+ }
+
+ if(adv){
+ os->body_returned+=bytes;
+ os->lacing_returned=ptr+1;
+ os->packetno++;
+ }
+ }
+ return(1);
+}
+
+int ogg_stream_packetout(ogg_stream_state *os,ogg_packet *op){
+ if(ogg_stream_check(os)) return 0;
+ return _packetout(os,op,1);
+}
+
+int ogg_stream_packetpeek(ogg_stream_state *os,ogg_packet *op){
+ if(ogg_stream_check(os)) return 0;
+ return _packetout(os,op,0);
+}
+
+void ogg_packet_clear(ogg_packet *op) {
+ _ogg_free(op->packet);
+ memset(op, 0, sizeof(*op));
+}
+
+#ifdef _V_SELFTEST
+#include <stdio.h>
+
+ogg_stream_state os_en, os_de;
+ogg_sync_state oy;
+
+void checkpacket(ogg_packet *op,long len, int no, long pos){
+ long j;
+ static int sequence=0;
+ static int lastno=0;
+
+ if(op->bytes!=len){
+ fprintf(stderr,"incorrect packet length (%ld != %ld)!\n",op->bytes,len);
+ exit(1);
+ }
+ if(op->granulepos!=pos){
+ fprintf(stderr,"incorrect packet granpos (%ld != %ld)!\n",(long)op->granulepos,pos);
+ exit(1);
+ }
+
+ /* packet number just follows sequence/gap; adjust the input number
+ for that */
+ if(no==0){
+ sequence=0;
+ }else{
+ sequence++;
+ if(no>lastno+1)
+ sequence++;
+ }
+ lastno=no;
+ if(op->packetno!=sequence){
+ fprintf(stderr,"incorrect packet sequence %ld != %d\n",
+ (long)(op->packetno),sequence);
+ exit(1);
+ }
+
+ /* Test data */
+ for(j=0;j<op->bytes;j++)
+ if(op->packet[j]!=((j+no)&0xff)){
+ fprintf(stderr,"body data mismatch (1) at pos %ld: %x!=%lx!\n\n",
+ j,op->packet[j],(j+no)&0xff);
+ exit(1);
+ }
+}
+
+void check_page(unsigned char *data,const int *header,ogg_page *og){
+ long j;
+ /* Test data */
+ for(j=0;j<og->body_len;j++)
+ if(og->body[j]!=data[j]){
+ fprintf(stderr,"body data mismatch (2) at pos %ld: %x!=%x!\n\n",
+ j,data[j],og->body[j]);
+ exit(1);
+ }
+
+ /* Test header */
+ for(j=0;j<og->header_len;j++){
+ if(og->header[j]!=header[j]){
+ fprintf(stderr,"header content mismatch at pos %ld:\n",j);
+ for(j=0;j<header[26]+27;j++)
+ fprintf(stderr," (%ld)%02x:%02x",j,header[j],og->header[j]);
+ fprintf(stderr,"\n");
+ exit(1);
+ }
+ }
+ if(og->header_len!=header[26]+27){
+ fprintf(stderr,"header length incorrect! (%ld!=%d)\n",
+ og->header_len,header[26]+27);
+ exit(1);
+ }
+}
+
+void print_header(ogg_page *og){
+ int j;
+ fprintf(stderr,"\nHEADER:\n");
+ fprintf(stderr," capture: %c %c %c %c version: %d flags: %x\n",
+ og->header[0],og->header[1],og->header[2],og->header[3],
+ (int)og->header[4],(int)og->header[5]);
+
+ fprintf(stderr," granulepos: %d serialno: %d pageno: %ld\n",
+ (og->header[9]<<24)|(og->header[8]<<16)|
+ (og->header[7]<<8)|og->header[6],
+ (og->header[17]<<24)|(og->header[16]<<16)|
+ (og->header[15]<<8)|og->header[14],
+ ((long)(og->header[21])<<24)|(og->header[20]<<16)|
+ (og->header[19]<<8)|og->header[18]);
+
+ fprintf(stderr," checksum: %02x:%02x:%02x:%02x\n segments: %d (",
+ (int)og->header[22],(int)og->header[23],
+ (int)og->header[24],(int)og->header[25],
+ (int)og->header[26]);
+
+ for(j=27;j<og->header_len;j++)
+ fprintf(stderr,"%d ",(int)og->header[j]);
+ fprintf(stderr,")\n\n");
+}
+
+void copy_page(ogg_page *og){
+ unsigned char *temp=_ogg_malloc(og->header_len);
+ memcpy(temp,og->header,og->header_len);
+ og->header=temp;
+
+ temp=_ogg_malloc(og->body_len);
+ memcpy(temp,og->body,og->body_len);
+ og->body=temp;
+}
+
+void free_page(ogg_page *og){
+ _ogg_free (og->header);
+ _ogg_free (og->body);
+}
+
+void error(void){
+ fprintf(stderr,"error!\n");
+ exit(1);
+}
+
+/* 17 only */
+const int head1_0[] = {0x4f,0x67,0x67,0x53,0,0x06,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x01,0x02,0x03,0x04,0,0,0,0,
+ 0x15,0xed,0xec,0x91,
+ 1,
+ 17};
+
+/* 17, 254, 255, 256, 500, 510, 600 byte, pad */
+const int head1_1[] = {0x4f,0x67,0x67,0x53,0,0x02,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x01,0x02,0x03,0x04,0,0,0,0,
+ 0x59,0x10,0x6c,0x2c,
+ 1,
+ 17};
+const int head2_1[] = {0x4f,0x67,0x67,0x53,0,0x04,
+ 0x07,0x18,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x01,0x02,0x03,0x04,1,0,0,0,
+ 0x89,0x33,0x85,0xce,
+ 13,
+ 254,255,0,255,1,255,245,255,255,0,
+ 255,255,90};
+
+/* nil packets; beginning,middle,end */
+const int head1_2[] = {0x4f,0x67,0x67,0x53,0,0x02,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x01,0x02,0x03,0x04,0,0,0,0,
+ 0xff,0x7b,0x23,0x17,
+ 1,
+ 0};
+const int head2_2[] = {0x4f,0x67,0x67,0x53,0,0x04,
+ 0x07,0x28,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x01,0x02,0x03,0x04,1,0,0,0,
+ 0x5c,0x3f,0x66,0xcb,
+ 17,
+ 17,254,255,0,0,255,1,0,255,245,255,255,0,
+ 255,255,90,0};
+
+/* large initial packet */
+const int head1_3[] = {0x4f,0x67,0x67,0x53,0,0x02,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x01,0x02,0x03,0x04,0,0,0,0,
+ 0x01,0x27,0x31,0xaa,
+ 18,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,255,10};
+
+const int head2_3[] = {0x4f,0x67,0x67,0x53,0,0x04,
+ 0x07,0x08,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x01,0x02,0x03,0x04,1,0,0,0,
+ 0x7f,0x4e,0x8a,0xd2,
+ 4,
+ 255,4,255,0};
+
+
+/* continuing packet test */
+const int head1_4[] = {0x4f,0x67,0x67,0x53,0,0x02,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x01,0x02,0x03,0x04,0,0,0,0,
+ 0xff,0x7b,0x23,0x17,
+ 1,
+ 0};
+
+const int head2_4[] = {0x4f,0x67,0x67,0x53,0,0x00,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0x01,0x02,0x03,0x04,1,0,0,0,
+ 0xf8,0x3c,0x19,0x79,
+ 255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255};
+
+const int head3_4[] = {0x4f,0x67,0x67,0x53,0,0x05,
+ 0x07,0x0c,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x01,0x02,0x03,0x04,2,0,0,0,
+ 0x38,0xe6,0xb6,0x28,
+ 6,
+ 255,220,255,4,255,0};
+
+
+/* spill expansion test */
+const int head1_4b[] = {0x4f,0x67,0x67,0x53,0,0x02,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x01,0x02,0x03,0x04,0,0,0,0,
+ 0xff,0x7b,0x23,0x17,
+ 1,
+ 0};
+
+const int head2_4b[] = {0x4f,0x67,0x67,0x53,0,0x00,
+ 0x07,0x10,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x01,0x02,0x03,0x04,1,0,0,0,
+ 0xce,0x8f,0x17,0x1a,
+ 23,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,255,10,255,4,255,0,0};
+
+
+const int head3_4b[] = {0x4f,0x67,0x67,0x53,0,0x04,
+ 0x07,0x14,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x01,0x02,0x03,0x04,2,0,0,0,
+ 0x9b,0xb2,0x50,0xa1,
+ 1,
+ 0};
+
+/* page with the 255 segment limit */
+const int head1_5[] = {0x4f,0x67,0x67,0x53,0,0x02,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x01,0x02,0x03,0x04,0,0,0,0,
+ 0xff,0x7b,0x23,0x17,
+ 1,
+ 0};
+
+const int head2_5[] = {0x4f,0x67,0x67,0x53,0,0x00,
+ 0x07,0xfc,0x03,0x00,0x00,0x00,0x00,0x00,
+ 0x01,0x02,0x03,0x04,1,0,0,0,
+ 0xed,0x2a,0x2e,0xa7,
+ 255,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10};
+
+const int head3_5[] = {0x4f,0x67,0x67,0x53,0,0x04,
+ 0x07,0x00,0x04,0x00,0x00,0x00,0x00,0x00,
+ 0x01,0x02,0x03,0x04,2,0,0,0,
+ 0x6c,0x3b,0x82,0x3d,
+ 1,
+ 50};
+
+
+/* packet that overspans over an entire page */
+const int head1_6[] = {0x4f,0x67,0x67,0x53,0,0x02,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x01,0x02,0x03,0x04,0,0,0,0,
+ 0xff,0x7b,0x23,0x17,
+ 1,
+ 0};
+
+const int head2_6[] = {0x4f,0x67,0x67,0x53,0,0x00,
+ 0x07,0x04,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x01,0x02,0x03,0x04,1,0,0,0,
+ 0x68,0x22,0x7c,0x3d,
+ 255,
+ 100,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255};
+
+const int head3_6[] = {0x4f,0x67,0x67,0x53,0,0x01,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0x01,0x02,0x03,0x04,2,0,0,0,
+ 0xf4,0x87,0xba,0xf3,
+ 255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255};
+
+const int head4_6[] = {0x4f,0x67,0x67,0x53,0,0x05,
+ 0x07,0x10,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x01,0x02,0x03,0x04,3,0,0,0,
+ 0xf7,0x2f,0x6c,0x60,
+ 5,
+ 254,255,4,255,0};
+
+/* packet that overspans over an entire page */
+const int head1_7[] = {0x4f,0x67,0x67,0x53,0,0x02,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x01,0x02,0x03,0x04,0,0,0,0,
+ 0xff,0x7b,0x23,0x17,
+ 1,
+ 0};
+
+const int head2_7[] = {0x4f,0x67,0x67,0x53,0,0x00,
+ 0x07,0x04,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x01,0x02,0x03,0x04,1,0,0,0,
+ 0x68,0x22,0x7c,0x3d,
+ 255,
+ 100,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255,255,255,
+ 255,255,255,255,255,255};
+
+const int head3_7[] = {0x4f,0x67,0x67,0x53,0,0x05,
+ 0x07,0x08,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x01,0x02,0x03,0x04,2,0,0,0,
+ 0xd4,0xe0,0x60,0xe5,
+ 1,
+ 0};
+
+void test_pack(const int *pl, const int **headers, int byteskip,
+ int pageskip, int packetskip){
+ unsigned char *data=_ogg_malloc(1024*1024); /* for scripted test cases only */
+ long inptr=0;
+ long outptr=0;
+ long deptr=0;
+ long depacket=0;
+ long granule_pos=7,pageno=0;
+ int i,j,packets,pageout=pageskip;
+ int eosflag=0;
+ int bosflag=0;
+
+ int byteskipcount=0;
+
+ ogg_stream_reset(&os_en);
+ ogg_stream_reset(&os_de);
+ ogg_sync_reset(&oy);
+
+ for(packets=0;packets<packetskip;packets++)
+ depacket+=pl[packets];
+
+ for(packets=0;;packets++)if(pl[packets]==-1)break;
+
+ for(i=0;i<packets;i++){
+ /* construct a test packet */
+ ogg_packet op;
+ int len=pl[i];
+
+ op.packet=data+inptr;
+ op.bytes=len;
+ op.e_o_s=(pl[i+1]<0?1:0);
+ op.granulepos=granule_pos;
+
+ granule_pos+=1024;
+
+ for(j=0;j<len;j++)data[inptr++]=i+j;
+
+ /* submit the test packet */
+ ogg_stream_packetin(&os_en,&op);
+
+ /* retrieve any finished pages */
+ {
+ ogg_page og;
+
+ while(ogg_stream_pageout(&os_en,&og)){
+ /* We have a page. Check it carefully */
+
+ fprintf(stderr,"%ld, ",pageno);
+
+ if(headers[pageno]==NULL){
+ fprintf(stderr,"coded too many pages!\n");
+ exit(1);
+ }
+
+ check_page(data+outptr,headers[pageno],&og);
+
+ outptr+=og.body_len;
+ pageno++;
+ if(pageskip){
+ bosflag=1;
+ pageskip--;
+ deptr+=og.body_len;
+ }
+
+ /* have a complete page; submit it to sync/decode */
+
+ {
+ ogg_page og_de;
+ ogg_packet op_de,op_de2;
+ char *buf=ogg_sync_buffer(&oy,og.header_len+og.body_len);
+ char *next=buf;
+ byteskipcount+=og.header_len;
+ if(byteskipcount>byteskip){
+ memcpy(next,og.header,byteskipcount-byteskip);
+ next+=byteskipcount-byteskip;
+ byteskipcount=byteskip;
+ }
+
+ byteskipcount+=og.body_len;
+ if(byteskipcount>byteskip){
+ memcpy(next,og.body,byteskipcount-byteskip);
+ next+=byteskipcount-byteskip;
+ byteskipcount=byteskip;
+ }
+
+ ogg_sync_wrote(&oy,next-buf);
+
+ while(1){
+ int ret=ogg_sync_pageout(&oy,&og_de);
+ if(ret==0)break;
+ if(ret<0)continue;
+ /* got a page. Happy happy. Verify that it's good. */
+
+ fprintf(stderr,"(%d), ",pageout);
+
+ check_page(data+deptr,headers[pageout],&og_de);
+ deptr+=og_de.body_len;
+ pageout++;
+
+ /* submit it to deconstitution */
+ ogg_stream_pagein(&os_de,&og_de);
+
+ /* packets out? */
+ while(ogg_stream_packetpeek(&os_de,&op_de2)>0){
+ ogg_stream_packetpeek(&os_de,NULL);
+ ogg_stream_packetout(&os_de,&op_de); /* just catching them all */
+
+ /* verify peek and out match */
+ if(memcmp(&op_de,&op_de2,sizeof(op_de))){
+ fprintf(stderr,"packetout != packetpeek! pos=%ld\n",
+ depacket);
+ exit(1);
+ }
+
+ /* verify the packet! */
+ /* check data */
+ if(memcmp(data+depacket,op_de.packet,op_de.bytes)){
+ fprintf(stderr,"packet data mismatch in decode! pos=%ld\n",
+ depacket);
+ exit(1);
+ }
+ /* check bos flag */
+ if(bosflag==0 && op_de.b_o_s==0){
+ fprintf(stderr,"b_o_s flag not set on packet!\n");
+ exit(1);
+ }
+ if(bosflag && op_de.b_o_s){
+ fprintf(stderr,"b_o_s flag incorrectly set on packet!\n");
+ exit(1);
+ }
+ bosflag=1;
+ depacket+=op_de.bytes;
+
+ /* check eos flag */
+ if(eosflag){
+ fprintf(stderr,"Multiple decoded packets with eos flag!\n");
+ exit(1);
+ }
+
+ if(op_de.e_o_s)eosflag=1;
+
+ /* check granulepos flag */
+ if(op_de.granulepos!=-1){
+ fprintf(stderr," granule:%ld ",(long)op_de.granulepos);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ _ogg_free(data);
+ if(headers[pageno]!=NULL){
+ fprintf(stderr,"did not write last page!\n");
+ exit(1);
+ }
+ if(headers[pageout]!=NULL){
+ fprintf(stderr,"did not decode last page!\n");
+ exit(1);
+ }
+ if(inptr!=outptr){
+ fprintf(stderr,"encoded page data incomplete!\n");
+ exit(1);
+ }
+ if(inptr!=deptr){
+ fprintf(stderr,"decoded page data incomplete!\n");
+ exit(1);
+ }
+ if(inptr!=depacket){
+ fprintf(stderr,"decoded packet data incomplete!\n");
+ exit(1);
+ }
+ if(!eosflag){
+ fprintf(stderr,"Never got a packet with EOS set!\n");
+ exit(1);
+ }
+ fprintf(stderr,"ok.\n");
+}
+
+int main(void){
+
+ ogg_stream_init(&os_en,0x04030201);
+ ogg_stream_init(&os_de,0x04030201);
+ ogg_sync_init(&oy);
+
+ /* Exercise each code path in the framing code. Also verify that
+ the checksums are working. */
+
+ {
+ /* 17 only */
+ const int packets[]={17, -1};
+ const int *headret[]={head1_0,NULL};
+
+ fprintf(stderr,"testing single page encoding... ");
+ test_pack(packets,headret,0,0,0);
+ }
+
+ {
+ /* 17, 254, 255, 256, 500, 510, 600 byte, pad */
+ const int packets[]={17, 254, 255, 256, 500, 510, 600, -1};
+ const int *headret[]={head1_1,head2_1,NULL};
+
+ fprintf(stderr,"testing basic page encoding... ");
+ test_pack(packets,headret,0,0,0);
+ }
+
+ {
+ /* nil packets; beginning,middle,end */
+ const int packets[]={0,17, 254, 255, 0, 256, 0, 500, 510, 600, 0, -1};
+ const int *headret[]={head1_2,head2_2,NULL};
+
+ fprintf(stderr,"testing basic nil packets... ");
+ test_pack(packets,headret,0,0,0);
+ }
+
+ {
+ /* large initial packet */
+ const int packets[]={4345,259,255,-1};
+ const int *headret[]={head1_3,head2_3,NULL};
+
+ fprintf(stderr,"testing initial-packet lacing > 4k... ");
+ test_pack(packets,headret,0,0,0);
+ }
+
+ {
+ /* continuing packet test; with page spill expansion, we have to
+ overflow the lacing table. */
+ const int packets[]={0,65500,259,255,-1};
+ const int *headret[]={head1_4,head2_4,head3_4,NULL};
+
+ fprintf(stderr,"testing single packet page span... ");
+ test_pack(packets,headret,0,0,0);
+ }
+
+ {
+ /* spill expand packet test */
+ const int packets[]={0,4345,259,255,0,0,-1};
+ const int *headret[]={head1_4b,head2_4b,head3_4b,NULL};
+
+ fprintf(stderr,"testing page spill expansion... ");
+ test_pack(packets,headret,0,0,0);
+ }
+
+ /* page with the 255 segment limit */
+ {
+
+ const int packets[]={0,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,50,-1};
+ const int *headret[]={head1_5,head2_5,head3_5,NULL};
+
+ fprintf(stderr,"testing max packet segments... ");
+ test_pack(packets,headret,0,0,0);
+ }
+
+ {
+ /* packet that overspans over an entire page */
+ const int packets[]={0,100,130049,259,255,-1};
+ const int *headret[]={head1_6,head2_6,head3_6,head4_6,NULL};
+
+ fprintf(stderr,"testing very large packets... ");
+ test_pack(packets,headret,0,0,0);
+ }
+
+ {
+ /* test for the libogg 1.1.1 resync in large continuation bug
+ found by Josh Coalson) */
+ const int packets[]={0,100,130049,259,255,-1};
+ const int *headret[]={head1_6,head2_6,head3_6,head4_6,NULL};
+
+ fprintf(stderr,"testing continuation resync in very large packets... ");
+ test_pack(packets,headret,100,2,3);
+ }
+
+ {
+ /* term only page. why not? */
+ const int packets[]={0,100,64770,-1};
+ const int *headret[]={head1_7,head2_7,head3_7,NULL};
+
+ fprintf(stderr,"testing zero data page (1 nil packet)... ");
+ test_pack(packets,headret,0,0,0);
+ }
+
+
+
+ {
+ /* build a bunch of pages for testing */
+ unsigned char *data=_ogg_malloc(1024*1024);
+ int pl[]={0, 1,1,98,4079, 1,1,2954,2057, 76,34,912,0,234,1000,1000, 1000,300,-1};
+ int inptr=0,i,j;
+ ogg_page og[5];
+
+ ogg_stream_reset(&os_en);
+
+ for(i=0;pl[i]!=-1;i++){
+ ogg_packet op;
+ int len=pl[i];
+
+ op.packet=data+inptr;
+ op.bytes=len;
+ op.e_o_s=(pl[i+1]<0?1:0);
+ op.granulepos=(i+1)*1000;
+
+ for(j=0;j<len;j++)data[inptr++]=i+j;
+ ogg_stream_packetin(&os_en,&op);
+ }
+
+ _ogg_free(data);
+
+ /* retrieve finished pages */
+ for(i=0;i<5;i++){
+ if(ogg_stream_pageout(&os_en,&og[i])==0){
+ fprintf(stderr,"Too few pages output building sync tests!\n");
+ exit(1);
+ }
+ copy_page(&og[i]);
+ }
+
+ /* Test lost pages on pagein/packetout: no rollback */
+ {
+ ogg_page temp;
+ ogg_packet test;
+
+ fprintf(stderr,"Testing loss of pages... ");
+
+ ogg_sync_reset(&oy);
+ ogg_stream_reset(&os_de);
+ for(i=0;i<5;i++){
+ memcpy(ogg_sync_buffer(&oy,og[i].header_len),og[i].header,
+ og[i].header_len);
+ ogg_sync_wrote(&oy,og[i].header_len);
+ memcpy(ogg_sync_buffer(&oy,og[i].body_len),og[i].body,og[i].body_len);
+ ogg_sync_wrote(&oy,og[i].body_len);
+ }
+
+ ogg_sync_pageout(&oy,&temp);
+ ogg_stream_pagein(&os_de,&temp);
+ ogg_sync_pageout(&oy,&temp);
+ ogg_stream_pagein(&os_de,&temp);
+ ogg_sync_pageout(&oy,&temp);
+ /* skip */
+ ogg_sync_pageout(&oy,&temp);
+ ogg_stream_pagein(&os_de,&temp);
+
+ /* do we get the expected results/packets? */
+
+ if(ogg_stream_packetout(&os_de,&test)!=1)error();
+ checkpacket(&test,0,0,0);
+ if(ogg_stream_packetout(&os_de,&test)!=1)error();
+ checkpacket(&test,1,1,-1);
+ if(ogg_stream_packetout(&os_de,&test)!=1)error();
+ checkpacket(&test,1,2,-1);
+ if(ogg_stream_packetout(&os_de,&test)!=1)error();
+ checkpacket(&test,98,3,-1);
+ if(ogg_stream_packetout(&os_de,&test)!=1)error();
+ checkpacket(&test,4079,4,5000);
+ if(ogg_stream_packetout(&os_de,&test)!=-1){
+ fprintf(stderr,"Error: loss of page did not return error\n");
+ exit(1);
+ }
+ if(ogg_stream_packetout(&os_de,&test)!=1)error();
+ checkpacket(&test,76,9,-1);
+ if(ogg_stream_packetout(&os_de,&test)!=1)error();
+ checkpacket(&test,34,10,-1);
+ fprintf(stderr,"ok.\n");
+ }
+
+ /* Test lost pages on pagein/packetout: rollback with continuation */
+ {
+ ogg_page temp;
+ ogg_packet test;
+
+ fprintf(stderr,"Testing loss of pages (rollback required)... ");
+
+ ogg_sync_reset(&oy);
+ ogg_stream_reset(&os_de);
+ for(i=0;i<5;i++){
+ memcpy(ogg_sync_buffer(&oy,og[i].header_len),og[i].header,
+ og[i].header_len);
+ ogg_sync_wrote(&oy,og[i].header_len);
+ memcpy(ogg_sync_buffer(&oy,og[i].body_len),og[i].body,og[i].body_len);
+ ogg_sync_wrote(&oy,og[i].body_len);
+ }
+
+ ogg_sync_pageout(&oy,&temp);
+ ogg_stream_pagein(&os_de,&temp);
+ ogg_sync_pageout(&oy,&temp);
+ ogg_stream_pagein(&os_de,&temp);
+ ogg_sync_pageout(&oy,&temp);
+ ogg_stream_pagein(&os_de,&temp);
+ ogg_sync_pageout(&oy,&temp);
+ /* skip */
+ ogg_sync_pageout(&oy,&temp);
+ ogg_stream_pagein(&os_de,&temp);
+
+ /* do we get the expected results/packets? */
+
+ if(ogg_stream_packetout(&os_de,&test)!=1)error();
+ checkpacket(&test,0,0,0);
+ if(ogg_stream_packetout(&os_de,&test)!=1)error();
+ checkpacket(&test,1,1,-1);
+ if(ogg_stream_packetout(&os_de,&test)!=1)error();
+ checkpacket(&test,1,2,-1);
+ if(ogg_stream_packetout(&os_de,&test)!=1)error();
+ checkpacket(&test,98,3,-1);
+ if(ogg_stream_packetout(&os_de,&test)!=1)error();
+ checkpacket(&test,4079,4,5000);
+ if(ogg_stream_packetout(&os_de,&test)!=1)error();
+ checkpacket(&test,1,5,-1);
+ if(ogg_stream_packetout(&os_de,&test)!=1)error();
+ checkpacket(&test,1,6,-1);
+ if(ogg_stream_packetout(&os_de,&test)!=1)error();
+ checkpacket(&test,2954,7,-1);
+ if(ogg_stream_packetout(&os_de,&test)!=1)error();
+ checkpacket(&test,2057,8,9000);
+ if(ogg_stream_packetout(&os_de,&test)!=-1){
+ fprintf(stderr,"Error: loss of page did not return error\n");
+ exit(1);
+ }
+ if(ogg_stream_packetout(&os_de,&test)!=1)error();
+ checkpacket(&test,300,17,18000);
+ fprintf(stderr,"ok.\n");
+ }
+
+ /* the rest only test sync */
+ {
+ ogg_page og_de;
+ /* Test fractional page inputs: incomplete capture */
+ fprintf(stderr,"Testing sync on partial inputs... ");
+ ogg_sync_reset(&oy);
+ memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
+ 3);
+ ogg_sync_wrote(&oy,3);
+ if(ogg_sync_pageout(&oy,&og_de)>0)error();
+
+ /* Test fractional page inputs: incomplete fixed header */
+ memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+3,
+ 20);
+ ogg_sync_wrote(&oy,20);
+ if(ogg_sync_pageout(&oy,&og_de)>0)error();
+
+ /* Test fractional page inputs: incomplete header */
+ memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+23,
+ 5);
+ ogg_sync_wrote(&oy,5);
+ if(ogg_sync_pageout(&oy,&og_de)>0)error();
+
+ /* Test fractional page inputs: incomplete body */
+
+ memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+28,
+ og[1].header_len-28);
+ ogg_sync_wrote(&oy,og[1].header_len-28);
+ if(ogg_sync_pageout(&oy,&og_de)>0)error();
+
+ memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,1000);
+ ogg_sync_wrote(&oy,1000);
+ if(ogg_sync_pageout(&oy,&og_de)>0)error();
+
+ memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body+1000,
+ og[1].body_len-1000);
+ ogg_sync_wrote(&oy,og[1].body_len-1000);
+ if(ogg_sync_pageout(&oy,&og_de)<=0)error();
+
+ fprintf(stderr,"ok.\n");
+ }
+
+ /* Test fractional page inputs: page + incomplete capture */
+ {
+ ogg_page og_de;
+ fprintf(stderr,"Testing sync on 1+partial inputs... ");
+ ogg_sync_reset(&oy);
+
+ memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
+ og[1].header_len);
+ ogg_sync_wrote(&oy,og[1].header_len);
+
+ memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
+ og[1].body_len);
+ ogg_sync_wrote(&oy,og[1].body_len);
+
+ memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
+ 20);
+ ogg_sync_wrote(&oy,20);
+ if(ogg_sync_pageout(&oy,&og_de)<=0)error();
+ if(ogg_sync_pageout(&oy,&og_de)>0)error();
+
+ memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+20,
+ og[1].header_len-20);
+ ogg_sync_wrote(&oy,og[1].header_len-20);
+ memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
+ og[1].body_len);
+ ogg_sync_wrote(&oy,og[1].body_len);
+ if(ogg_sync_pageout(&oy,&og_de)<=0)error();
+
+ fprintf(stderr,"ok.\n");
+ }
+
+ /* Test recapture: garbage + page */
+ {
+ ogg_page og_de;
+ fprintf(stderr,"Testing search for capture... ");
+ ogg_sync_reset(&oy);
+
+ /* 'garbage' */
+ memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
+ og[1].body_len);
+ ogg_sync_wrote(&oy,og[1].body_len);
+
+ memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
+ og[1].header_len);
+ ogg_sync_wrote(&oy,og[1].header_len);
+
+ memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
+ og[1].body_len);
+ ogg_sync_wrote(&oy,og[1].body_len);
+
+ memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header,
+ 20);
+ ogg_sync_wrote(&oy,20);
+ if(ogg_sync_pageout(&oy,&og_de)>0)error();
+ if(ogg_sync_pageout(&oy,&og_de)<=0)error();
+ if(ogg_sync_pageout(&oy,&og_de)>0)error();
+
+ memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header+20,
+ og[2].header_len-20);
+ ogg_sync_wrote(&oy,og[2].header_len-20);
+ memcpy(ogg_sync_buffer(&oy,og[2].body_len),og[2].body,
+ og[2].body_len);
+ ogg_sync_wrote(&oy,og[2].body_len);
+ if(ogg_sync_pageout(&oy,&og_de)<=0)error();
+
+ fprintf(stderr,"ok.\n");
+ }
+
+ /* Test recapture: page + garbage + page */
+ {
+ ogg_page og_de;
+ fprintf(stderr,"Testing recapture... ");
+ ogg_sync_reset(&oy);
+
+ memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
+ og[1].header_len);
+ ogg_sync_wrote(&oy,og[1].header_len);
+
+ memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
+ og[1].body_len);
+ ogg_sync_wrote(&oy,og[1].body_len);
+
+ memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header,
+ og[2].header_len);
+ ogg_sync_wrote(&oy,og[2].header_len);
+
+ memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header,
+ og[2].header_len);
+ ogg_sync_wrote(&oy,og[2].header_len);
+
+ if(ogg_sync_pageout(&oy,&og_de)<=0)error();
+
+ memcpy(ogg_sync_buffer(&oy,og[2].body_len),og[2].body,
+ og[2].body_len-5);
+ ogg_sync_wrote(&oy,og[2].body_len-5);
+
+ memcpy(ogg_sync_buffer(&oy,og[3].header_len),og[3].header,
+ og[3].header_len);
+ ogg_sync_wrote(&oy,og[3].header_len);
+
+ memcpy(ogg_sync_buffer(&oy,og[3].body_len),og[3].body,
+ og[3].body_len);
+ ogg_sync_wrote(&oy,og[3].body_len);
+
+ if(ogg_sync_pageout(&oy,&og_de)>0)error();
+ if(ogg_sync_pageout(&oy,&og_de)<=0)error();
+
+ fprintf(stderr,"ok.\n");
+ }
+
+ /* Free page data that was previously copied */
+ {
+ for(i=0;i<5;i++){
+ free_page(&og[i]);
+ }
+ }
+ }
+
+ return(0);
+}
+
+#endif
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2007 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: toplevel libogg include
+ last mod: $Id: ogg.h 18044 2011-08-01 17:55:20Z gmaxwell $
+
+ ********************************************************************/
+#ifndef _OGG_H
+#define _OGG_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+#include <ogg/os_types.h>
+
+typedef struct {
+ void *iov_base;
+ size_t iov_len;
+} ogg_iovec_t;
+
+typedef struct {
+ long endbyte;
+ int endbit;
+
+ unsigned char *buffer;
+ unsigned char *ptr;
+ long storage;
+} oggpack_buffer;
+
+/* ogg_page is used to encapsulate the data in one Ogg bitstream page *****/
+
+typedef struct {
+ unsigned char *header;
+ long header_len;
+ unsigned char *body;
+ long body_len;
+} ogg_page;
+
+/* ogg_stream_state contains the current encode/decode state of a logical
+ Ogg bitstream **********************************************************/
+
+typedef struct {
+ unsigned char *body_data; /* bytes from packet bodies */
+ long body_storage; /* storage elements allocated */
+ long body_fill; /* elements stored; fill mark */
+ long body_returned; /* elements of fill returned */
+
+
+ int *lacing_vals; /* The values that will go to the segment table */
+ ogg_int64_t *granule_vals; /* granulepos values for headers. Not compact
+ this way, but it is simple coupled to the
+ lacing fifo */
+ long lacing_storage;
+ long lacing_fill;
+ long lacing_packet;
+ long lacing_returned;
+
+ unsigned char header[282]; /* working space for header encode */
+ int header_fill;
+
+ int e_o_s; /* set when we have buffered the last packet in the
+ logical bitstream */
+ int b_o_s; /* set after we've written the initial page
+ of a logical bitstream */
+ long serialno;
+ long pageno;
+ ogg_int64_t packetno; /* sequence number for decode; the framing
+ knows where there's a hole in the data,
+ but we need coupling so that the codec
+ (which is in a separate abstraction
+ layer) also knows about the gap */
+ ogg_int64_t granulepos;
+
+} ogg_stream_state;
+
+/* ogg_packet is used to encapsulate the data and metadata belonging
+ to a single raw Ogg/Vorbis packet *************************************/
+
+typedef struct {
+ unsigned char *packet;
+ long bytes;
+ long b_o_s;
+ long e_o_s;
+
+ ogg_int64_t granulepos;
+
+ ogg_int64_t packetno; /* sequence number for decode; the framing
+ knows where there's a hole in the data,
+ but we need coupling so that the codec
+ (which is in a separate abstraction
+ layer) also knows about the gap */
+} ogg_packet;
+
+typedef struct {
+ unsigned char *data;
+ int storage;
+ int fill;
+ int returned;
+
+ int unsynced;
+ int headerbytes;
+ int bodybytes;
+} ogg_sync_state;
+
+/* Ogg BITSTREAM PRIMITIVES: bitstream ************************/
+
+extern void oggpack_writeinit(oggpack_buffer *b);
+extern int oggpack_writecheck(oggpack_buffer *b);
+extern void oggpack_writetrunc(oggpack_buffer *b,long bits);
+extern void oggpack_writealign(oggpack_buffer *b);
+extern void oggpack_writecopy(oggpack_buffer *b,void *source,long bits);
+extern void oggpack_reset(oggpack_buffer *b);
+extern void oggpack_writeclear(oggpack_buffer *b);
+extern void oggpack_readinit(oggpack_buffer *b,unsigned char *buf,int bytes);
+extern void oggpack_write(oggpack_buffer *b,unsigned long value,int bits);
+extern long oggpack_look(oggpack_buffer *b,int bits);
+extern long oggpack_look1(oggpack_buffer *b);
+extern void oggpack_adv(oggpack_buffer *b,int bits);
+extern void oggpack_adv1(oggpack_buffer *b);
+extern long oggpack_read(oggpack_buffer *b,int bits);
+extern long oggpack_read1(oggpack_buffer *b);
+extern long oggpack_bytes(oggpack_buffer *b);
+extern long oggpack_bits(oggpack_buffer *b);
+extern unsigned char *oggpack_get_buffer(oggpack_buffer *b);
+
+extern void oggpackB_writeinit(oggpack_buffer *b);
+extern int oggpackB_writecheck(oggpack_buffer *b);
+extern void oggpackB_writetrunc(oggpack_buffer *b,long bits);
+extern void oggpackB_writealign(oggpack_buffer *b);
+extern void oggpackB_writecopy(oggpack_buffer *b,void *source,long bits);
+extern void oggpackB_reset(oggpack_buffer *b);
+extern void oggpackB_writeclear(oggpack_buffer *b);
+extern void oggpackB_readinit(oggpack_buffer *b,unsigned char *buf,int bytes);
+extern void oggpackB_write(oggpack_buffer *b,unsigned long value,int bits);
+extern long oggpackB_look(oggpack_buffer *b,int bits);
+extern long oggpackB_look1(oggpack_buffer *b);
+extern void oggpackB_adv(oggpack_buffer *b,int bits);
+extern void oggpackB_adv1(oggpack_buffer *b);
+extern long oggpackB_read(oggpack_buffer *b,int bits);
+extern long oggpackB_read1(oggpack_buffer *b);
+extern long oggpackB_bytes(oggpack_buffer *b);
+extern long oggpackB_bits(oggpack_buffer *b);
+extern unsigned char *oggpackB_get_buffer(oggpack_buffer *b);
+
+/* Ogg BITSTREAM PRIMITIVES: encoding **************************/
+
+extern int ogg_stream_packetin(ogg_stream_state *os, ogg_packet *op);
+extern int ogg_stream_iovecin(ogg_stream_state *os, ogg_iovec_t *iov,
+ int count, long e_o_s, ogg_int64_t granulepos);
+extern int ogg_stream_pageout(ogg_stream_state *os, ogg_page *og);
+extern int ogg_stream_pageout_fill(ogg_stream_state *os, ogg_page *og, int nfill);
+extern int ogg_stream_flush(ogg_stream_state *os, ogg_page *og);
+extern int ogg_stream_flush_fill(ogg_stream_state *os, ogg_page *og, int nfill);
+
+/* Ogg BITSTREAM PRIMITIVES: decoding **************************/
+
+extern int ogg_sync_init(ogg_sync_state *oy);
+extern int ogg_sync_clear(ogg_sync_state *oy);
+extern int ogg_sync_reset(ogg_sync_state *oy);
+extern int ogg_sync_destroy(ogg_sync_state *oy);
+extern int ogg_sync_check(ogg_sync_state *oy);
+
+extern char *ogg_sync_buffer(ogg_sync_state *oy, long size);
+extern int ogg_sync_wrote(ogg_sync_state *oy, long bytes);
+extern long ogg_sync_pageseek(ogg_sync_state *oy,ogg_page *og);
+extern int ogg_sync_pageout(ogg_sync_state *oy, ogg_page *og);
+extern int ogg_stream_pagein(ogg_stream_state *os, ogg_page *og);
+extern int ogg_stream_packetout(ogg_stream_state *os,ogg_packet *op);
+extern int ogg_stream_packetpeek(ogg_stream_state *os,ogg_packet *op);
+
+/* Ogg BITSTREAM PRIMITIVES: general ***************************/
+
+extern int ogg_stream_init(ogg_stream_state *os,int serialno);
+extern int ogg_stream_clear(ogg_stream_state *os);
+extern int ogg_stream_reset(ogg_stream_state *os);
+extern int ogg_stream_reset_serialno(ogg_stream_state *os,int serialno);
+extern int ogg_stream_destroy(ogg_stream_state *os);
+extern int ogg_stream_check(ogg_stream_state *os);
+extern int ogg_stream_eos(ogg_stream_state *os);
+
+extern void ogg_page_checksum_set(ogg_page *og);
+
+extern int ogg_page_version(const ogg_page *og);
+extern int ogg_page_continued(const ogg_page *og);
+extern int ogg_page_bos(const ogg_page *og);
+extern int ogg_page_eos(const ogg_page *og);
+extern ogg_int64_t ogg_page_granulepos(const ogg_page *og);
+extern int ogg_page_serialno(const ogg_page *og);
+extern long ogg_page_pageno(const ogg_page *og);
+extern int ogg_page_packets(const ogg_page *og);
+
+extern void ogg_packet_clear(ogg_packet *op);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _OGG_H */
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2002 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: #ifdef jail to whip a few platforms into the UNIX ideal.
+ last mod: $Id: os_types.h 17712 2010-12-03 17:10:02Z xiphmont $
+
+ ********************************************************************/
+#ifndef _OS_TYPES_H
+#define _OS_TYPES_H
+
+/* make it easy on the folks that want to compile the libs with a
+ different malloc than stdlib */
+#define _ogg_malloc malloc
+#define _ogg_calloc calloc
+#define _ogg_realloc realloc
+#define _ogg_free free
+
+#if defined(_WIN32)
+
+# if defined(__CYGWIN__)
+# include <stdint.h>
+ typedef int16_t ogg_int16_t;
+ typedef uint16_t ogg_uint16_t;
+ typedef int32_t ogg_int32_t;
+ typedef uint32_t ogg_uint32_t;
+ typedef int64_t ogg_int64_t;
+ typedef uint64_t ogg_uint64_t;
+# elif defined(__MINGW32__)
+# include <sys/types.h>
+ typedef short ogg_int16_t;
+ typedef unsigned short ogg_uint16_t;
+ typedef int ogg_int32_t;
+ typedef unsigned int ogg_uint32_t;
+ typedef long long ogg_int64_t;
+ typedef unsigned long long ogg_uint64_t;
+# elif defined(__MWERKS__)
+ typedef long long ogg_int64_t;
+ typedef int ogg_int32_t;
+ typedef unsigned int ogg_uint32_t;
+ typedef short ogg_int16_t;
+ typedef unsigned short ogg_uint16_t;
+# else
+ /* MSVC/Borland */
+ typedef __int64 ogg_int64_t;
+ typedef __int32 ogg_int32_t;
+ typedef unsigned __int32 ogg_uint32_t;
+ typedef __int16 ogg_int16_t;
+ typedef unsigned __int16 ogg_uint16_t;
+# endif
+
+#elif defined(__MACOS__)
+
+# include <sys/types.h>
+ typedef SInt16 ogg_int16_t;
+ typedef UInt16 ogg_uint16_t;
+ typedef SInt32 ogg_int32_t;
+ typedef UInt32 ogg_uint32_t;
+ typedef SInt64 ogg_int64_t;
+
+#elif (defined(__APPLE__) && defined(__MACH__)) /* MacOS X Framework build */
+
+# include <inttypes.h>
+ typedef int16_t ogg_int16_t;
+ typedef uint16_t ogg_uint16_t;
+ typedef int32_t ogg_int32_t;
+ typedef uint32_t ogg_uint32_t;
+ typedef int64_t ogg_int64_t;
+
+#elif defined(__HAIKU__)
+
+ /* Haiku */
+# include <sys/types.h>
+ typedef short ogg_int16_t;
+ typedef unsigned short ogg_uint16_t;
+ typedef int ogg_int32_t;
+ typedef unsigned int ogg_uint32_t;
+ typedef long long ogg_int64_t;
+
+#elif defined(__BEOS__)
+
+ /* Be */
+# include <inttypes.h>
+ typedef int16_t ogg_int16_t;
+ typedef uint16_t ogg_uint16_t;
+ typedef int32_t ogg_int32_t;
+ typedef uint32_t ogg_uint32_t;
+ typedef int64_t ogg_int64_t;
+
+#elif defined (__EMX__)
+
+ /* OS/2 GCC */
+ typedef short ogg_int16_t;
+ typedef unsigned short ogg_uint16_t;
+ typedef int ogg_int32_t;
+ typedef unsigned int ogg_uint32_t;
+ typedef long long ogg_int64_t;
+
+#elif defined (DJGPP)
+
+ /* DJGPP */
+ typedef short ogg_int16_t;
+ typedef int ogg_int32_t;
+ typedef unsigned int ogg_uint32_t;
+ typedef long long ogg_int64_t;
+
+#elif defined(R5900)
+
+ /* PS2 EE */
+ typedef long ogg_int64_t;
+ typedef int ogg_int32_t;
+ typedef unsigned ogg_uint32_t;
+ typedef short ogg_int16_t;
+
+#elif defined(__SYMBIAN32__)
+
+ /* Symbian GCC */
+ typedef signed short ogg_int16_t;
+ typedef unsigned short ogg_uint16_t;
+ typedef signed int ogg_int32_t;
+ typedef unsigned int ogg_uint32_t;
+ typedef long long int ogg_int64_t;
+
+#elif defined(__TMS320C6X__)
+
+ /* TI C64x compiler */
+ typedef signed short ogg_int16_t;
+ typedef unsigned short ogg_uint16_t;
+ typedef signed int ogg_int32_t;
+ typedef unsigned int ogg_uint32_t;
+ typedef long long int ogg_int64_t;
+
+#else
+
+# include <ogg/config_types.h>
+
+#endif
+
+#endif /* _OS_TYPES_H */
--- /dev/null
+Monty <monty@xiph.org>
+
+and the rest of the Xiph.org Foundation.
--- /dev/null
+Copyright (c) 2002-2008 Xiph.org Foundation
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+- Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+- Neither the name of the Xiph.org Foundation nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--- /dev/null
+obj = analysis.o bitrate.o block.o codebook.o envelope.o floor0.o floor1.o \
+ info.o lookup.o lpc.o lsp.o mapping0.o mdct.o psy.o registry.o res0.o \
+ sharedbook.o smallft.o synthesis.o vorbisenc.o vorbisfile.o window.o
+
+liba = ../libvorbis.a
+
+CFLAGS = -O3 -I.
+
+$(liba): $(obj)
+ $(AR) rcs $@ $(obj)
+
+.PHONY: clean
+clean:
+ rm -f $(obj) $(liba)
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2007 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: single-block PCM analysis mode dispatch
+ last mod: $Id: analysis.c 16226 2009-07-08 06:43:49Z xiphmont $
+
+ ********************************************************************/
+
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <ogg/ogg.h>
+#include "vorbis/codec.h"
+#include "codec_internal.h"
+#include "registry.h"
+#include "scales.h"
+#include "os.h"
+#include "misc.h"
+
+/* decides between modes, dispatches to the appropriate mapping. */
+int vorbis_analysis(vorbis_block *vb, ogg_packet *op){
+ int ret,i;
+ vorbis_block_internal *vbi=vb->internal;
+
+ vb->glue_bits=0;
+ vb->time_bits=0;
+ vb->floor_bits=0;
+ vb->res_bits=0;
+
+ /* first things first. Make sure encode is ready */
+ for(i=0;i<PACKETBLOBS;i++)
+ oggpack_reset(vbi->packetblob[i]);
+
+ /* we only have one mapping type (0), and we let the mapping code
+ itself figure out what soft mode to use. This allows easier
+ bitrate management */
+
+ if((ret=_mapping_P[0]->forward(vb)))
+ return(ret);
+
+ if(op){
+ if(vorbis_bitrate_managed(vb))
+ /* The app is using a bitmanaged mode... but not using the
+ bitrate management interface. */
+ return(OV_EINVAL);
+
+ op->packet=oggpack_get_buffer(&vb->opb);
+ op->bytes=oggpack_bytes(&vb->opb);
+ op->b_o_s=0;
+ op->e_o_s=vb->eofflag;
+ op->granulepos=vb->granulepos;
+ op->packetno=vb->sequence; /* for sake of completeness */
+ }
+ return(0);
+}
+
+#ifdef ANALYSIS
+int analysis_noisy=1;
+
+/* there was no great place to put this.... */
+void _analysis_output_always(char *base,int i,float *v,int n,int bark,int dB,ogg_int64_t off){
+ int j;
+ FILE *of;
+ char buffer[80];
+
+ sprintf(buffer,"%s_%d.m",base,i);
+ of=fopen(buffer,"w");
+
+ if(!of)perror("failed to open data dump file");
+
+ for(j=0;j<n;j++){
+ if(bark){
+ float b=toBARK((4000.f*j/n)+.25);
+ fprintf(of,"%f ",b);
+ }else
+ if(off!=0)
+ fprintf(of,"%f ",(double)(j+off)/8000.);
+ else
+ fprintf(of,"%f ",(double)j);
+
+ if(dB){
+ float val;
+ if(v[j]==0.)
+ val=-140.;
+ else
+ val=todB(v+j);
+ fprintf(of,"%f\n",val);
+ }else{
+ fprintf(of,"%f\n",v[j]);
+ }
+ }
+ fclose(of);
+}
+
+void _analysis_output(char *base,int i,float *v,int n,int bark,int dB,
+ ogg_int64_t off){
+ if(analysis_noisy)_analysis_output_always(base,i,v,n,bark,dB,off);
+}
+
+#endif
+
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: libvorbis backend and mapping structures; needed for
+ static mode headers
+ last mod: $Id: backends.h 16962 2010-03-11 07:30:34Z xiphmont $
+
+ ********************************************************************/
+
+/* this is exposed up here because we need it for static modes.
+ Lookups for each backend aren't exposed because there's no reason
+ to do so */
+
+#ifndef _vorbis_backend_h_
+#define _vorbis_backend_h_
+
+#include "codec_internal.h"
+
+/* this would all be simpler/shorter with templates, but.... */
+/* Floor backend generic *****************************************/
+typedef struct{
+ void (*pack) (vorbis_info_floor *,oggpack_buffer *);
+ vorbis_info_floor *(*unpack)(vorbis_info *,oggpack_buffer *);
+ vorbis_look_floor *(*look) (vorbis_dsp_state *,vorbis_info_floor *);
+ void (*free_info) (vorbis_info_floor *);
+ void (*free_look) (vorbis_look_floor *);
+ void *(*inverse1) (struct vorbis_block *,vorbis_look_floor *);
+ int (*inverse2) (struct vorbis_block *,vorbis_look_floor *,
+ void *buffer,float *);
+} vorbis_func_floor;
+
+typedef struct{
+ int order;
+ long rate;
+ long barkmap;
+
+ int ampbits;
+ int ampdB;
+
+ int numbooks; /* <= 16 */
+ int books[16];
+
+ float lessthan; /* encode-only config setting hacks for libvorbis */
+ float greaterthan; /* encode-only config setting hacks for libvorbis */
+
+} vorbis_info_floor0;
+
+
+#define VIF_POSIT 63
+#define VIF_CLASS 16
+#define VIF_PARTS 31
+typedef struct{
+ int partitions; /* 0 to 31 */
+ int partitionclass[VIF_PARTS]; /* 0 to 15 */
+
+ int class_dim[VIF_CLASS]; /* 1 to 8 */
+ int class_subs[VIF_CLASS]; /* 0,1,2,3 (bits: 1<<n poss) */
+ int class_book[VIF_CLASS]; /* subs ^ dim entries */
+ int class_subbook[VIF_CLASS][8]; /* [VIF_CLASS][subs] */
+
+
+ int mult; /* 1 2 3 or 4 */
+ int postlist[VIF_POSIT+2]; /* first two implicit */
+
+
+ /* encode side analysis parameters */
+ float maxover;
+ float maxunder;
+ float maxerr;
+
+ float twofitweight;
+ float twofitatten;
+
+ int n;
+
+} vorbis_info_floor1;
+
+/* Residue backend generic *****************************************/
+typedef struct{
+ void (*pack) (vorbis_info_residue *,oggpack_buffer *);
+ vorbis_info_residue *(*unpack)(vorbis_info *,oggpack_buffer *);
+ vorbis_look_residue *(*look) (vorbis_dsp_state *,
+ vorbis_info_residue *);
+ void (*free_info) (vorbis_info_residue *);
+ void (*free_look) (vorbis_look_residue *);
+ long **(*class) (struct vorbis_block *,vorbis_look_residue *,
+ int **,int *,int);
+ int (*forward) (oggpack_buffer *,struct vorbis_block *,
+ vorbis_look_residue *,
+ int **,int *,int,long **,int);
+ int (*inverse) (struct vorbis_block *,vorbis_look_residue *,
+ float **,int *,int);
+} vorbis_func_residue;
+
+typedef struct vorbis_info_residue0{
+/* block-partitioned VQ coded straight residue */
+ long begin;
+ long end;
+
+ /* first stage (lossless partitioning) */
+ int grouping; /* group n vectors per partition */
+ int partitions; /* possible codebooks for a partition */
+ int partvals; /* partitions ^ groupbook dim */
+ int groupbook; /* huffbook for partitioning */
+ int secondstages[64]; /* expanded out to pointers in lookup */
+ int booklist[512]; /* list of second stage books */
+
+ const int classmetric1[64];
+ const int classmetric2[64];
+} vorbis_info_residue0;
+
+/* Mapping backend generic *****************************************/
+typedef struct{
+ void (*pack) (vorbis_info *,vorbis_info_mapping *,
+ oggpack_buffer *);
+ vorbis_info_mapping *(*unpack)(vorbis_info *,oggpack_buffer *);
+ void (*free_info) (vorbis_info_mapping *);
+ int (*forward) (struct vorbis_block *vb);
+ int (*inverse) (struct vorbis_block *vb,vorbis_info_mapping *);
+} vorbis_func_mapping;
+
+typedef struct vorbis_info_mapping0{
+ int submaps; /* <= 16 */
+ int chmuxlist[256]; /* up to 256 channels in a Vorbis stream */
+
+ int floorsubmap[16]; /* [mux] submap to floors */
+ int residuesubmap[16]; /* [mux] submap to residue */
+
+ int coupling_steps;
+ int coupling_mag[256];
+ int coupling_ang[256];
+
+} vorbis_info_mapping0;
+
+#endif
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: bitrate tracking and management
+ last mod: $Id: bitrate.c 16227 2009-07-08 06:58:46Z xiphmont $
+
+ ********************************************************************/
+
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <ogg/ogg.h>
+#include "vorbis/codec.h"
+#include "codec_internal.h"
+#include "os.h"
+#include "misc.h"
+#include "bitrate.h"
+
+/* compute bitrate tracking setup */
+void vorbis_bitrate_init(vorbis_info *vi,bitrate_manager_state *bm){
+ codec_setup_info *ci=vi->codec_setup;
+ bitrate_manager_info *bi=&ci->bi;
+
+ memset(bm,0,sizeof(*bm));
+
+ if(bi && (bi->reservoir_bits>0)){
+ long ratesamples=vi->rate;
+ int halfsamples=ci->blocksizes[0]>>1;
+
+ bm->short_per_long=ci->blocksizes[1]/ci->blocksizes[0];
+ bm->managed=1;
+
+ bm->avg_bitsper= rint(1.*bi->avg_rate*halfsamples/ratesamples);
+ bm->min_bitsper= rint(1.*bi->min_rate*halfsamples/ratesamples);
+ bm->max_bitsper= rint(1.*bi->max_rate*halfsamples/ratesamples);
+
+ bm->avgfloat=PACKETBLOBS/2;
+
+ /* not a necessary fix, but one that leads to a more balanced
+ typical initialization */
+ {
+ long desired_fill=bi->reservoir_bits*bi->reservoir_bias;
+ bm->minmax_reservoir=desired_fill;
+ bm->avg_reservoir=desired_fill;
+ }
+
+ }
+}
+
+void vorbis_bitrate_clear(bitrate_manager_state *bm){
+ memset(bm,0,sizeof(*bm));
+ return;
+}
+
+int vorbis_bitrate_managed(vorbis_block *vb){
+ vorbis_dsp_state *vd=vb->vd;
+ private_state *b=vd->backend_state;
+ bitrate_manager_state *bm=&b->bms;
+
+ if(bm && bm->managed)return(1);
+ return(0);
+}
+
+/* finish taking in the block we just processed */
+int vorbis_bitrate_addblock(vorbis_block *vb){
+ vorbis_block_internal *vbi=vb->internal;
+ vorbis_dsp_state *vd=vb->vd;
+ private_state *b=vd->backend_state;
+ bitrate_manager_state *bm=&b->bms;
+ vorbis_info *vi=vd->vi;
+ codec_setup_info *ci=vi->codec_setup;
+ bitrate_manager_info *bi=&ci->bi;
+
+ int choice=rint(bm->avgfloat);
+ long this_bits=oggpack_bytes(vbi->packetblob[choice])*8;
+ long min_target_bits=(vb->W?bm->min_bitsper*bm->short_per_long:bm->min_bitsper);
+ long max_target_bits=(vb->W?bm->max_bitsper*bm->short_per_long:bm->max_bitsper);
+ int samples=ci->blocksizes[vb->W]>>1;
+ long desired_fill=bi->reservoir_bits*bi->reservoir_bias;
+ if(!bm->managed){
+ /* not a bitrate managed stream, but for API simplicity, we'll
+ buffer the packet to keep the code path clean */
+
+ if(bm->vb)return(-1); /* one has been submitted without
+ being claimed */
+ bm->vb=vb;
+ return(0);
+ }
+
+ bm->vb=vb;
+
+ /* look ahead for avg floater */
+ if(bm->avg_bitsper>0){
+ double slew=0.;
+ long avg_target_bits=(vb->W?bm->avg_bitsper*bm->short_per_long:bm->avg_bitsper);
+ double slewlimit= 15./bi->slew_damp;
+
+ /* choosing a new floater:
+ if we're over target, we slew down
+ if we're under target, we slew up
+
+ choose slew as follows: look through packetblobs of this frame
+ and set slew as the first in the appropriate direction that
+ gives us the slew we want. This may mean no slew if delta is
+ already favorable.
+
+ Then limit slew to slew max */
+
+ if(bm->avg_reservoir+(this_bits-avg_target_bits)>desired_fill){
+ while(choice>0 && this_bits>avg_target_bits &&
+ bm->avg_reservoir+(this_bits-avg_target_bits)>desired_fill){
+ choice--;
+ this_bits=oggpack_bytes(vbi->packetblob[choice])*8;
+ }
+ }else if(bm->avg_reservoir+(this_bits-avg_target_bits)<desired_fill){
+ while(choice+1<PACKETBLOBS && this_bits<avg_target_bits &&
+ bm->avg_reservoir+(this_bits-avg_target_bits)<desired_fill){
+ choice++;
+ this_bits=oggpack_bytes(vbi->packetblob[choice])*8;
+ }
+ }
+
+ slew=rint(choice-bm->avgfloat)/samples*vi->rate;
+ if(slew<-slewlimit)slew=-slewlimit;
+ if(slew>slewlimit)slew=slewlimit;
+ choice=rint(bm->avgfloat+= slew/vi->rate*samples);
+ this_bits=oggpack_bytes(vbi->packetblob[choice])*8;
+ }
+
+
+
+ /* enforce min(if used) on the current floater (if used) */
+ if(bm->min_bitsper>0){
+ /* do we need to force the bitrate up? */
+ if(this_bits<min_target_bits){
+ while(bm->minmax_reservoir-(min_target_bits-this_bits)<0){
+ choice++;
+ if(choice>=PACKETBLOBS)break;
+ this_bits=oggpack_bytes(vbi->packetblob[choice])*8;
+ }
+ }
+ }
+
+ /* enforce max (if used) on the current floater (if used) */
+ if(bm->max_bitsper>0){
+ /* do we need to force the bitrate down? */
+ if(this_bits>max_target_bits){
+ while(bm->minmax_reservoir+(this_bits-max_target_bits)>bi->reservoir_bits){
+ choice--;
+ if(choice<0)break;
+ this_bits=oggpack_bytes(vbi->packetblob[choice])*8;
+ }
+ }
+ }
+
+ /* Choice of packetblobs now made based on floater, and min/max
+ requirements. Now boundary check extreme choices */
+
+ if(choice<0){
+ /* choosing a smaller packetblob is insufficient to trim bitrate.
+ frame will need to be truncated */
+ long maxsize=(max_target_bits+(bi->reservoir_bits-bm->minmax_reservoir))/8;
+ bm->choice=choice=0;
+
+ if(oggpack_bytes(vbi->packetblob[choice])>maxsize){
+
+ oggpack_writetrunc(vbi->packetblob[choice],maxsize*8);
+ this_bits=oggpack_bytes(vbi->packetblob[choice])*8;
+ }
+ }else{
+ long minsize=(min_target_bits-bm->minmax_reservoir+7)/8;
+ if(choice>=PACKETBLOBS)
+ choice=PACKETBLOBS-1;
+
+ bm->choice=choice;
+
+ /* prop up bitrate according to demand. pad this frame out with zeroes */
+ minsize-=oggpack_bytes(vbi->packetblob[choice]);
+ while(minsize-->0)oggpack_write(vbi->packetblob[choice],0,8);
+ this_bits=oggpack_bytes(vbi->packetblob[choice])*8;
+
+ }
+
+ /* now we have the final packet and the final packet size. Update statistics */
+ /* min and max reservoir */
+ if(bm->min_bitsper>0 || bm->max_bitsper>0){
+
+ if(max_target_bits>0 && this_bits>max_target_bits){
+ bm->minmax_reservoir+=(this_bits-max_target_bits);
+ }else if(min_target_bits>0 && this_bits<min_target_bits){
+ bm->minmax_reservoir+=(this_bits-min_target_bits);
+ }else{
+ /* inbetween; we want to take reservoir toward but not past desired_fill */
+ if(bm->minmax_reservoir>desired_fill){
+ if(max_target_bits>0){ /* logical bulletproofing against initialization state */
+ bm->minmax_reservoir+=(this_bits-max_target_bits);
+ if(bm->minmax_reservoir<desired_fill)bm->minmax_reservoir=desired_fill;
+ }else{
+ bm->minmax_reservoir=desired_fill;
+ }
+ }else{
+ if(min_target_bits>0){ /* logical bulletproofing against initialization state */
+ bm->minmax_reservoir+=(this_bits-min_target_bits);
+ if(bm->minmax_reservoir>desired_fill)bm->minmax_reservoir=desired_fill;
+ }else{
+ bm->minmax_reservoir=desired_fill;
+ }
+ }
+ }
+ }
+
+ /* avg reservoir */
+ if(bm->avg_bitsper>0){
+ long avg_target_bits=(vb->W?bm->avg_bitsper*bm->short_per_long:bm->avg_bitsper);
+ bm->avg_reservoir+=this_bits-avg_target_bits;
+ }
+
+ return(0);
+}
+
+int vorbis_bitrate_flushpacket(vorbis_dsp_state *vd,ogg_packet *op){
+ private_state *b=vd->backend_state;
+ bitrate_manager_state *bm=&b->bms;
+ vorbis_block *vb=bm->vb;
+ int choice=PACKETBLOBS/2;
+ if(!vb)return 0;
+
+ if(op){
+ vorbis_block_internal *vbi=vb->internal;
+
+ if(vorbis_bitrate_managed(vb))
+ choice=bm->choice;
+
+ op->packet=oggpack_get_buffer(vbi->packetblob[choice]);
+ op->bytes=oggpack_bytes(vbi->packetblob[choice]);
+ op->b_o_s=0;
+ op->e_o_s=vb->eofflag;
+ op->granulepos=vb->granulepos;
+ op->packetno=vb->sequence; /* for sake of completeness */
+ }
+
+ bm->vb=0;
+ return(1);
+}
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2007 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: bitrate tracking and management
+ last mod: $Id: bitrate.h 13293 2007-07-24 00:09:47Z xiphmont $
+
+ ********************************************************************/
+
+#ifndef _V_BITRATE_H_
+#define _V_BITRATE_H_
+
+#include "vorbis/codec.h"
+#include "codec_internal.h"
+#include "os.h"
+
+/* encode side bitrate tracking */
+typedef struct bitrate_manager_state {
+ int managed;
+
+ long avg_reservoir;
+ long minmax_reservoir;
+ long avg_bitsper;
+ long min_bitsper;
+ long max_bitsper;
+
+ long short_per_long;
+ double avgfloat;
+
+ vorbis_block *vb;
+ int choice;
+} bitrate_manager_state;
+
+typedef struct bitrate_manager_info{
+ long avg_rate;
+ long min_rate;
+ long max_rate;
+ long reservoir_bits;
+ double reservoir_bias;
+
+ double slew_damp;
+
+} bitrate_manager_info;
+
+extern void vorbis_bitrate_init(vorbis_info *vi,bitrate_manager_state *bs);
+extern void vorbis_bitrate_clear(bitrate_manager_state *bs);
+extern int vorbis_bitrate_managed(vorbis_block *vb);
+extern int vorbis_bitrate_addblock(vorbis_block *vb);
+extern int vorbis_bitrate_flushpacket(vorbis_dsp_state *vd, ogg_packet *op);
+
+#endif
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: PCM data vector blocking, windowing and dis/reassembly
+ last mod: $Id: block.c 17561 2010-10-23 10:34:24Z xiphmont $
+
+ Handle windowing, overlap-add, etc of the PCM vectors. This is made
+ more amusing by Vorbis' current two allowed block sizes.
+
+ ********************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ogg/ogg.h>
+#include "vorbis/codec.h"
+#include "codec_internal.h"
+
+#include "window.h"
+#include "mdct.h"
+#include "lpc.h"
+#include "registry.h"
+#include "misc.h"
+
+static int ilog2(unsigned int v){
+ int ret=0;
+ if(v)--v;
+ while(v){
+ ret++;
+ v>>=1;
+ }
+ return(ret);
+}
+
+/* pcm accumulator examples (not exhaustive):
+
+ <-------------- lW ---------------->
+ <--------------- W ---------------->
+: .....|..... _______________ |
+: .''' | '''_--- | |\ |
+:.....''' |_____--- '''......| | \_______|
+:.................|__________________|_______|__|______|
+ |<------ Sl ------>| > Sr < |endW
+ |beginSl |endSl | |endSr
+ |beginW |endlW |beginSr
+
+
+ |< lW >|
+ <--------------- W ---------------->
+ | | .. ______________ |
+ | | ' `/ | ---_ |
+ |___.'___/`. | ---_____|
+ |_______|__|_______|_________________|
+ | >|Sl|< |<------ Sr ----->|endW
+ | | |endSl |beginSr |endSr
+ |beginW | |endlW
+ mult[0] |beginSl mult[n]
+
+ <-------------- lW ----------------->
+ |<--W-->|
+: .............. ___ | |
+: .''' |`/ \ | |
+:.....''' |/`....\|...|
+:.........................|___|___|___|
+ |Sl |Sr |endW
+ | | |endSr
+ | |beginSr
+ | |endSl
+ |beginSl
+ |beginW
+*/
+
+/* block abstraction setup *********************************************/
+
+#ifndef WORD_ALIGN
+#define WORD_ALIGN 8
+#endif
+
+int vorbis_block_init(vorbis_dsp_state *v, vorbis_block *vb){
+ int i;
+ memset(vb,0,sizeof(*vb));
+ vb->vd=v;
+ vb->localalloc=0;
+ vb->localstore=NULL;
+ if(v->analysisp){
+ vorbis_block_internal *vbi=
+ vb->internal=_ogg_calloc(1,sizeof(vorbis_block_internal));
+ vbi->ampmax=-9999;
+
+ for(i=0;i<PACKETBLOBS;i++){
+ if(i==PACKETBLOBS/2){
+ vbi->packetblob[i]=&vb->opb;
+ }else{
+ vbi->packetblob[i]=
+ _ogg_calloc(1,sizeof(oggpack_buffer));
+ }
+ oggpack_writeinit(vbi->packetblob[i]);
+ }
+ }
+
+ return(0);
+}
+
+void *_vorbis_block_alloc(vorbis_block *vb,long bytes){
+ bytes=(bytes+(WORD_ALIGN-1)) & ~(WORD_ALIGN-1);
+ if(bytes+vb->localtop>vb->localalloc){
+ /* can't just _ogg_realloc... there are outstanding pointers */
+ if(vb->localstore){
+ struct alloc_chain *link=_ogg_malloc(sizeof(*link));
+ vb->totaluse+=vb->localtop;
+ link->next=vb->reap;
+ link->ptr=vb->localstore;
+ vb->reap=link;
+ }
+ /* highly conservative */
+ vb->localalloc=bytes;
+ vb->localstore=_ogg_malloc(vb->localalloc);
+ vb->localtop=0;
+ }
+ {
+ void *ret=(void *)(((char *)vb->localstore)+vb->localtop);
+ vb->localtop+=bytes;
+ return ret;
+ }
+}
+
+/* reap the chain, pull the ripcord */
+void _vorbis_block_ripcord(vorbis_block *vb){
+ /* reap the chain */
+ struct alloc_chain *reap=vb->reap;
+ while(reap){
+ struct alloc_chain *next=reap->next;
+ _ogg_free(reap->ptr);
+ memset(reap,0,sizeof(*reap));
+ _ogg_free(reap);
+ reap=next;
+ }
+ /* consolidate storage */
+ if(vb->totaluse){
+ vb->localstore=_ogg_realloc(vb->localstore,vb->totaluse+vb->localalloc);
+ vb->localalloc+=vb->totaluse;
+ vb->totaluse=0;
+ }
+
+ /* pull the ripcord */
+ vb->localtop=0;
+ vb->reap=NULL;
+}
+
+int vorbis_block_clear(vorbis_block *vb){
+ int i;
+ vorbis_block_internal *vbi=vb->internal;
+
+ _vorbis_block_ripcord(vb);
+ if(vb->localstore)_ogg_free(vb->localstore);
+
+ if(vbi){
+ for(i=0;i<PACKETBLOBS;i++){
+ oggpack_writeclear(vbi->packetblob[i]);
+ if(i!=PACKETBLOBS/2)_ogg_free(vbi->packetblob[i]);
+ }
+ _ogg_free(vbi);
+ }
+ memset(vb,0,sizeof(*vb));
+ return(0);
+}
+
+/* Analysis side code, but directly related to blocking. Thus it's
+ here and not in analysis.c (which is for analysis transforms only).
+ The init is here because some of it is shared */
+
+static int _vds_shared_init(vorbis_dsp_state *v,vorbis_info *vi,int encp){
+ int i;
+ codec_setup_info *ci=vi->codec_setup;
+ private_state *b=NULL;
+ int hs;
+
+ if(ci==NULL) return 1;
+ hs=ci->halfrate_flag;
+
+ memset(v,0,sizeof(*v));
+ b=v->backend_state=_ogg_calloc(1,sizeof(*b));
+
+ v->vi=vi;
+ b->modebits=ilog2(ci->modes);
+
+ b->transform[0]=_ogg_calloc(VI_TRANSFORMB,sizeof(*b->transform[0]));
+ b->transform[1]=_ogg_calloc(VI_TRANSFORMB,sizeof(*b->transform[1]));
+
+ /* MDCT is tranform 0 */
+
+ b->transform[0][0]=_ogg_calloc(1,sizeof(mdct_lookup));
+ b->transform[1][0]=_ogg_calloc(1,sizeof(mdct_lookup));
+ mdct_init(b->transform[0][0],ci->blocksizes[0]>>hs);
+ mdct_init(b->transform[1][0],ci->blocksizes[1]>>hs);
+
+ /* Vorbis I uses only window type 0 */
+ b->window[0]=ilog2(ci->blocksizes[0])-6;
+ b->window[1]=ilog2(ci->blocksizes[1])-6;
+
+ if(encp){ /* encode/decode differ here */
+
+ /* analysis always needs an fft */
+ drft_init(&b->fft_look[0],ci->blocksizes[0]);
+ drft_init(&b->fft_look[1],ci->blocksizes[1]);
+
+ /* finish the codebooks */
+ if(!ci->fullbooks){
+ ci->fullbooks=_ogg_calloc(ci->books,sizeof(*ci->fullbooks));
+ for(i=0;i<ci->books;i++)
+ vorbis_book_init_encode(ci->fullbooks+i,ci->book_param[i]);
+ }
+
+ b->psy=_ogg_calloc(ci->psys,sizeof(*b->psy));
+ for(i=0;i<ci->psys;i++){
+ _vp_psy_init(b->psy+i,
+ ci->psy_param[i],
+ &ci->psy_g_param,
+ ci->blocksizes[ci->psy_param[i]->blockflag]/2,
+ vi->rate);
+ }
+
+ v->analysisp=1;
+ }else{
+ /* finish the codebooks */
+ if(!ci->fullbooks){
+ ci->fullbooks=_ogg_calloc(ci->books,sizeof(*ci->fullbooks));
+ for(i=0;i<ci->books;i++){
+ if(ci->book_param[i]==NULL)
+ goto abort_books;
+ if(vorbis_book_init_decode(ci->fullbooks+i,ci->book_param[i]))
+ goto abort_books;
+ /* decode codebooks are now standalone after init */
+ vorbis_staticbook_destroy(ci->book_param[i]);
+ ci->book_param[i]=NULL;
+ }
+ }
+ }
+
+ /* initialize the storage vectors. blocksize[1] is small for encode,
+ but the correct size for decode */
+ v->pcm_storage=ci->blocksizes[1];
+ v->pcm=_ogg_malloc(vi->channels*sizeof(*v->pcm));
+ v->pcmret=_ogg_malloc(vi->channels*sizeof(*v->pcmret));
+ {
+ int i;
+ for(i=0;i<vi->channels;i++)
+ v->pcm[i]=_ogg_calloc(v->pcm_storage,sizeof(*v->pcm[i]));
+ }
+
+ /* all 1 (large block) or 0 (small block) */
+ /* explicitly set for the sake of clarity */
+ v->lW=0; /* previous window size */
+ v->W=0; /* current window size */
+
+ /* all vector indexes */
+ v->centerW=ci->blocksizes[1]/2;
+
+ v->pcm_current=v->centerW;
+
+ /* initialize all the backend lookups */
+ b->flr=_ogg_calloc(ci->floors,sizeof(*b->flr));
+ b->residue=_ogg_calloc(ci->residues,sizeof(*b->residue));
+
+ for(i=0;i<ci->floors;i++)
+ b->flr[i]=_floor_P[ci->floor_type[i]]->
+ look(v,ci->floor_param[i]);
+
+ for(i=0;i<ci->residues;i++)
+ b->residue[i]=_residue_P[ci->residue_type[i]]->
+ look(v,ci->residue_param[i]);
+
+ return 0;
+ abort_books:
+ for(i=0;i<ci->books;i++){
+ if(ci->book_param[i]!=NULL){
+ vorbis_staticbook_destroy(ci->book_param[i]);
+ ci->book_param[i]=NULL;
+ }
+ }
+ vorbis_dsp_clear(v);
+ return -1;
+}
+
+/* arbitrary settings and spec-mandated numbers get filled in here */
+int vorbis_analysis_init(vorbis_dsp_state *v,vorbis_info *vi){
+ private_state *b=NULL;
+
+ if(_vds_shared_init(v,vi,1))return 1;
+ b=v->backend_state;
+ b->psy_g_look=_vp_global_look(vi);
+
+ /* Initialize the envelope state storage */
+ b->ve=_ogg_calloc(1,sizeof(*b->ve));
+ _ve_envelope_init(b->ve,vi);
+
+ vorbis_bitrate_init(vi,&b->bms);
+
+ /* compressed audio packets start after the headers
+ with sequence number 3 */
+ v->sequence=3;
+
+ return(0);
+}
+
+void vorbis_dsp_clear(vorbis_dsp_state *v){
+ int i;
+ if(v){
+ vorbis_info *vi=v->vi;
+ codec_setup_info *ci=(vi?vi->codec_setup:NULL);
+ private_state *b=v->backend_state;
+
+ if(b){
+
+ if(b->ve){
+ _ve_envelope_clear(b->ve);
+ _ogg_free(b->ve);
+ }
+
+ if(b->transform[0]){
+ mdct_clear(b->transform[0][0]);
+ _ogg_free(b->transform[0][0]);
+ _ogg_free(b->transform[0]);
+ }
+ if(b->transform[1]){
+ mdct_clear(b->transform[1][0]);
+ _ogg_free(b->transform[1][0]);
+ _ogg_free(b->transform[1]);
+ }
+
+ if(b->flr){
+ if(ci)
+ for(i=0;i<ci->floors;i++)
+ _floor_P[ci->floor_type[i]]->
+ free_look(b->flr[i]);
+ _ogg_free(b->flr);
+ }
+ if(b->residue){
+ if(ci)
+ for(i=0;i<ci->residues;i++)
+ _residue_P[ci->residue_type[i]]->
+ free_look(b->residue[i]);
+ _ogg_free(b->residue);
+ }
+ if(b->psy){
+ if(ci)
+ for(i=0;i<ci->psys;i++)
+ _vp_psy_clear(b->psy+i);
+ _ogg_free(b->psy);
+ }
+
+ if(b->psy_g_look)_vp_global_free(b->psy_g_look);
+ vorbis_bitrate_clear(&b->bms);
+
+ drft_clear(&b->fft_look[0]);
+ drft_clear(&b->fft_look[1]);
+
+ }
+
+ if(v->pcm){
+ if(vi)
+ for(i=0;i<vi->channels;i++)
+ if(v->pcm[i])_ogg_free(v->pcm[i]);
+ _ogg_free(v->pcm);
+ if(v->pcmret)_ogg_free(v->pcmret);
+ }
+
+ if(b){
+ /* free header, header1, header2 */
+ if(b->header)_ogg_free(b->header);
+ if(b->header1)_ogg_free(b->header1);
+ if(b->header2)_ogg_free(b->header2);
+ _ogg_free(b);
+ }
+
+ memset(v,0,sizeof(*v));
+ }
+}
+
+float **vorbis_analysis_buffer(vorbis_dsp_state *v, int vals){
+ int i;
+ vorbis_info *vi=v->vi;
+ private_state *b=v->backend_state;
+
+ /* free header, header1, header2 */
+ if(b->header)_ogg_free(b->header);b->header=NULL;
+ if(b->header1)_ogg_free(b->header1);b->header1=NULL;
+ if(b->header2)_ogg_free(b->header2);b->header2=NULL;
+
+ /* Do we have enough storage space for the requested buffer? If not,
+ expand the PCM (and envelope) storage */
+
+ if(v->pcm_current+vals>=v->pcm_storage){
+ v->pcm_storage=v->pcm_current+vals*2;
+
+ for(i=0;i<vi->channels;i++){
+ v->pcm[i]=_ogg_realloc(v->pcm[i],v->pcm_storage*sizeof(*v->pcm[i]));
+ }
+ }
+
+ for(i=0;i<vi->channels;i++)
+ v->pcmret[i]=v->pcm[i]+v->pcm_current;
+
+ return(v->pcmret);
+}
+
+static void _preextrapolate_helper(vorbis_dsp_state *v){
+ int i;
+ int order=16;
+ float *lpc=alloca(order*sizeof(*lpc));
+ float *work=alloca(v->pcm_current*sizeof(*work));
+ long j;
+ v->preextrapolate=1;
+
+ if(v->pcm_current-v->centerW>order*2){ /* safety */
+ for(i=0;i<v->vi->channels;i++){
+ /* need to run the extrapolation in reverse! */
+ for(j=0;j<v->pcm_current;j++)
+ work[j]=v->pcm[i][v->pcm_current-j-1];
+
+ /* prime as above */
+ vorbis_lpc_from_data(work,lpc,v->pcm_current-v->centerW,order);
+
+#if 0
+ if(v->vi->channels==2){
+ if(i==0)
+ _analysis_output("predataL",0,work,v->pcm_current-v->centerW,0,0,0);
+ else
+ _analysis_output("predataR",0,work,v->pcm_current-v->centerW,0,0,0);
+ }else{
+ _analysis_output("predata",0,work,v->pcm_current-v->centerW,0,0,0);
+ }
+#endif
+
+ /* run the predictor filter */
+ vorbis_lpc_predict(lpc,work+v->pcm_current-v->centerW-order,
+ order,
+ work+v->pcm_current-v->centerW,
+ v->centerW);
+
+ for(j=0;j<v->pcm_current;j++)
+ v->pcm[i][v->pcm_current-j-1]=work[j];
+
+ }
+ }
+}
+
+
+/* call with val<=0 to set eof */
+
+int vorbis_analysis_wrote(vorbis_dsp_state *v, int vals){
+ vorbis_info *vi=v->vi;
+ codec_setup_info *ci=vi->codec_setup;
+
+ if(vals<=0){
+ int order=32;
+ int i;
+ float *lpc=alloca(order*sizeof(*lpc));
+
+ /* if it wasn't done earlier (very short sample) */
+ if(!v->preextrapolate)
+ _preextrapolate_helper(v);
+
+ /* We're encoding the end of the stream. Just make sure we have
+ [at least] a few full blocks of zeroes at the end. */
+ /* actually, we don't want zeroes; that could drop a large
+ amplitude off a cliff, creating spread spectrum noise that will
+ suck to encode. Extrapolate for the sake of cleanliness. */
+
+ vorbis_analysis_buffer(v,ci->blocksizes[1]*3);
+ v->eofflag=v->pcm_current;
+ v->pcm_current+=ci->blocksizes[1]*3;
+
+ for(i=0;i<vi->channels;i++){
+ if(v->eofflag>order*2){
+ /* extrapolate with LPC to fill in */
+ long n;
+
+ /* make a predictor filter */
+ n=v->eofflag;
+ if(n>ci->blocksizes[1])n=ci->blocksizes[1];
+ vorbis_lpc_from_data(v->pcm[i]+v->eofflag-n,lpc,n,order);
+
+ /* run the predictor filter */
+ vorbis_lpc_predict(lpc,v->pcm[i]+v->eofflag-order,order,
+ v->pcm[i]+v->eofflag,v->pcm_current-v->eofflag);
+ }else{
+ /* not enough data to extrapolate (unlikely to happen due to
+ guarding the overlap, but bulletproof in case that
+ assumtion goes away). zeroes will do. */
+ memset(v->pcm[i]+v->eofflag,0,
+ (v->pcm_current-v->eofflag)*sizeof(*v->pcm[i]));
+
+ }
+ }
+ }else{
+
+ if(v->pcm_current+vals>v->pcm_storage)
+ return(OV_EINVAL);
+
+ v->pcm_current+=vals;
+
+ /* we may want to reverse extrapolate the beginning of a stream
+ too... in case we're beginning on a cliff! */
+ /* clumsy, but simple. It only runs once, so simple is good. */
+ if(!v->preextrapolate && v->pcm_current-v->centerW>ci->blocksizes[1])
+ _preextrapolate_helper(v);
+
+ }
+ return(0);
+}
+
+/* do the deltas, envelope shaping, pre-echo and determine the size of
+ the next block on which to continue analysis */
+int vorbis_analysis_blockout(vorbis_dsp_state *v,vorbis_block *vb){
+ int i;
+ vorbis_info *vi=v->vi;
+ codec_setup_info *ci=vi->codec_setup;
+ private_state *b=v->backend_state;
+ vorbis_look_psy_global *g=b->psy_g_look;
+ long beginW=v->centerW-ci->blocksizes[v->W]/2,centerNext;
+ vorbis_block_internal *vbi=(vorbis_block_internal *)vb->internal;
+
+ /* check to see if we're started... */
+ if(!v->preextrapolate)return(0);
+
+ /* check to see if we're done... */
+ if(v->eofflag==-1)return(0);
+
+ /* By our invariant, we have lW, W and centerW set. Search for
+ the next boundary so we can determine nW (the next window size)
+ which lets us compute the shape of the current block's window */
+
+ /* we do an envelope search even on a single blocksize; we may still
+ be throwing more bits at impulses, and envelope search handles
+ marking impulses too. */
+ {
+ long bp=_ve_envelope_search(v);
+ if(bp==-1){
+
+ if(v->eofflag==0)return(0); /* not enough data currently to search for a
+ full long block */
+ v->nW=0;
+ }else{
+
+ if(ci->blocksizes[0]==ci->blocksizes[1])
+ v->nW=0;
+ else
+ v->nW=bp;
+ }
+ }
+
+ centerNext=v->centerW+ci->blocksizes[v->W]/4+ci->blocksizes[v->nW]/4;
+
+ {
+ /* center of next block + next block maximum right side. */
+
+ long blockbound=centerNext+ci->blocksizes[v->nW]/2;
+ if(v->pcm_current<blockbound)return(0); /* not enough data yet;
+ although this check is
+ less strict that the
+ _ve_envelope_search,
+ the search is not run
+ if we only use one
+ block size */
+
+
+ }
+
+ /* fill in the block. Note that for a short window, lW and nW are *short*
+ regardless of actual settings in the stream */
+
+ _vorbis_block_ripcord(vb);
+ vb->lW=v->lW;
+ vb->W=v->W;
+ vb->nW=v->nW;
+
+ if(v->W){
+ if(!v->lW || !v->nW){
+ vbi->blocktype=BLOCKTYPE_TRANSITION;
+ /*fprintf(stderr,"-");*/
+ }else{
+ vbi->blocktype=BLOCKTYPE_LONG;
+ /*fprintf(stderr,"_");*/
+ }
+ }else{
+ if(_ve_envelope_mark(v)){
+ vbi->blocktype=BLOCKTYPE_IMPULSE;
+ /*fprintf(stderr,"|");*/
+
+ }else{
+ vbi->blocktype=BLOCKTYPE_PADDING;
+ /*fprintf(stderr,".");*/
+
+ }
+ }
+
+ vb->vd=v;
+ vb->sequence=v->sequence++;
+ vb->granulepos=v->granulepos;
+ vb->pcmend=ci->blocksizes[v->W];
+
+ /* copy the vectors; this uses the local storage in vb */
+
+ /* this tracks 'strongest peak' for later psychoacoustics */
+ /* moved to the global psy state; clean this mess up */
+ if(vbi->ampmax>g->ampmax)g->ampmax=vbi->ampmax;
+ g->ampmax=_vp_ampmax_decay(g->ampmax,v);
+ vbi->ampmax=g->ampmax;
+
+ vb->pcm=_vorbis_block_alloc(vb,sizeof(*vb->pcm)*vi->channels);
+ vbi->pcmdelay=_vorbis_block_alloc(vb,sizeof(*vbi->pcmdelay)*vi->channels);
+ for(i=0;i<vi->channels;i++){
+ vbi->pcmdelay[i]=
+ _vorbis_block_alloc(vb,(vb->pcmend+beginW)*sizeof(*vbi->pcmdelay[i]));
+ memcpy(vbi->pcmdelay[i],v->pcm[i],(vb->pcmend+beginW)*sizeof(*vbi->pcmdelay[i]));
+ vb->pcm[i]=vbi->pcmdelay[i]+beginW;
+
+ /* before we added the delay
+ vb->pcm[i]=_vorbis_block_alloc(vb,vb->pcmend*sizeof(*vb->pcm[i]));
+ memcpy(vb->pcm[i],v->pcm[i]+beginW,ci->blocksizes[v->W]*sizeof(*vb->pcm[i]));
+ */
+
+ }
+
+ /* handle eof detection: eof==0 means that we've not yet received EOF
+ eof>0 marks the last 'real' sample in pcm[]
+ eof<0 'no more to do'; doesn't get here */
+
+ if(v->eofflag){
+ if(v->centerW>=v->eofflag){
+ v->eofflag=-1;
+ vb->eofflag=1;
+ return(1);
+ }
+ }
+
+ /* advance storage vectors and clean up */
+ {
+ int new_centerNext=ci->blocksizes[1]/2;
+ int movementW=centerNext-new_centerNext;
+
+ if(movementW>0){
+
+ _ve_envelope_shift(b->ve,movementW);
+ v->pcm_current-=movementW;
+
+ for(i=0;i<vi->channels;i++)
+ memmove(v->pcm[i],v->pcm[i]+movementW,
+ v->pcm_current*sizeof(*v->pcm[i]));
+
+
+ v->lW=v->W;
+ v->W=v->nW;
+ v->centerW=new_centerNext;
+
+ if(v->eofflag){
+ v->eofflag-=movementW;
+ if(v->eofflag<=0)v->eofflag=-1;
+ /* do not add padding to end of stream! */
+ if(v->centerW>=v->eofflag){
+ v->granulepos+=movementW-(v->centerW-v->eofflag);
+ }else{
+ v->granulepos+=movementW;
+ }
+ }else{
+ v->granulepos+=movementW;
+ }
+ }
+ }
+
+ /* done */
+ return(1);
+}
+
+int vorbis_synthesis_restart(vorbis_dsp_state *v){
+ vorbis_info *vi=v->vi;
+ codec_setup_info *ci;
+ int hs;
+
+ if(!v->backend_state)return -1;
+ if(!vi)return -1;
+ ci=vi->codec_setup;
+ if(!ci)return -1;
+ hs=ci->halfrate_flag;
+
+ v->centerW=ci->blocksizes[1]>>(hs+1);
+ v->pcm_current=v->centerW>>hs;
+
+ v->pcm_returned=-1;
+ v->granulepos=-1;
+ v->sequence=-1;
+ v->eofflag=0;
+ ((private_state *)(v->backend_state))->sample_count=-1;
+
+ return(0);
+}
+
+int vorbis_synthesis_init(vorbis_dsp_state *v,vorbis_info *vi){
+ if(_vds_shared_init(v,vi,0)){
+ vorbis_dsp_clear(v);
+ return 1;
+ }
+ vorbis_synthesis_restart(v);
+ return 0;
+}
+
+/* Unlike in analysis, the window is only partially applied for each
+ block. The time domain envelope is not yet handled at the point of
+ calling (as it relies on the previous block). */
+
+int vorbis_synthesis_blockin(vorbis_dsp_state *v,vorbis_block *vb){
+ vorbis_info *vi=v->vi;
+ codec_setup_info *ci=vi->codec_setup;
+ private_state *b=v->backend_state;
+ int hs=ci->halfrate_flag;
+ int i,j;
+
+ if(!vb)return(OV_EINVAL);
+ if(v->pcm_current>v->pcm_returned && v->pcm_returned!=-1)return(OV_EINVAL);
+
+ v->lW=v->W;
+ v->W=vb->W;
+ v->nW=-1;
+
+ if((v->sequence==-1)||
+ (v->sequence+1 != vb->sequence)){
+ v->granulepos=-1; /* out of sequence; lose count */
+ b->sample_count=-1;
+ }
+
+ v->sequence=vb->sequence;
+
+ if(vb->pcm){ /* no pcm to process if vorbis_synthesis_trackonly
+ was called on block */
+ int n=ci->blocksizes[v->W]>>(hs+1);
+ int n0=ci->blocksizes[0]>>(hs+1);
+ int n1=ci->blocksizes[1]>>(hs+1);
+
+ int thisCenter;
+ int prevCenter;
+
+ v->glue_bits+=vb->glue_bits;
+ v->time_bits+=vb->time_bits;
+ v->floor_bits+=vb->floor_bits;
+ v->res_bits+=vb->res_bits;
+
+ if(v->centerW){
+ thisCenter=n1;
+ prevCenter=0;
+ }else{
+ thisCenter=0;
+ prevCenter=n1;
+ }
+
+ /* v->pcm is now used like a two-stage double buffer. We don't want
+ to have to constantly shift *or* adjust memory usage. Don't
+ accept a new block until the old is shifted out */
+
+ for(j=0;j<vi->channels;j++){
+ /* the overlap/add section */
+ if(v->lW){
+ if(v->W){
+ /* large/large */
+ float *w=_vorbis_window_get(b->window[1]-hs);
+ float *pcm=v->pcm[j]+prevCenter;
+ float *p=vb->pcm[j];
+ for(i=0;i<n1;i++)
+ pcm[i]=pcm[i]*w[n1-i-1] + p[i]*w[i];
+ }else{
+ /* large/small */
+ float *w=_vorbis_window_get(b->window[0]-hs);
+ float *pcm=v->pcm[j]+prevCenter+n1/2-n0/2;
+ float *p=vb->pcm[j];
+ for(i=0;i<n0;i++)
+ pcm[i]=pcm[i]*w[n0-i-1] +p[i]*w[i];
+ }
+ }else{
+ if(v->W){
+ /* small/large */
+ float *w=_vorbis_window_get(b->window[0]-hs);
+ float *pcm=v->pcm[j]+prevCenter;
+ float *p=vb->pcm[j]+n1/2-n0/2;
+ for(i=0;i<n0;i++)
+ pcm[i]=pcm[i]*w[n0-i-1] +p[i]*w[i];
+ for(;i<n1/2+n0/2;i++)
+ pcm[i]=p[i];
+ }else{
+ /* small/small */
+ float *w=_vorbis_window_get(b->window[0]-hs);
+ float *pcm=v->pcm[j]+prevCenter;
+ float *p=vb->pcm[j];
+ for(i=0;i<n0;i++)
+ pcm[i]=pcm[i]*w[n0-i-1] +p[i]*w[i];
+ }
+ }
+
+ /* the copy section */
+ {
+ float *pcm=v->pcm[j]+thisCenter;
+ float *p=vb->pcm[j]+n;
+ for(i=0;i<n;i++)
+ pcm[i]=p[i];
+ }
+ }
+
+ if(v->centerW)
+ v->centerW=0;
+ else
+ v->centerW=n1;
+
+ /* deal with initial packet state; we do this using the explicit
+ pcm_returned==-1 flag otherwise we're sensitive to first block
+ being short or long */
+
+ if(v->pcm_returned==-1){
+ v->pcm_returned=thisCenter;
+ v->pcm_current=thisCenter;
+ }else{
+ v->pcm_returned=prevCenter;
+ v->pcm_current=prevCenter+
+ ((ci->blocksizes[v->lW]/4+
+ ci->blocksizes[v->W]/4)>>hs);
+ }
+
+ }
+
+ /* track the frame number... This is for convenience, but also
+ making sure our last packet doesn't end with added padding. If
+ the last packet is partial, the number of samples we'll have to
+ return will be past the vb->granulepos.
+
+ This is not foolproof! It will be confused if we begin
+ decoding at the last page after a seek or hole. In that case,
+ we don't have a starting point to judge where the last frame
+ is. For this reason, vorbisfile will always try to make sure
+ it reads the last two marked pages in proper sequence */
+
+ if(b->sample_count==-1){
+ b->sample_count=0;
+ }else{
+ b->sample_count+=ci->blocksizes[v->lW]/4+ci->blocksizes[v->W]/4;
+ }
+
+ if(v->granulepos==-1){
+ if(vb->granulepos!=-1){ /* only set if we have a position to set to */
+
+ v->granulepos=vb->granulepos;
+
+ /* is this a short page? */
+ if(b->sample_count>v->granulepos){
+ /* corner case; if this is both the first and last audio page,
+ then spec says the end is cut, not beginning */
+ long extra=b->sample_count-vb->granulepos;
+
+ /* we use ogg_int64_t for granule positions because a
+ uint64 isn't universally available. Unfortunately,
+ that means granposes can be 'negative' and result in
+ extra being negative */
+ if(extra<0)
+ extra=0;
+
+ if(vb->eofflag){
+ /* trim the end */
+ /* no preceding granulepos; assume we started at zero (we'd
+ have to in a short single-page stream) */
+ /* granulepos could be -1 due to a seek, but that would result
+ in a long count, not short count */
+
+ /* Guard against corrupt/malicious frames that set EOP and
+ a backdated granpos; don't rewind more samples than we
+ actually have */
+ if(extra > (v->pcm_current - v->pcm_returned)<<hs)
+ extra = (v->pcm_current - v->pcm_returned)<<hs;
+
+ v->pcm_current-=extra>>hs;
+ }else{
+ /* trim the beginning */
+ v->pcm_returned+=extra>>hs;
+ if(v->pcm_returned>v->pcm_current)
+ v->pcm_returned=v->pcm_current;
+ }
+
+ }
+
+ }
+ }else{
+ v->granulepos+=ci->blocksizes[v->lW]/4+ci->blocksizes[v->W]/4;
+ if(vb->granulepos!=-1 && v->granulepos!=vb->granulepos){
+
+ if(v->granulepos>vb->granulepos){
+ long extra=v->granulepos-vb->granulepos;
+
+ if(extra)
+ if(vb->eofflag){
+ /* partial last frame. Strip the extra samples off */
+
+ /* Guard against corrupt/malicious frames that set EOP and
+ a backdated granpos; don't rewind more samples than we
+ actually have */
+ if(extra > (v->pcm_current - v->pcm_returned)<<hs)
+ extra = (v->pcm_current - v->pcm_returned)<<hs;
+
+ /* we use ogg_int64_t for granule positions because a
+ uint64 isn't universally available. Unfortunately,
+ that means granposes can be 'negative' and result in
+ extra being negative */
+ if(extra<0)
+ extra=0;
+
+ v->pcm_current-=extra>>hs;
+ } /* else {Shouldn't happen *unless* the bitstream is out of
+ spec. Either way, believe the bitstream } */
+ } /* else {Shouldn't happen *unless* the bitstream is out of
+ spec. Either way, believe the bitstream } */
+ v->granulepos=vb->granulepos;
+ }
+ }
+
+ /* Update, cleanup */
+
+ if(vb->eofflag)v->eofflag=1;
+ return(0);
+
+}
+
+/* pcm==NULL indicates we just want the pending samples, no more */
+int vorbis_synthesis_pcmout(vorbis_dsp_state *v,float ***pcm){
+ vorbis_info *vi=v->vi;
+
+ if(v->pcm_returned>-1 && v->pcm_returned<v->pcm_current){
+ if(pcm){
+ int i;
+ for(i=0;i<vi->channels;i++)
+ v->pcmret[i]=v->pcm[i]+v->pcm_returned;
+ *pcm=v->pcmret;
+ }
+ return(v->pcm_current-v->pcm_returned);
+ }
+ return(0);
+}
+
+int vorbis_synthesis_read(vorbis_dsp_state *v,int n){
+ if(n && v->pcm_returned+n>v->pcm_current)return(OV_EINVAL);
+ v->pcm_returned+=n;
+ return(0);
+}
+
+/* intended for use with a specific vorbisfile feature; we want access
+ to the [usually synthetic/postextrapolated] buffer and lapping at
+ the end of a decode cycle, specifically, a half-short-block worth.
+ This funtion works like pcmout above, except it will also expose
+ this implicit buffer data not normally decoded. */
+int vorbis_synthesis_lapout(vorbis_dsp_state *v,float ***pcm){
+ vorbis_info *vi=v->vi;
+ codec_setup_info *ci=vi->codec_setup;
+ int hs=ci->halfrate_flag;
+
+ int n=ci->blocksizes[v->W]>>(hs+1);
+ int n0=ci->blocksizes[0]>>(hs+1);
+ int n1=ci->blocksizes[1]>>(hs+1);
+ int i,j;
+
+ if(v->pcm_returned<0)return 0;
+
+ /* our returned data ends at pcm_returned; because the synthesis pcm
+ buffer is a two-fragment ring, that means our data block may be
+ fragmented by buffering, wrapping or a short block not filling
+ out a buffer. To simplify things, we unfragment if it's at all
+ possibly needed. Otherwise, we'd need to call lapout more than
+ once as well as hold additional dsp state. Opt for
+ simplicity. */
+
+ /* centerW was advanced by blockin; it would be the center of the
+ *next* block */
+ if(v->centerW==n1){
+ /* the data buffer wraps; swap the halves */
+ /* slow, sure, small */
+ for(j=0;j<vi->channels;j++){
+ float *p=v->pcm[j];
+ for(i=0;i<n1;i++){
+ float temp=p[i];
+ p[i]=p[i+n1];
+ p[i+n1]=temp;
+ }
+ }
+
+ v->pcm_current-=n1;
+ v->pcm_returned-=n1;
+ v->centerW=0;
+ }
+
+ /* solidify buffer into contiguous space */
+ if((v->lW^v->W)==1){
+ /* long/short or short/long */
+ for(j=0;j<vi->channels;j++){
+ float *s=v->pcm[j];
+ float *d=v->pcm[j]+(n1-n0)/2;
+ for(i=(n1+n0)/2-1;i>=0;--i)
+ d[i]=s[i];
+ }
+ v->pcm_returned+=(n1-n0)/2;
+ v->pcm_current+=(n1-n0)/2;
+ }else{
+ if(v->lW==0){
+ /* short/short */
+ for(j=0;j<vi->channels;j++){
+ float *s=v->pcm[j];
+ float *d=v->pcm[j]+n1-n0;
+ for(i=n0-1;i>=0;--i)
+ d[i]=s[i];
+ }
+ v->pcm_returned+=n1-n0;
+ v->pcm_current+=n1-n0;
+ }
+ }
+
+ if(pcm){
+ int i;
+ for(i=0;i<vi->channels;i++)
+ v->pcmret[i]=v->pcm[i]+v->pcm_returned;
+ *pcm=v->pcmret;
+ }
+
+ return(n1+n-v->pcm_returned);
+
+}
+
+float *vorbis_window(vorbis_dsp_state *v,int W){
+ vorbis_info *vi=v->vi;
+ codec_setup_info *ci=vi->codec_setup;
+ int hs=ci->halfrate_flag;
+ private_state *b=v->backend_state;
+
+ if(b->window[W]-1<0)return NULL;
+ return _vorbis_window_get(b->window[W]-hs);
+}
--- /dev/null
+static const long _vq_quantlist__44p0_l0_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44p0_l0_0[] = {
+ 1, 3, 4, 7, 7, 8, 8, 9, 9, 9,10,10,10, 5, 6, 5,
+ 8, 7, 9, 8, 9, 9,10, 9,11,10, 5, 5, 7, 7, 8, 8,
+ 9, 9, 9, 9,10,10,11, 8, 9, 8,10, 9,10, 9,10, 9,
+ 11,10,11,10, 8, 8, 9, 9,10, 9,10, 9,11,10,11,10,
+ 11,10,11,11,11,11,11,11,11,11,11,11,11,11,10,11,
+ 11,11,12,11,11,11,11,11,11,10,12,12,12,12,12,12,
+ 12,11,12,12,12,11,11,11,12,12,12,12,12,12,12,11,
+ 12,11,12,11,11,13,12,12,12,13,12,12,12,12,11,12,
+ 11,11,13,13,13,12,12,12,12,12,12,11,11,11,10,13,
+ 13,13,12,13,12,13,11,13,10,12,11,11,13,13,12,13,
+ 12,12,12,12,11,12,11,11,11,
+};
+
+static const static_codebook _44p0_l0_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44p0_l0_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44p0_l0_0,
+ 0
+};
+
+static const long _vq_quantlist__44p0_l0_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p0_l0_1[] = {
+ 1, 4, 4, 6, 6, 5, 5, 5, 7, 5, 5, 5, 5, 6, 7, 7,
+ 6, 7, 7, 7, 6, 7, 7, 7, 7,
+};
+
+static const static_codebook _44p0_l0_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44p0_l0_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p0_l0_1,
+ 0
+};
+
+static const long _vq_quantlist__44p0_l1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p0_l1_0[] = {
+ 1, 4, 4, 4, 4, 4, 4, 4, 4,
+};
+
+static const static_codebook _44p0_l1_0 = {
+ 2, 9,
+ (long *)_vq_lengthlist__44p0_l1_0,
+ 1, -516716544, 1630767104, 2, 0,
+ (long *)_vq_quantlist__44p0_l1_0,
+ 0
+};
+
+static const long _huff_lengthlist__44p0_lfe[] = {
+ 1, 3, 2, 3,
+};
+
+static const static_codebook _huff_book__44p0_lfe = {
+ 2, 4,
+ (long *)_huff_lengthlist__44p0_lfe,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44p0_long[] = {
+ 2, 3, 6, 7,10,14,16, 3, 2, 5, 7,11,14,17, 6, 5,
+ 5, 7,10,12,14, 7, 7, 6, 6, 7, 9,13,10,11, 9, 6,
+ 6, 9,11,15,15,13,10, 9,10,12,18,18,16,14,12,13,
+ 16,
+};
+
+static const static_codebook _huff_book__44p0_long = {
+ 2, 49,
+ (long *)_huff_lengthlist__44p0_long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44p0_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p0_p1_0[] = {
+ 1, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0,
+};
+
+static const static_codebook _44p0_p1_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p0_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44p0_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44p0_p2_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p0_p2_0[] = {
+ 1, 5, 5, 0, 7, 7, 0, 8, 8, 0, 9, 9, 0,12,12, 0,
+ 8, 8, 0, 9, 9, 0,12,12, 0, 8, 8, 0, 6, 6, 0,11,
+ 11, 0,12,12, 0,12,12, 0,15,15, 0,11,11, 0,12,12,
+ 0,15,15, 0,12,12, 0, 5, 5, 0, 5, 5, 0, 6, 6, 0,
+ 7, 7, 0,11,11, 0, 6, 6, 0, 7, 7, 0,10,11, 0, 6,
+ 6, 0, 7, 7, 0,11,11, 0,12,12, 0,11,11, 0,15,15,
+ 0,10,10, 0,12,12, 0,15,15, 0,12,12, 0, 6, 6, 0,
+ 12,12, 0,12,12, 0,12,12, 0,15,15, 0,11,11, 0,12,
+ 12, 0,15,15, 0,12,12, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 8, 8, 0,12,12, 0,12,12, 0,12,12, 0,15,
+ 15, 0,12,12, 0,11,12, 0,15,16, 0,11,11, 0, 6, 6,
+ 0,11,12, 0,12,12, 0,12,12, 0,16,15, 0,12,12, 0,
+ 13,12, 0,15,14, 0,12,12, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0,
+};
+
+static const static_codebook _44p0_p2_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p0_p2_0,
+ 1, -533200896, 1614282752, 2, 0,
+ (long *)_vq_quantlist__44p0_p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44p0_p2_1[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p0_p2_1[] = {
+ 1, 3, 3, 0, 9, 9, 0, 9, 9, 0,10,10, 0, 9, 9, 0,
+ 10,10, 0,10,10, 0, 9, 9, 0,10,10, 0, 7, 7, 0, 7,
+ 7, 0, 6, 6, 0, 8, 8, 0, 7, 7, 0, 8, 8, 0, 8, 9,
+ 0, 8, 8, 0, 8, 8, 0, 7, 7, 0, 9, 9, 0, 8, 8, 0,
+ 10,10, 0, 9, 9, 0,10,10, 0,10,10, 0, 9, 9, 0,10,
+ 10, 0, 9, 9, 0,11,11, 0,11,11, 0,12,12, 0,11,11,
+ 0,12,12, 0,13,13, 0,12,12, 0,13,12, 0, 8, 8, 0,
+ 12,12, 0,12,12, 0,13,13, 0,12,12, 0,13,13, 0,13,
+ 13, 0,13,13, 0,13,13, 0, 7, 7, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 9, 9, 0,11,11, 0,12,12, 0,13,13, 0,12,
+ 12, 0,13,13, 0,13,13, 0,12,12, 0,12,12, 0, 8, 8,
+ 0,12,12, 0,12,12, 0,13,13, 0,13,13, 0,13,14, 0,
+ 14,13, 0,13,13, 0,13,13, 0, 7, 7, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0,
+};
+
+static const static_codebook _44p0_p2_1 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p0_p2_1,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44p0_p2_1,
+ 0
+};
+
+static const long _vq_quantlist__44p0_p3_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p0_p3_0[] = {
+ 1, 6, 6, 7, 8, 8, 7, 8, 8, 7, 9, 9,10,12,11, 9,
+ 8, 8, 7, 9, 9,11,12,12, 9, 9, 9, 6, 7, 7,10,11,
+ 11,10,11,11,10,11,11,13,13,14,12,12,12,11,11,11,
+ 14,14,14,12,12,12, 6, 5, 5, 9, 6, 5, 9, 6, 6, 9,
+ 7, 7,12,10,10,11, 6, 6,10, 7, 7,13,10,10,12, 7,
+ 7, 7, 8, 8,12,10,10,12,10,10,11,10,10,15,13,13,
+ 13, 9, 9,12,11,11,16,13,13,15,11,11, 8, 7, 7,12,
+ 12,12,12,11,11,12,11,11,14,14,14,14,12,12,12,12,
+ 12,16,15,15,14,12,12, 0,10,10, 0,12,12, 0,12,12,
+ 0,11,11, 0,14,14, 0,11,11, 0,12,12, 0,15,15, 0,
+ 11,11, 8, 8, 8,13,11,11,13,10,10,13,11,11,15,13,
+ 13,14,11,11,12,10,10,16,14,14,14,10,10, 9, 7, 7,
+ 13,11,11,13,11,11,12,11,11,16,14,14,14,12,12,13,
+ 12,12,15,14,14,15,13,12, 0,11,11, 0,12,12, 0,12,
+ 12, 0,12,12, 0,15,15, 0,12,12, 0,13,12, 0,14,15,
+ 0,12,12,
+};
+
+static const static_codebook _44p0_p3_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p0_p3_0,
+ 1, -531365888, 1616117760, 2, 0,
+ (long *)_vq_quantlist__44p0_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44p0_p3_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p0_p3_1[] = {
+ 2, 4, 4, 8, 8,10,12,12,11,11, 9,11,11,12,13,11,
+ 12,12,11,11,11,12,12,12,12,10,13,12,13,13,11,12,
+ 12,13,13,11,12,12,13,13,11,12,13,13,13,11,13,13,
+ 13,13,10,13,13,12,13,11,12,12,14,14,11,13,12,12,
+ 12,11,12,12,13,13,11,13,13,12,12,11,13,13,13,13,
+ 11,12,12,13,13,11,13,13,12,12,11,12,12,13,13,11,
+ 13,13,12,12,11,13,13,13,13,11,12,12,14,14,11,13,
+ 13,12,12,11,12,12,13,13,11,13,13,12,12,11,10,10,
+ 10,10,12,10,10,11,11,11, 8, 8,11,11,13,10,10,10,
+ 10,12,10,10,10,10,13,11,11,11,11,13,10,10,11,11,
+ 13,11,11,12,12,13,11,11,11,11,13,11,11,12,12,13,
+ 11,11,12,12,13,10,10,11,11,13,11,11,11,11,13,11,
+ 10,11,11,13,11,11,11,11,13,11,11,11,11,13,10,10,
+ 11,11,13,11,11,11,11,12,10,11,11,11,13,11,11,11,
+ 11,13,11,11,11,11,13,10,10,11,11,13,11,11,11,11,
+ 13,11,11,11,11,13,11,11,11,11,11,10,10,10,10,12,
+ 10,10, 9, 9,12,12,12,11,11,13,12,12, 9, 9,13,12,
+ 12,10,10,12,12,12,12,12,13,13,13,14,14,13,12,12,
+ 11,11,13,13,13,12,12,13,12,12,11,11,13,12,13,11,
+ 11,13,13,13,14,14,13,12,12,10,10,13,13,13,11,11,
+ 13,12,12,10,10,13,13,13,11,11,13,13,13,14,14,13,
+ 12,12,10,10,13,13,13,11,11,13,12,13,10,10,13,13,
+ 13,11,11,13,13,13,14,14,13,12,12,10,10,13,13,13,
+ 11,11,13,13,12,10,10,14,12,12, 8, 8,14,12,12, 9,
+ 9,14,11,11, 9, 9,14,12,12, 8, 8,14,11,11, 7, 7,
+ 14,13,13,10,10,15,12,12,10,10,15,13,13,10,10,15,
+ 12,12, 9, 9,15,13,13,10,10,15,13,13,10,10,15,12,
+ 12,10,10,15,13,13,10,10,14,12,12, 9, 9,14,13,13,
+ 9, 9,14,13,13, 9, 9,15,12,12, 9, 9,15,13,13, 9,
+ 9,14,12,12, 9, 9,14,13,13, 9, 9,14,13,13, 9, 9,
+ 15,12,12, 9, 9,14,13,13, 9, 9,14,12,12, 9, 9,14,
+ 13,13, 9, 9,13,12,12, 8, 8,13,13,13, 8, 8,14,13,
+ 13, 9, 9,13,13,13, 7, 7,14,13,13, 8, 8,14,14,14,
+ 10,10,14,14,14,11,11,14,14,14, 9, 9,14,14,14,10,
+ 10,14,14,14, 9, 9,14,14,14,10, 9,15,14,14,11,11,
+ 14,14,14, 9, 9,14,14,14,10,10,14,14,14, 9, 9,14,
+ 14,14, 9, 9,15,14,14,11,11,14,14,14, 8, 8,14,14,
+ 14, 9, 9,14,14,14, 8, 8,14,14,14, 9, 9,15,14,14,
+ 11,11,14,14,14, 8, 8,14,14,14, 9, 9,14,14,14, 8,
+ 8,12,12,12,13,13,16,15,15,11,11,16,15,16,12,12,
+ 17,16,16,11,11,17,15,15,12,11,16,16,16,12,13,16,
+ 15,15,13,13,16,16,16,12,12,16,16,15,13,13,16,16,
+ 16,12,12,16,16,16,13,13,17,16,16,14,14,17,17,16,
+ 12,12,17,16,16,13,13,17,17,16,12,13,16,16,17,13,
+ 12,17,16,16,14,13,17,16,16,12,12,17,16,16,12,12,
+ 17,16,17,12,12,17,17,17,13,13,16,16,16,13,14,17,
+ 17,16,12,12,16,16,16,13,13,17,17,17,12,12,13,14,
+ 14,10,10,16,14,14,12,12,16,15,15,14,14,16,14,14,
+ 12,12,15,14,14,13,13,17,15,15,14,13,16,16,15,15,
+ 15,16,15,15,14,14,16,15,15,14,14,17,15,15,14,14,
+ 16,15,15,14,14,16,16,15,15,15,17,15,15,13,13,16,
+ 15,15,14,14,17,15,15,13,13,17,15,15,14,14,16,15,
+ 15,15,15,16,14,14,13,13,16,15,15,14,14,16,14,14,
+ 13,13,17,15,15,14,14,16,16,15,15,15,17,14,14,13,
+ 13,16,15,15,14,14,17,14,14,13,13,13,11,11,10,10,
+ 16,14,14,13,13,15,14,14,13,13,16,14,14,12,12,16,
+ 14,14,12,12,15,15,15,14,14,16,14,14,14,14,16,15,
+ 14,14,14,16,14,14,14,14,16,15,15,14,13,16,15,15,
+ 14,14,16,14,14,14,14,17,15,15,14,14,16,14,14,14,
+ 14,16,15,15,13,14,16,15,15,14,14,16,14,14,14,14,
+ 16,15,15,13,13,16,14,14,13,13,16,15,15,13,13,16,
+ 15,15,14,14,16,14,14,14,14,17,15,15,13,13,16,15,
+ 14,13,13,17,15,15,13,13,14,14,14, 9, 9,14,14,14,
+ 17,17,14,15,15,18,18,14,14,14,18,19,14,14,14,18,
+ 18,15,15,15,19,18,15,16,15,18,20,15,15,15,18,19,
+ 15,15,15,19,19,15,15,15,18,20,15,15,15,18,19,15,
+ 15,16,20,18,15,15,15,18,18,15,15,15,19,19,15,15,
+ 15,18,19,15,15,15,18,19,15,15,15,19,19,14,15,14,
+ 19,19,15,15,15,20,19,15,14,14,19,18,14,15,15,18,
+ 19,15,15,16,20,20,14,14,14,18,19,15,15,15,19,18,
+ 14,14,14,18,18,14,12,12, 9, 9,13,14,14,18,18,14,
+ 13,13,18,19,14,14,14,18,18,14,14,14,18,18,15,15,
+ 15,19,19,15,14,14,19,18,14,15,15,19,18,15,14,14,
+ 18,18,15,15,15,19,18,14,15,15,19,19,15,14,14,19,
+ 18,14,15,15,19,18,15,14,14,19,18,14,15,15,19,18,
+ 15,15,15,21,18,15,14,14,19,18,14,15,15,18,19,14,
+ 15,14,20,19,14,15,15,18,19,14,15,15,19,19,15,14,
+ 14,19,20,14,15,15,18,18,14,14,14,19,19,14,15,15,
+ 19,18,12,12,12,13,13,16,15,15,11,11,16,15,15,12,
+ 12,16,16,16,11,11,16,15,15,11,11,16,16,16,13,13,
+ 17,16,16,13,13,17,17,17,12,12,16,16,16,13,13,17,
+ 16,17,13,12,15,16,16,12,12,16,15,15,13,13,17,16,
+ 16,12,12,16,16,15,12,12,16,16,16,12,12,17,17,16,
+ 13,12,16,16,16,13,13,17,16,16,12,12,17,16,16,12,
+ 12,17,17,16,12,12,16,17,16,12,12,17,15,15,13,13,
+ 17,16,16,12,12,16,16,16,12,12,16,16,16,12,12,13,
+ 13,13, 9, 9,15,14,14,13,13,16,15,14,14,14,16,14,
+ 14,13,13,15,14,14,13,13,17,15,15,14,14,16,15,15,
+ 15,15,16,15,15,14,14,16,15,15,15,15,17,15,15,14,
+ 14,16,15,15,14,14,16,15,15,15,15,17,14,15,14,14,
+ 16,15,15,14,14,17,15,15,13,14,17,15,15,14,14,16,
+ 15,15,15,15,17,14,14,13,13,16,15,15,14,14,17,14,
+ 14,13,13,17,15,15,14,14,16,15,16,15,15,17,14,14,
+ 13,13,16,15,15,14,14,18,14,14,13,13,13,11,11,11,
+ 11,15,14,14,12,12,15,14,14,13,13,16,14,14,12,12,
+ 16,13,14,12,12,16,15,15,13,13,16,14,14,14,14,16,
+ 15,15,13,13,16,14,14,13,13,16,14,15,13,13,15,15,
+ 15,13,13,16,14,14,14,13,16,14,14,13,13,16,14,14,
+ 13,13,16,15,15,13,13,16,15,15,13,13,16,14,14,14,
+ 14,16,15,15,12,12,16,14,14,13,13,16,15,15,12,12,
+ 16,15,15,13,13,16,14,14,14,14,17,15,14,12,12,16,
+ 14,14,13,13,16,15,15,12,12,14,14,14, 8, 8,14,14,
+ 14,17,18,14,15,15,17,18,14,14,14,17,18,14,14,14,
+ 18,18,14,15,15,18,18,14,16,15,19,19,15,15,15,18,
+ 19,15,16,15,20,19,15,15,15,18,18,14,15,15,18,19,
+ 15,16,16,20,19,15,15,15,19,17,14,15,15,20,18,14,
+ 15,15,18,18,14,15,15,18,19,14,15,15,19,20,14,14,
+ 14,18,18,14,15,15,18,19,14,14,14,18,19,14,15,15,
+ 19,18,15,16,16,20,21,14,14,15,19,19,14,15,15,19,
+ 19,14,14,14,19,18,13,12,12, 9, 9,13,14,14,18,19,
+ 14,14,14,18,19,14,14,14,18,18,14,14,14,18,18,14,
+ 15,15,19,19,15,14,14,19,18,15,15,15,19,19,15,14,
+ 14,19,20,14,15,15,18,19,14,15,15,20,18,15,14,14,
+ 18,18,14,15,15,18,18,14,14,14,19,19,14,15,15,18,
+ 18,14,15,15,19,18,15,14,14,19,19,14,15,15,19,18,
+ 15,14,14,19,18,14,14,15,18,19,14,15,15,19,18,15,
+ 14,14,18,19,14,15,14,19,20,14,14,14,19,19,14,15,
+ 15,19,19,12,12,12,13,13,16,16,16,11,11,16,16,16,
+ 12,12,17,16,16,11,11,17,15,15,11,11,16,16,16,13,
+ 13,17,15,16,13,13,16,16,16,12,12,17,16,16,13,13,
+ 17,17,16,12,12,17,17,16,13,13,17,16,16,13,13,17,
+ 17,17,12,12,17,16,16,13,13,17,17,17,12,12,16,16,
+ 16,12,12,17,15,15,13,13,17,16,16,11,11,17,16,16,
+ 12,12,16,16,16,11,11,16,17,16,12,12,17,16,16,13,
+ 13,17,17,16,12,12,17,17,16,12,12,17,16,16,11,11,
+ 13,14,14, 9, 9,16,14,14,13,13,16,14,15,14,14,16,
+ 14,14,12,12,16,14,14,13,13,17,15,15,14,14,16,15,
+ 15,15,15,17,15,15,14,14,16,15,15,14,14,17,15,15,
+ 14,14,16,15,15,14,14,16,15,15,15,16,17,14,15,14,
+ 14,16,15,15,14,14,17,15,15,14,14,16,15,15,14,14,
+ 16,15,15,15,15,17,14,14,13,13,16,15,15,14,14,16,
+ 14,14,13,13,17,15,15,14,14,16,16,15,15,15,17,14,
+ 14,13,13,16,15,15,14,14,17,14,14,13,13,13,11,11,
+ 10,10,16,14,14,12,12,15,13,13,13,12,16,14,14,11,
+ 11,16,14,14,11,11,16,14,15,13,14,16,14,14,13,13,
+ 16,15,15,13,13,16,14,14,13,13,16,15,15,13,13,16,
+ 15,15,13,13,17,14,14,14,14,17,15,15,13,13,16,14,
+ 15,13,13,16,15,15,13,13,16,15,15,13,13,16,14,14,
+ 13,13,17,15,15,12,12,16,14,14,12,12,16,15,15,12,
+ 12,16,15,15,13,13,16,14,14,13,13,17,15,15,12,12,
+ 17,14,14,12,12,16,15,15,12,12,13,14,14, 8, 8,13,
+ 14,14,18,18,13,15,15,17,18,14,14,14,18,19,14,14,
+ 14,19,18,14,15,15,19,18,15,15,16,21,18,15,15,15,
+ 19,19,14,16,16,19,19,14,15,15,18,19,14,15,15,19,
+ 20,14,16,16,19,18,15,15,15,18,19,14,15,15,19,18,
+ 15,15,15,18,18,15,15,15,20,18,15,16,16,20,19,14,
+ 15,14,18,19,14,15,16,19,20,14,15,15,19,18,15,15,
+ 15,19,18,15,16,16,20,19,15,14,14,18,18,14,15,15,
+ 19,19,14,15,15,18,18,13,12,12, 8, 8,13,14,14,19,
+ 18,14,13,13,20,18,14,14,14,19,18,14,13,13,18,19,
+ 14,15,15,20,19,15,14,14,19,19,14,15,15,19,18,15,
+ 14,14,20,20,15,15,15,19,18,14,15,15,19,18,15,14,
+ 14,19,18,14,15,15,20,19,14,14,14,20,19,14,15,15,
+ 19,18,15,15,15,18,18,15,14,14,18,18,14,15,15,19,
+ 19,14,14,14,19,19,14,15,15,19,19,15,15,15,19,18,
+ 15,14,14,20,19,15,15,15,19,19,14,14,14,20,19,14,
+ 15,15,20,20,12,12,12,13,13,17,16,16,11,11,16,16,
+ 15,12,12,17,16,16,11,11,17,15,15,11,11,17,17,17,
+ 13,13,17,16,16,13,13,17,17,17,12,12,17,16,16,13,
+ 13,17,17,16,12,13,16,17,16,13,13,17,16,15,13,13,
+ 17,16,16,12,12,17,16,16,12,13,17,16,17,12,12,17,
+ 17,17,12,12,17,16,15,13,13,17,16,16,12,12,17,16,
+ 16,12,12,17,16,16,11,11,16,16,16,12,12,17,15,15,
+ 13,13,17,16,15,11,11,16,16,16,12,12,17,16,16,11,
+ 11,13,14,14, 9, 9,16,14,14,13,13,16,14,15,14,14,
+ 16,14,14,12,12,16,14,14,13,13,17,15,15,14,15,16,
+ 15,15,15,15,17,15,15,14,14,16,15,15,15,14,16,15,
+ 15,14,14,16,15,15,14,14,16,15,16,15,15,17,15,14,
+ 14,14,16,15,15,14,14,17,15,15,13,13,16,15,15,14,
+ 14,16,16,16,15,15,17,14,14,13,13,16,15,15,14,14,
+ 18,14,15,13,13,16,15,15,14,14,16,16,15,15,15,16,
+ 14,14,13,13,16,15,15,14,14,17,14,15,13,13,13,11,
+ 11,10,10,15,14,14,12,12,15,14,14,13,13,16,14,14,
+ 12,12,16,13,14,12,12,16,14,15,14,13,16,14,14,14,
+ 14,16,15,15,13,13,16,14,14,13,13,16,15,15,13,13,
+ 15,15,15,13,13,16,14,14,14,14,17,15,15,13,13,16,
+ 14,14,13,13,16,15,15,13,13,16,15,15,13,13,16,14,
+ 14,13,13,17,15,15,12,12,16,14,14,12,12,16,14,15,
+ 12,12,16,15,15,13,13,16,14,14,13,13,17,15,15,12,
+ 12,16,14,14,12,12,16,15,15,12,12,14,14,14, 8, 8,
+ 14,14,14,17,17,14,15,15,18,18,14,14,14,18,17,14,
+ 14,14,18,18,14,15,15,18,20,15,16,15,19,18,15,15,
+ 15,19,18,15,15,16,19,18,15,15,15,18,18,14,15,15,
+ 18,18,15,16,16,18,19,15,15,15,18,18,15,15,15,19,
+ 20,15,15,15,18,18,15,15,15,18,18,15,16,16,19,19,
+ 15,14,15,19,19,15,15,15,19,20,14,14,15,18,18,15,
+ 15,15,19,19,15,16,16,19,19,15,15,14,18,19,15,15,
+ 15,20,20,15,15,14,18,18,13,12,12, 8, 8,13,14,14,
+ 18,18,14,14,14,18,18,14,14,14,18,20,14,14,14,18,
+ 18,14,15,15,19,18,15,14,14,18,19,15,15,15,18,19,
+ 15,14,14,18,19,15,15,15,18,18,14,15,14,18,19,15,
+ 14,14,21,19,15,15,15,19,18,14,14,14,19,18,14,15,
+ 15,19,18,15,15,15,20,19,15,14,14,20,18,14,15,15,
+ 18,19,14,14,14,19,18,14,15,15,18,19,15,15,15,18,
+ 19,15,14,14,19,19,15,15,15,19,19,14,14,14,19,20,
+ 14,15,15,18,19,
+};
+
+static const static_codebook _44p0_p3_1 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p0_p3_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p0_p3_1,
+ 0
+};
+
+static const long _vq_quantlist__44p0_p4_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p0_p4_0[] = {
+ 2, 6, 6,14,14, 6, 8, 8,14,14, 7, 7, 7,14,14, 0,
+ 13,13,15,16, 0,13,13,15,15, 7, 8, 8,15,15, 9,10,
+ 10,16,16, 9, 8, 8,14,15, 0,13,13,17,17, 0,13,13,
+ 16,16, 8, 8, 8,15,15,12,11,11,16,16, 9, 8, 8,14,
+ 14, 0,13,13,17,17, 0,13,13,15,15, 0,14,14,16,16,
+ 0, 0, 0,18,19, 0,12,12,16,15, 0,16,16, 0,20, 0,
+ 14,14,16,16, 0,14,14,17,17, 0, 0, 0,19,19, 0,12,
+ 12,15,15, 0,18,17,21,21, 0,14,14,16,16, 5, 7, 7,
+ 12,13, 9,10, 9,14,14,11,10,10,14,14, 0, 0, 0,18,
+ 17, 0,20,21,18,18, 9,10,10,14,14,12,12,12,17,16,
+ 12,10,10,14,14, 0,20,20,18,17, 0,21,21,17,17,11,
+ 10,10,14,14,15,13,13,18,18,13,11,11,14,14, 0,20,
+ 0,18,18, 0,20,21,18,17, 0,21, 0,18,19, 0, 0, 0,
+ 0,21, 0,21,20,16,17, 0, 0, 0,21,21, 0, 0, 0,20,
+ 18, 0,20, 0,17,18, 0, 0, 0, 0, 0, 0, 0,20,16,17,
+ 0, 0, 0,20, 0, 0, 0, 0,18,18, 6, 6, 6,13,13, 8,
+ 5, 5,11,11, 9, 6, 6,13,13, 0, 9, 9,12,12, 0,10,
+ 10,14,14, 9, 7, 7,13,13,12, 9, 9,13,13,10, 6, 6,
+ 13,13, 0,10,10,14,14, 0,10,10,13,13, 9, 7, 7,13,
+ 13,13,10,10,13,13,11, 6, 6,13,13, 0,10,10,15,15,
+ 0,10,10,13,13, 0,12,11,15,15, 0,20,19,17,16, 0,
+ 9, 9,13,13, 0,13,13,20,19, 0,11,11,13,13, 0,11,
+ 11,15,15, 0,20,19,17,17, 0,10,10,13,13, 0,14,15,
+ 0,21, 0,12,12,13,13, 0,10,10,12,12, 0,11,11,15,
+ 15, 0,11,11,15,15, 0,15,15,20,20, 0,16,16, 0, 0,
+ 0,11,11,15,15, 0,14,14,17,17, 0,11,11,15,15, 0,
+ 15,15,20,21, 0,16,16,21,21, 0,12,12,15,15, 0,15,
+ 15,18,20, 0,11,11,16,15, 0,15,15,21,21, 0,16,16,
+ 0,21, 0,16,16, 0, 0, 0, 0, 0, 0, 0, 0,14,14,21,
+ 21, 0,17,18, 0, 0, 0,16,17,20, 0, 0,16,16, 0, 0,
+ 0, 0, 0, 0, 0, 0,15,15,20,20, 0,19,18, 0,21, 0,
+ 18,17, 0, 0, 0,10,10,11,11, 0,10,10,10,10, 0,11,
+ 11,12,12, 0,11,11, 9, 9, 0,13,13,12,12, 0,11,11,
+ 12,12, 0,13,13,12,12, 0,10,10,12,12, 0,12,12,13,
+ 13, 0,12,12,12,12, 0,11,11,12,12, 0,13,13,12,12,
+ 0,10,10,12,12, 0,13,13,13,13, 0,12,12,12,12, 0,
+ 14,13,13,13, 0,19,21,15,15, 0,12,11,12,12, 0,16,
+ 15,19,19, 0,13,13,11,11, 0,13,13,13,13, 0, 0,21,
+ 15,16, 0,12,12,12,12, 0,16,16,19,21, 0,13,13,12,
+ 12, 7, 7, 7,16,16,11, 9, 9,16,16,12, 9, 9,16,16,
+ 0,13,13,16,16, 0,14,14,17,16,11, 9, 9,16,16,14,
+ 12,11,17,17,13, 8, 9,15,15, 0,13,13,19,19, 0,13,
+ 13,16,15,12,10,10,17,17,15,12,12,19,18,14, 9, 9,
+ 17,16, 0,14,14,18, 0, 0,14,13,16,16, 0,14,15,18,
+ 17, 0,21, 0,19,21, 0,12,12,16,16, 0,16,16, 0, 0,
+ 0,14,14,16,16, 0,14,14,18,18, 0, 0,21,20, 0, 0,
+ 13,13,16,17, 0,18,18, 0, 0, 0,15,14,17,16, 8, 7,
+ 7,14,14,11,10,10,15,15,13,10,10,15,15, 0,21,20,
+ 19,19, 0,21, 0,17,18,11,10,10,15,16,14,12,12,18,
+ 18,14,11,11,15,14, 0,21,20,18,19, 0, 0,21,18,18,
+ 12,11,11,16,16,16,14,14,18,20,14,11,11,16,15, 0,
+ 20,20,19,19, 0, 0,20,18,18, 0,21, 0,18,19, 0, 0,
+ 0, 0, 0, 0,20,20,17,18, 0, 0, 0,20,20, 0, 0, 0,
+ 19,19, 0, 0, 0,20,18, 0, 0, 0, 0, 0, 0, 0,21,18,
+ 18, 0,21,21, 0,21, 0, 0, 0,19,20,11, 9, 9,14,14,
+ 13,10,10,14,14,13,11,11,15,15, 0,13,13,13,13, 0,
+ 14,14,16,16,13,11,11,15,15,16,12,12,15,15,14,10,
+ 10,14,14, 0,14,14,16,16, 0,14,14,15,15,13,10,10,
+ 15,15,17,13,14,15,16,15,10,10,15,15, 0,14,14,17,
+ 16, 0,14,14,15,15, 0,15,15,17,17, 0, 0,21,18,18,
+ 0,13,13,15,15, 0,16,16,21,20, 0,14,14,15,14, 0,
+ 15,14,16,17, 0, 0,20,20,19, 0,13,13,15,15, 0,19,
+ 18, 0, 0, 0,15,15,15,15, 0,11,11,14,14, 0,12,12,
+ 16,16, 0,12,12,16,16, 0,15,16,21,21, 0,16,17,21,
+ 0, 0,12,12,17,16, 0,14,14,18,19, 0,11,11,16,16,
+ 0,15,15,20,21, 0,16,16,21, 0, 0,12,12,17,16, 0,
+ 15,15,19,19, 0,12,12,16,17, 0,16,15, 0, 0, 0,16,
+ 16, 0, 0, 0,17,17, 0,21, 0, 0, 0, 0, 0, 0,14,15,
+ 20, 0, 0,17,17, 0, 0, 0,17,17, 0, 0, 0,17,16, 0,
+ 0, 0, 0, 0, 0, 0, 0,15,15, 0, 0, 0,18,18, 0, 0,
+ 0,18,17, 0, 0, 0,11,11,14,14, 0,12,12,15,15, 0,
+ 12,12,15,15, 0,13,13,14,14, 0,14,14,17,17, 0,12,
+ 12,16,16, 0,14,14,16,16, 0,11,11,15,15, 0,13,13,
+ 16,17, 0,13,13,16,16, 0,12,12,15,15, 0,14,14,17,
+ 16, 0,11,11,15,15, 0,14,14,17,17, 0,13,13,16,16,
+ 0,15,15,17,18, 0,21,20,20,21, 0,12,12,15,15, 0,
+ 16,16,20,21, 0,14,14,15,15, 0,14,14,17,17, 0, 0,
+ 0,18,19, 0,12,13,15,15, 0,18,17,21, 0, 0,14,15,
+ 15,15, 8, 8, 8,16,16,12,10,10,16,16,13, 9, 9,16,
+ 16, 0,14,14,18,17, 0,14,14,16,17,12,10,10,18,17,
+ 14,12,11,18,18,14, 9, 9,16,16, 0,13,13,18,18, 0,
+ 13,13,17,16,12, 9, 9,16,17,17,13,13,17,17,14, 9,
+ 9,15,15, 0,14,14,20,19, 0,13,13,16,16, 0,15,15,
+ 19,18, 0, 0, 0,20,19, 0,12,13,17,17, 0,16,16,20,
+ 0, 0,14,14,16,17, 0,14,14,19,18, 0, 0, 0,20,20,
+ 0,13,13,16,16, 0,18,17, 0, 0, 0,15,15,16,16, 9,
+ 7, 7,14,14,12,10,10,15,15,13,10,10,15,15, 0,21,
+ 0,18,19, 0,20,21,19,18,12,10,10,16,15,15,13,13,
+ 18,18,14,11,11,15,15, 0, 0, 0,19,18, 0, 0,21,18,
+ 18,13,11,11,15,15,16,14,14,17,19,15,11,11,15,15,
+ 0,21,21,20,18, 0, 0,21,18,18, 0, 0,21,21,19, 0,
+ 0, 0, 0, 0, 0,19,20,18,17, 0, 0, 0,21,21, 0,21,
+ 0,20,18, 0, 0,21,19,19, 0, 0, 0, 0, 0, 0,20,21,
+ 17,17, 0, 0, 0, 0, 0, 0,21, 0,18,20, 0,10,10,14,
+ 14, 0,11,11,15,15, 0,11,11,15,15, 0,14,14,15,15,
+ 0,15,15,16,16, 0,11,12,16,16, 0,13,13,16,16, 0,
+ 11,11,15,15, 0,14,14,17,17, 0,14,14,15,15, 0,11,
+ 11,16,15, 0,14,14,15,15, 0,11,11,15,15, 0,15,15,
+ 17,17, 0,14,14,15,15, 0,16,16,18,18, 0, 0, 0,20,
+ 19, 0,14,13,16,15, 0,17,17,21, 0, 0,15,15,15,15,
+ 0,16,15,17,16, 0,20, 0,20,18, 0,13,14,15,15, 0,
+ 19,18, 0,21, 0,15,15,15,15, 0,11,11,14,14, 0,12,
+ 12,16,16, 0,12,12,16,16, 0,16,15,20,21, 0,17,16,
+ 0, 0, 0,12,12,16,16, 0,14,14,18,18, 0,11,11,16,
+ 16, 0,15,15,21,20, 0,16,16, 0, 0, 0,12,12,16,17,
+ 0,15,14,19,19, 0,11,12,16,16, 0,15,15,21, 0, 0,
+ 16,16, 0, 0, 0,16,17, 0, 0, 0, 0, 0, 0, 0, 0,15,
+ 15,21, 0, 0,17,17, 0, 0, 0,17,17, 0, 0, 0,17,16,
+ 0, 0, 0, 0, 0, 0, 0, 0,15,15, 0,20, 0,19,20, 0,
+ 0, 0,17,17, 0, 0, 0,12,12,15,15, 0,12,12,15,15,
+ 0,12,12,16,16, 0,13,13,15,15, 0,15,15,17,17, 0,
+ 13,13,17,16, 0,14,14,17,17, 0,11,11,16,16, 0,14,
+ 14,17,17, 0,13,13,16,16, 0,12,12,16,16, 0,15,15,
+ 16,17, 0,11,11,15,16, 0,14,14,17,17, 0,13,14,16,
+ 16, 0,15,15,18,18, 0,21,20,20,19, 0,13,13,16,17,
+ 0,16,16, 0, 0, 0,14,14,16,16, 0,15,15,18,18, 0,
+ 0, 0,20,19, 0,13,13,16,16, 0,17,17, 0, 0, 0,14,
+ 14,16,16, 0,11,11,16,16, 0,13,13,18,17, 0,13,13,
+ 17,17, 0,16,16,17,17, 0,16,16,17,18, 0,12,12,17,
+ 17, 0,15,15,18,18, 0,12,12,16,16, 0,16,16,19,19,
+ 0,15,15,16,17, 0,12,12,17,17, 0,17,17,18,18, 0,
+ 12,12,17,17, 0,16,16,19,19, 0,15,16,17,17, 0,16,
+ 16,18,17, 0, 0, 0,21,21, 0,13,13,16,16, 0,17,17,
+ 0,20, 0,15,15,16,17, 0,16,16,19,18, 0, 0,21,20,
+ 21, 0,14,14,17,16, 0,20, 0, 0, 0, 0,15,16,16,17,
+ 0, 9, 9,14,14, 0,13,13,16,16, 0,14,14,15,15, 0,
+ 0,20,19,19, 0, 0, 0,19,19, 0,12,12,15,15, 0,15,
+ 16,19,18, 0,14,14,15,15, 0,21, 0,18,18, 0,20, 0,
+ 17,18, 0,13,13,16,16, 0,17,17,17,19, 0,14,14,16,
+ 15, 0,21,20,20,19, 0, 0, 0,19,19, 0, 0, 0,19,18,
+ 0, 0, 0, 0, 0, 0,20,20,17,18, 0, 0, 0,21,21, 0,
+ 0, 0,18,18, 0,21, 0,18,19, 0, 0, 0, 0, 0, 0,20,
+ 21,18,18, 0, 0, 0,20,21, 0, 0, 0,19,19, 0,18,18,
+ 15,15, 0,20,21,17,17, 0,19,21,17,17, 0, 0, 0,17,
+ 18, 0, 0, 0,20,19, 0,19,19,17,17, 0, 0, 0,18,18,
+ 0,19,20,16,17, 0, 0,21,20,20, 0,19,20,19,18, 0,
+ 19,20,16,16, 0, 0, 0,18,19, 0,19,20,17,17, 0, 0,
+ 21, 0,20, 0,21,21,17,19, 0,20, 0,19,20, 0, 0, 0,
+ 20, 0, 0,19,18,17,16, 0, 0, 0, 0, 0, 0, 0,20,17,
+ 17, 0,20,21,18,20, 0, 0, 0, 0,21, 0,19,20,17,17,
+ 0, 0, 0, 0, 0, 0,20,21,17,17, 0,11,11,14,14, 0,
+ 13,13,16,17, 0,13,13,16,16, 0,17,17, 0,21, 0,18,
+ 17,21, 0, 0,13,13,16,16, 0,15,15,18,18, 0,12,12,
+ 16,16, 0,17,16,21, 0, 0,17,17, 0, 0, 0,12,12,17,
+ 17, 0,17,17,19,21, 0,13,12,16,16, 0,17,17, 0, 0,
+ 0,17,17, 0, 0, 0,18,17, 0,21, 0, 0, 0, 0, 0, 0,
+ 15,15,20, 0, 0,20,18, 0, 0, 0,17,18, 0, 0, 0,16,
+ 17, 0, 0, 0, 0, 0, 0, 0, 0,15,15, 0, 0, 0,19,19,
+ 0, 0, 0,18,18, 0, 0, 0,14,14,18,18, 0,16,16, 0,
+ 21, 0,16,16,21,21, 0,17,17, 0,20, 0,17,17,20, 0,
+ 0,16,15, 0, 0, 0,20,20, 0, 0, 0,15,15,20,20, 0,
+ 17,17,21, 0, 0,17,18,20,20, 0,15,15,20,20, 0,18,
+ 18, 0, 0, 0,15,15,19,20, 0,17,18, 0, 0, 0,17,17,
+ 20,20, 0,18,17,21, 0, 0, 0, 0, 0,21, 0,15,15,20,
+ 20, 0,19,19, 0, 0, 0,17,17,21, 0, 0,17,17, 0, 0,
+ 0, 0, 0,21, 0, 0,15,15,19,19, 0,20,21, 0, 0, 0,
+ 18,17,21,21, 0,12,12,16,16, 0,14,14,17,17, 0,13,
+ 13,17,18, 0,16,16,18,17, 0,16,16,18,18, 0,13,13,
+ 18,18, 0,15,16,19,18, 0,13,13,16,16, 0,16,16,20,
+ 18, 0,16,16,17,17, 0,12,13,17,17, 0,17,16,18,18,
+ 0,12,12,16,16, 0,17,16,20,19, 0,16,16,16,16, 0,
+ 16,17,18,20, 0, 0, 0,21,20, 0,14,14,17,16, 0,19,
+ 18, 0,20, 0,16,16,17,16, 0,16,16,17,18, 0, 0,21,
+ 21,21, 0,14,14,16,16, 0,20,20,21, 0, 0,16,16,16,
+ 16, 0,10,10,14,14, 0,14,14,15,16, 0,14,14,15,15,
+ 0, 0,21,18,18, 0, 0,21,18,19, 0,13,13,16,16, 0,
+ 16,16,18,18, 0,14,14,15,15, 0,21, 0,18,18, 0,21,
+ 0,18,18, 0,13,13,16,16, 0,17,17,19,20, 0,14,14,
+ 15,15, 0, 0, 0,18,20, 0, 0,21,18,18, 0, 0,21,19,
+ 18, 0, 0, 0, 0, 0, 0,20,21,18,17, 0, 0, 0,21,21,
+ 0, 0, 0,19,19, 0,21, 0,18,19, 0, 0, 0, 0, 0, 0,
+ 21,20,17,17, 0, 0,21,20, 0, 0, 0, 0,19,19, 0,19,
+ 20,15,16, 0, 0,20,18,17, 0,20,21,17,18, 0,21, 0,
+ 18,18, 0, 0, 0,19,19, 0,20,20,17,18, 0, 0, 0,18,
+ 19, 0,20,20,18,17, 0, 0, 0, 0,20, 0, 0,21,17,18,
+ 0,20,21,17,17, 0, 0, 0,18,18, 0,19,19,17,17, 0,
+ 0, 0,21,21, 0,20,20,17,17, 0, 0, 0,21,19, 0, 0,
+ 0,20,19, 0,21,20,17,18, 0, 0, 0, 0, 0, 0, 0,20,
+ 18,17, 0,21,20,18,18, 0, 0, 0,20,21, 0,20,20,17,
+ 17, 0, 0, 0, 0, 0, 0,20, 0,17,17, 0,11,11,13,14,
+ 0,13,13,16,16, 0,13,13,16,16, 0,17,17, 0, 0, 0,
+ 17,18, 0, 0, 0,13,13,16,16, 0,15,16,18,18, 0,13,
+ 13,16,17, 0,16,17,20, 0, 0,17,18,20, 0, 0,13,13,
+ 17,17, 0,16,16,20,21, 0,13,13,16,16, 0,17,17,21,
+ 0, 0,17,18, 0, 0, 0,17,18, 0,21, 0, 0, 0, 0, 0,
+ 0,15,15,20, 0, 0,19,19, 0, 0, 0,17,17, 0, 0, 0,
+ 18,17,21,20, 0, 0, 0, 0, 0, 0,16,16,20,21, 0,21,
+ 20, 0,21, 0,19,21, 0, 0, 0,15,15, 0, 0, 0,16,17,
+ 0,19, 0,16,16, 0, 0, 0,17,17, 0, 0, 0,19,18, 0,
+ 0, 0,16,16,20,20, 0,20,18,21, 0, 0,15,15,21,21,
+ 0,18,18, 0, 0, 0,18,19, 0, 0, 0,16,15, 0,21, 0,
+ 20,19, 0, 0, 0,16,16, 0, 0, 0,20,18, 0,21, 0,17,
+ 18,21, 0, 0,18,19, 0, 0, 0, 0, 0, 0, 0, 0,16,16,
+ 20,20, 0,19,20, 0, 0, 0,17,17, 0, 0, 0,18,17,20,
+ 21, 0, 0, 0, 0, 0, 0,16,16, 0,20, 0,20,22, 0, 0,
+ 0,18,18, 0,22,
+};
+
+static const static_codebook _44p0_p4_0 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p0_p4_0,
+ 1, -528744448, 1616642048, 3, 0,
+ (long *)_vq_quantlist__44p0_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44p0_p4_1[] = {
+ 3,
+ 2,
+ 4,
+ 1,
+ 5,
+ 0,
+ 6,
+};
+
+static const long _vq_lengthlist__44p0_p4_1[] = {
+ 2, 3, 3, 3, 3, 3, 3,
+};
+
+static const static_codebook _44p0_p4_1 = {
+ 1, 7,
+ (long *)_vq_lengthlist__44p0_p4_1,
+ 1, -533200896, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p0_p4_1,
+ 0
+};
+
+static const long _vq_quantlist__44p0_p5_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p0_p5_0[] = {
+ 1, 6, 6, 6, 8, 8, 7, 8, 8, 7, 9, 8,10,11,11, 9,
+ 8, 8, 7, 8, 8,11,11,11, 9, 8, 8, 6, 7, 7,10,10,
+ 10,10,10,10,10,10,10,14,13,13,12,11,11,10,10,10,
+ 14,14,13,13,11,11, 6, 6, 6, 8, 5, 5, 8, 7, 7, 8,
+ 7, 7,11, 9, 9, 9, 7, 7, 8, 7, 7,12,10,10,10, 7,
+ 7, 7, 8, 8,12,11,11,12,10,10,11,10,10,14,13,13,
+ 13,10,10,11,10,11,16,14,14,13,10,10, 7, 8, 7,12,
+ 12,12,12,11,11,12,11,11,16,14,15,13,12,12,11,11,
+ 11,17,15,14,14,13,13,10, 9, 9,13,11,11,13,11,11,
+ 12,11,11,16,14,13,14,11,11,12,11,11,16,15,14,14,
+ 11,11, 7, 8, 8,12,11,11,12,10,10,12,10,10,16,14,
+ 13,13,11,11,12,10,10,16,14,14,13,10,10, 8, 8, 8,
+ 12,12,12,12,11,11,12,11,11,16,14,15,14,12,12,12,
+ 11,11,16,15,15,14,12,12,10,10,10,13,11,11,13,11,
+ 11,12,12,12,16,14,14,14,11,11,12,11,11,17,14,15,
+ 14,11,11,
+};
+
+static const static_codebook _44p0_p5_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p0_p5_0,
+ 1, -527106048, 1620377600, 2, 0,
+ (long *)_vq_quantlist__44p0_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44p0_p5_1[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p0_p5_1[] = {
+ 2, 7, 7, 7, 8, 8, 7, 7, 7, 7, 8, 8, 8, 8, 9, 8,
+ 7, 7, 8, 8, 8, 9, 9, 9, 9, 7, 7, 6, 6, 6, 9, 7,
+ 7, 9, 7, 7, 9, 8, 8,10, 8, 8,10, 8, 8,10, 8, 8,
+ 10, 8, 8,10, 8, 8, 7, 6, 6, 9, 6, 6, 9, 6, 6, 9,
+ 7, 7,10, 8, 8, 9, 6, 6, 9, 7, 7,10, 8, 8, 9, 7,
+ 7, 7, 8, 8,11, 9, 9,11, 9, 9,11, 9, 9,12, 9, 9,
+ 12, 8, 8,12, 9, 9,12,10, 9,12, 8, 8, 8, 7, 7,10,
+ 9, 9,11, 9, 9,11, 9, 9,11,11,10,11, 9, 9,11,10,
+ 9,11,10,11,11, 9, 9,10, 8, 8,11, 9, 9,11, 9, 9,
+ 11, 9, 9,11,10,10,11, 9, 9,11, 9, 9,11,10,10,11,
+ 9, 9, 9, 8, 8,12, 9, 9,12, 9, 9,11, 9, 9,12, 9,
+ 9,12, 8, 8,12, 9, 9,12, 9, 9,12, 8, 8, 9, 7, 7,
+ 11, 9,10,11,10, 9,11, 9, 9,11,11,11,11, 9, 9,11,
+ 10,10,11,11,11,11, 9, 9,10, 9, 9,11, 9, 9,11,10,
+ 10,11,10, 9,11,10,10,11, 9, 9,11,10,10,11,10,11,
+ 11, 9, 9,
+};
+
+static const static_codebook _44p0_p5_1 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p0_p5_1,
+ 1, -530841600, 1616642048, 2, 0,
+ (long *)_vq_quantlist__44p0_p5_1,
+ 0
+};
+
+static const long _vq_quantlist__44p0_p6_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p0_p6_0[] = {
+ 1, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 8, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 7, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9,
+};
+
+static const static_codebook _44p0_p6_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p0_p6_0,
+ 1, -516716544, 1630767104, 2, 0,
+ (long *)_vq_quantlist__44p0_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44p0_p6_1[] = {
+ 12,
+ 11,
+ 13,
+ 10,
+ 14,
+ 9,
+ 15,
+ 8,
+ 16,
+ 7,
+ 17,
+ 6,
+ 18,
+ 5,
+ 19,
+ 4,
+ 20,
+ 3,
+ 21,
+ 2,
+ 22,
+ 1,
+ 23,
+ 0,
+ 24,
+};
+
+static const long _vq_lengthlist__44p0_p6_1[] = {
+ 1, 3, 2, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9,10,10,11,
+ 11,12,12,12,14,14,14,15,15,
+};
+
+static const static_codebook _44p0_p6_1 = {
+ 1, 25,
+ (long *)_vq_lengthlist__44p0_p6_1,
+ 1, -518864896, 1620639744, 5, 0,
+ (long *)_vq_quantlist__44p0_p6_1,
+ 0
+};
+
+static const long _vq_quantlist__44p0_p6_2[] = {
+ 12,
+ 11,
+ 13,
+ 10,
+ 14,
+ 9,
+ 15,
+ 8,
+ 16,
+ 7,
+ 17,
+ 6,
+ 18,
+ 5,
+ 19,
+ 4,
+ 20,
+ 3,
+ 21,
+ 2,
+ 22,
+ 1,
+ 23,
+ 0,
+ 24,
+};
+
+static const long _vq_lengthlist__44p0_p6_2[] = {
+ 3, 4, 4, 5, 4, 5, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5,
+};
+
+static const static_codebook _44p0_p6_2 = {
+ 1, 25,
+ (long *)_vq_lengthlist__44p0_p6_2,
+ 1, -529006592, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44p0_p6_2,
+ 0
+};
+
+static const long _huff_lengthlist__44p0_short[] = {
+ 3, 3, 7, 8,10,13,16, 3, 2, 5, 7, 9,13,16, 6, 4,
+ 4, 6,10,14,15, 7, 5, 5, 7,10,13,14, 9, 8, 9, 9,
+ 9,11,13,12,11,12, 9, 7, 8,11,14,12,10, 6, 5, 7,
+ 10,
+};
+
+static const static_codebook _huff_book__44p0_short = {
+ 2, 49,
+ (long *)_huff_lengthlist__44p0_short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44p1_l0_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44p1_l0_0[] = {
+ 1, 4, 4, 7, 7, 8, 8, 9, 9,10,10,11,11, 4, 6, 5,
+ 8, 6, 9, 8,10, 9,10,10,11,10, 5, 5, 6, 6, 8, 8,
+ 9, 9,10,10,10,10,11, 7, 8, 8, 9, 8,10, 9,10, 9,
+ 11,10,11,10, 7, 8, 8, 8,10, 9,10,10,10,10,11,10,
+ 11, 9,10,10,11,11,11,11,12,11,12,11,12,11, 9,10,
+ 10,11,11,11,11,11,11,11,12,11,12,11,11,11,12,12,
+ 12,12,12,12,12,12,12,11,11,12,11,12,12,12,12,12,
+ 12,12,12,11,12,12,12,12,12,13,12,13,12,12,12,12,
+ 12,12,12,12,12,13,13,13,13,12,13,12,12,12,12,12,
+ 13,13,12,13,12,13,12,13,12,12,12,12,13,13,13,13,
+ 13,13,12,12,12,12,12,11,12,
+};
+
+static const static_codebook _44p1_l0_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44p1_l0_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44p1_l0_0,
+ 0
+};
+
+static const long _vq_quantlist__44p1_l0_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p1_l0_1[] = {
+ 1, 4, 4, 6, 6, 5, 5, 5, 6, 6, 5, 6, 5, 6, 6, 6,
+ 6, 7, 7, 7, 6, 7, 6, 7, 7,
+};
+
+static const static_codebook _44p1_l0_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44p1_l0_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p1_l0_1,
+ 0
+};
+
+static const long _vq_quantlist__44p1_l1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p1_l1_0[] = {
+ 1, 4, 4, 4, 4, 4, 4, 4, 4,
+};
+
+static const static_codebook _44p1_l1_0 = {
+ 2, 9,
+ (long *)_vq_lengthlist__44p1_l1_0,
+ 1, -516716544, 1630767104, 2, 0,
+ (long *)_vq_quantlist__44p1_l1_0,
+ 0
+};
+
+static const long _huff_lengthlist__44p1_lfe[] = {
+ 1, 3, 2, 3,
+};
+
+static const static_codebook _huff_book__44p1_lfe = {
+ 2, 4,
+ (long *)_huff_lengthlist__44p1_lfe,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44p1_long[] = {
+ 3, 3, 7, 7, 9,13,16, 3, 2, 4, 6,10,13,17, 7, 4,
+ 4, 6, 9,12,14, 7, 6, 6, 5, 7, 9,12,10,10, 9, 6,
+ 6, 9,12,14,14,13, 9, 8,10,11,18,18,15,13,11,10,
+ 11,
+};
+
+static const static_codebook _huff_book__44p1_long = {
+ 2, 49,
+ (long *)_huff_lengthlist__44p1_long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44p1_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p1_p1_0[] = {
+ 1, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0,
+};
+
+static const static_codebook _44p1_p1_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p1_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44p1_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44p1_p2_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p1_p2_0[] = {
+ 1, 4, 4, 0, 7, 7, 0, 8, 8, 0, 9, 9, 0,12,12, 0,
+ 8, 8, 0, 9, 9, 0,12,12, 0, 8, 8, 0, 6, 6, 0,11,
+ 11, 0,11,11, 0,12,12, 0,14,14, 0,11,11, 0,12,12,
+ 0,14,14, 0,11,11, 0, 6, 6, 0, 6, 5, 0, 7, 6, 0,
+ 7, 7, 0,10,10, 0, 6, 6, 0, 7, 7, 0,10,10, 0, 7,
+ 7, 0, 7, 7, 0,10,10, 0,11,11, 0,11,11, 0,14,14,
+ 0,10,10, 0,12,12, 0,14,14, 0,12,12, 0, 6, 6, 0,
+ 11,11, 0,11,11, 0,12,12, 0,14,14, 0,11,11, 0,12,
+ 12, 0,15,15, 0,11,11, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 8, 8, 0,11,11, 0,11,11, 0,12,12, 0,15,
+ 15, 0,12,12, 0,11,11, 0,15,15, 0,11,11, 0, 6, 6,
+ 0,11,11, 0,12,12, 0,12,12, 0,15,15, 0,11,11, 0,
+ 12,12, 0,14,14, 0,12,12, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0,
+};
+
+static const static_codebook _44p1_p2_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p1_p2_0,
+ 1, -533200896, 1614282752, 2, 0,
+ (long *)_vq_quantlist__44p1_p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44p1_p2_1[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p1_p2_1[] = {
+ 1, 3, 3, 0, 8, 8, 0, 8, 8, 0,10,10, 0, 9, 9, 0,
+ 10,10, 0,10,10, 0, 9, 9, 0,10,10, 0, 7, 7, 0, 7,
+ 7, 0, 7, 7, 0, 8, 8, 0, 8, 8, 0, 8, 8, 0, 9, 9,
+ 0, 8, 8, 0, 8, 8, 0, 7, 7, 0, 8, 8, 0, 8, 8, 0,
+ 10,10, 0, 9, 9, 0, 9, 9, 0,10,10, 0, 9, 9, 0,10,
+ 10, 0, 8, 8, 0,11,11, 0,11,11, 0,12,12, 0,11,11,
+ 0,12,12, 0,12,12, 0,12,12, 0,12,12, 0, 8, 8, 0,
+ 11,11, 0,11,11, 0,13,12, 0,12,12, 0,13,12, 0,13,
+ 13, 0,12,12, 0,13,13, 0, 7, 7, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 8, 8, 0,11,11, 0,11,11, 0,13,12, 0,12,
+ 12, 0,12,12, 0,12,12, 0,11,11, 0,12,12, 0, 8, 8,
+ 0,12,12, 0,12,12, 0,13,13, 0,12,12, 0,13,13, 0,
+ 13,13, 0,12,13, 0,13,13, 0, 7, 7, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0,
+};
+
+static const static_codebook _44p1_p2_1 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p1_p2_1,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44p1_p2_1,
+ 0
+};
+
+static const long _vq_quantlist__44p1_p3_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p1_p3_0[] = {
+ 1, 6, 6, 6, 7, 7, 7, 8, 8, 7, 8, 8,10,11,11, 9,
+ 8, 8, 7, 9, 9,11,12,12, 9, 8, 8, 6, 7, 7, 9,11,
+ 11,10,11,11,10,11,11,13,13,13,11,12,12,10,11,11,
+ 13,14,14,12,12,12, 6, 6, 6, 8, 6, 6, 8, 6, 6, 9,
+ 7, 7,12,10,10,10, 6, 6, 9, 7, 7,12,10,10,11, 7,
+ 6, 7, 8, 8,12,10,10,12,10,10,11,10,10,15,13,13,
+ 13,10,10,12,11,11,15,13,13,14,11,11, 8, 7, 7,12,
+ 11,11,12,11,11,11,11,11,14,14,14,13,12,12,12,11,
+ 11,16,15,15,14,12,12, 0,10,10, 0,11,11, 0,12,12,
+ 0,11,11, 0,14,14, 0,11,11, 0,11,11, 0,15,15, 0,
+ 11,11, 7, 8, 8,13,10,10,12,10,10,12,11,11,15,13,
+ 13,14,11,11,12,10,10,16,14,14,14,10,10, 8, 7, 7,
+ 12,11,11,13,11,11,12,11,11,15,14,14,14,12,12,13,
+ 12,12,15,14,14,15,12,12, 0,11,11, 0,12,12, 0,12,
+ 12, 0,12,12, 0,15,15, 0,12,12, 0,12,12, 0,15,14,
+ 0,12,12,
+};
+
+static const static_codebook _44p1_p3_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p1_p3_0,
+ 1, -531365888, 1616117760, 2, 0,
+ (long *)_vq_quantlist__44p1_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44p1_p3_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p1_p3_1[] = {
+ 2, 3, 4, 7, 7,10,12,12,12,12,10,11,11,13,13,11,
+ 12,12,11,11,12,12,12,12,12,11,13,13,13,13,12,12,
+ 12,13,14,12,13,13,13,13,12,13,13,13,13,12,13,13,
+ 13,13,11,13,13,13,13,12,12,12,14,14,12,13,13,12,
+ 12,12,12,13,13,13,12,13,13,13,13,12,13,13,13,13,
+ 12,12,12,14,14,12,13,13,12,12,12,13,13,13,13,12,
+ 13,13,12,12,12,13,13,13,13,12,12,12,14,14,12,13,
+ 13,12,12,12,13,13,13,13,12,13,13,12,12,10,10,11,
+ 10,10,11,11,11,11,11,11, 9, 9,10,10,12,11,11,10,
+ 10,12,10,10,10,10,13,12,12,12,12,13,11,11,11,11,
+ 13,12,12,12,12,13,11,11,11,11,13,12,12,12,12,13,
+ 12,12,12,12,13,11,11,11,11,13,12,12,12,12,13,11,
+ 11,11,11,13,12,12,11,11,13,12,12,11,11,13,11,11,
+ 11,11,13,12,12,11,11,13,11,11,11,11,13,12,12,11,
+ 11,13,12,12,11,11,13,11,11,11,11,13,12,12,11,11,
+ 13,11,11,11,11,13,12,12,11,11,11,11,11,10,10,11,
+ 11,11, 9, 9,11,12,12,11,11,12,12,12, 9, 9,13,13,
+ 13,10,10,13,13,13,11,11,13,13,13,14,14,13,13,13,
+ 11,10,13,13,14,12,12,13,13,13,11,11,13,13,13,11,
+ 11,13,13,13,14,14,13,13,13,10,10,13,13,13,11,11,
+ 13,13,13,10,10,13,14,13,11,11,13,14,14,14,14,13,
+ 13,13,10,10,13,14,14,11,11,13,13,13,10,10,13,14,
+ 14,11,11,13,13,13,14,14,14,13,13,10,10,13,14,14,
+ 11,11,13,13,13,10,10,14,12,12, 9, 9,14,12,12, 9,
+ 9,14,11,11, 9, 9,14,12,12, 8, 8,14,11,11, 7, 7,
+ 15,13,13,10,10,15,12,12,10,10,15,13,13,10,10,15,
+ 12,12,10,10,15,13,13,10,10,15,13,13,10,10,15,12,
+ 12,10,10,15,13,13,10,10,15,12,12,10,10,15,13,13,
+ 10,10,15,13,13,10,10,15,12,12,10,10,15,13,13, 9,
+ 9,15,12,12, 9, 9,14,13,13, 9, 9,15,13,13,10,10,
+ 15,12,12,10,10,15,13,13, 9, 9,15,12,12, 9, 9,15,
+ 13,13, 9, 9,13,12,12, 9, 9,13,13,13, 8, 8,13,13,
+ 13, 9, 9,13,13,13, 7, 7,14,13,13, 8, 8,14,14,14,
+ 10,10,15,14,14,11,11,14,14,14, 9, 9,15,14,14,10,
+ 10,15,14,14, 9, 9,14,14,14,10,10,15,14,14,11,11,
+ 15,14,14, 9, 9,14,14,14,10,10,14,14,14, 9, 9,15,
+ 14,15,10,10,15,14,14,11,11,14,14,14, 9, 9,14,14,
+ 14, 9, 9,14,14,14, 8, 8,15,14,14,10,10,15,14,14,
+ 11,11,14,14,14, 9, 9,15,14,14, 9, 9,14,14,14, 8,
+ 8,12,12,12,13,13,16,16,16,11,11,17,16,16,12,12,
+ 17,16,16,11,11,17,16,16,11,11,17,17,16,13,13,17,
+ 16,16,13,13,18,17,16,12,12,17,16,16,13,13,17,16,
+ 17,12,12,18,17,17,13,13,17,16,16,14,14,18,17,17,
+ 12,12,18,16,16,13,13,17,17,17,13,12,17,17,17,13,
+ 13,17,16,16,13,13,18,17,17,12,12,17,16,16,13,12,
+ 17,17,17,12,12,18,17,17,13,13,18,16,16,14,14,18,
+ 17,17,12,12,17,17,17,13,13,18,17,18,12,12,13,14,
+ 14,10,10,16,14,14,13,13,17,15,15,14,14,17,14,14,
+ 12,13,16,14,14,13,13,17,15,15,14,14,16,16,16,15,
+ 15,17,15,15,14,14,17,16,16,14,15,17,15,15,14,14,
+ 17,15,16,14,14,17,16,16,15,15,17,15,15,13,13,17,
+ 15,15,14,14,18,15,15,13,14,17,15,15,14,14,16,16,
+ 16,15,15,17,15,15,13,13,17,15,15,14,14,17,15,15,
+ 13,13,17,15,15,14,14,16,16,16,15,15,17,15,15,13,
+ 13,17,15,15,14,14,18,15,15,13,13,13,11,11,10,10,
+ 16,14,14,13,12,16,14,14,13,13,16,15,14,12,12,16,
+ 14,14,12,12,16,15,15,14,14,16,14,14,14,14,17,15,
+ 15,13,13,16,15,15,14,14,17,15,15,13,14,17,15,15,
+ 14,14,17,15,14,14,14,17,15,15,13,13,17,15,15,14,
+ 14,17,15,15,13,13,17,15,15,14,14,17,14,14,14,14,
+ 17,15,15,13,13,17,15,15,13,13,17,15,15,13,13,17,
+ 15,15,14,14,17,15,15,14,14,17,15,15,13,13,17,15,
+ 15,13,13,17,15,15,13,13,14,14,15, 8, 8,14,14,14,
+ 19,19,14,15,15,18,19,14,14,14,19,18,14,14,14,19,
+ 19,15,15,15,19,18,15,16,16,19,19,15,15,15,19,19,
+ 15,16,16,20,19,15,15,15,19,19,15,15,15,19,19,16,
+ 16,16,20,19,15,15,15,19,18,15,16,16,20,19,15,15,
+ 15,18,18,15,15,15,19,20,15,16,16,19,19,15,15,15,
+ 20,19,15,15,15,20,19,15,15,15,19,18,15,15,15,19,
+ 19,15,16,16,19,20,15,15,15,19,19,15,15,15,19,20,
+ 15,15,15,19,19,14,12,12, 9, 9,14,14,14,19,19,14,
+ 14,14,19,19,14,14,15,20,19,15,14,14,18,19,15,15,
+ 15,19,19,15,15,14,20,19,15,15,15,20,19,15,15,14,
+ 20,19,15,15,15,20,19,15,15,15,19,20,15,14,14,19,
+ 20,15,15,15,20,20,15,14,14,20,19,15,15,15,19,19,
+ 15,15,15,19,19,15,14,14,19,19,15,15,15,19,20,15,
+ 15,15,20,20,15,15,15,19,19,15,15,15,20,19,16,14,
+ 14,19,19,15,15,15,20,19,15,14,15,20,19,14,15,15,
+ 20,19,12,12,12,13,13,16,16,16,11,11,16,16,16,12,
+ 12,17,16,16,11,11,17,15,16,11,11,17,17,17,13,13,
+ 18,16,17,13,13,18,17,17,13,12,17,16,17,13,13,17,
+ 17,17,13,13,16,16,16,12,12,17,16,16,13,13,17,16,
+ 16,12,12,17,16,16,12,13,17,17,17,12,12,17,17,17,
+ 13,13,18,16,16,13,13,18,17,17,12,12,18,17,17,12,
+ 12,17,17,17,12,12,17,17,17,12,12,17,16,16,13,13,
+ 17,17,17,12,12,17,16,16,12,12,17,17,17,12,12,13,
+ 14,14, 9, 9,16,14,14,13,13,16,15,15,14,14,17,14,
+ 14,13,13,16,14,14,13,13,17,15,15,15,15,16,16,16,
+ 15,15,17,15,15,14,14,17,15,15,15,15,17,15,15,14,
+ 14,17,15,15,14,14,16,16,16,15,15,17,15,15,14,14,
+ 17,15,15,14,14,17,15,15,14,14,17,15,15,14,14,16,
+ 16,16,15,15,18,15,15,14,13,17,15,15,14,14,17,15,
+ 15,13,13,17,15,15,14,14,16,16,16,15,15,17,15,15,
+ 14,13,17,15,15,14,14,17,15,15,13,13,13,11,11,11,
+ 11,16,14,14,12,12,16,14,14,13,13,16,15,14,12,12,
+ 17,14,14,12,12,17,15,15,13,13,17,14,14,14,14,17,
+ 15,15,13,13,17,14,15,14,13,17,15,15,13,13,16,15,
+ 15,13,13,16,14,14,14,14,17,15,15,13,13,16,14,14,
+ 13,13,16,15,15,13,13,17,15,15,13,13,17,14,14,14,
+ 14,17,15,15,12,12,17,15,15,13,13,17,15,15,12,12,
+ 16,15,15,13,13,17,14,14,13,14,17,15,15,12,12,17,
+ 14,14,13,13,17,15,15,12,12,14,14,14, 8, 8,14,14,
+ 14,18,18,14,15,15,19,19,14,14,14,19,19,14,15,14,
+ 18,19,15,15,15,18,19,15,16,16,20,20,15,15,15,19,
+ 20,15,16,16,19,20,15,15,15,19,20,15,15,16,19,19,
+ 15,16,16,20,20,15,15,15,20,19,15,16,16,20,19,15,
+ 15,15,19,20,15,15,15,19,19,15,16,16,20,19,15,15,
+ 15,19,19,15,16,15,20,19,15,15,15,19,19,15,15,15,
+ 19,20,15,16,16,20,20,15,15,15,19,19,15,15,15,20,
+ 20,15,15,15,19,19,14,12,12, 9, 9,14,14,14,18,18,
+ 14,14,14,19,20,14,14,14,18,18,14,14,14,18,19,15,
+ 15,15,19,20,15,14,14,19,19,15,15,15,19,19,15,14,
+ 15,19,19,15,15,15,18,20,15,15,15,19,19,15,14,14,
+ 19,19,15,15,15,20,19,15,15,14,20,20,15,15,15,19,
+ 19,15,15,15,19,19,15,14,14,19,19,15,15,15,19,19,
+ 15,14,14,19,20,14,15,15,19,19,15,15,15,19,19,15,
+ 14,14,20,19,15,15,15,19,19,15,14,14,20,19,15,15,
+ 15,19,19,13,12,12,13,13,17,17,16,11,11,16,16,16,
+ 12,12,17,17,16,11,11,17,16,16,11,11,17,17,17,13,
+ 13,17,16,16,13,13,18,17,17,12,12,17,16,16,13,13,
+ 18,17,17,12,12,18,17,17,13,13,18,16,17,13,13,17,
+ 17,17,12,12,18,17,17,13,13,18,17,17,12,12,17,16,
+ 17,12,12,17,16,16,13,13,17,16,16,11,11,17,16,16,
+ 12,12,17,17,17,11,11,17,17,17,12,12,18,16,16,13,
+ 13,18,17,17,12,11,17,16,16,12,12,18,17,17,11,11,
+ 13,14,14, 9, 9,16,14,14,13,13,16,15,15,14,14,17,
+ 14,14,12,12,16,14,14,13,13,17,15,15,14,14,17,16,
+ 16,15,16,18,15,15,14,14,17,15,15,14,14,17,15,15,
+ 14,14,18,15,15,14,14,16,16,16,15,16,18,15,15,14,
+ 14,17,16,15,14,14,18,15,15,14,14,17,15,15,14,14,
+ 17,16,16,15,15,18,14,15,13,13,17,15,15,14,14,18,
+ 15,15,13,13,17,15,15,14,14,17,16,15,15,15,17,15,
+ 15,13,13,17,15,15,14,14,18,15,15,13,13,13,11,11,
+ 10,10,16,14,14,12,12,16,14,14,12,12,17,14,15,11,
+ 11,17,14,14,11,11,17,15,15,13,13,17,14,14,14,13,
+ 17,15,15,13,13,16,15,15,13,13,17,15,15,13,13,17,
+ 15,15,13,13,17,14,14,14,14,17,15,15,13,13,17,14,
+ 15,13,13,16,15,15,13,13,17,15,15,13,13,17,14,14,
+ 13,13,17,15,15,12,12,16,14,14,12,12,17,15,15,12,
+ 12,17,15,15,13,13,17,14,14,13,13,17,15,15,12,12,
+ 17,14,14,12,12,17,15,15,12,12,13,15,14, 8, 8,14,
+ 14,14,19,19,14,15,15,18,19,14,14,14,18,19,14,15,
+ 14,19,19,15,16,15,19,19,15,16,16,19,20,15,15,15,
+ 19,19,15,16,16,19,19,15,16,16,19,19,15,15,15,19,
+ 19,15,16,16,20,20,15,15,15,19,19,15,15,15,19,19,
+ 15,15,15,19,19,15,15,15,19,19,15,16,16,20,19,15,
+ 15,15,19,19,15,15,15,19,19,15,15,15,19,19,15,16,
+ 15,19,19,15,16,16,21,19,15,15,15,20,20,15,15,15,
+ 20,21,15,15,15,19,20,14,12,12, 8, 8,14,14,14,19,
+ 19,14,13,13,19,19,14,14,14,19,19,14,13,14,19,19,
+ 15,15,15,20,20,15,14,14,20,19,15,15,15,19,20,15,
+ 14,14,19,20,15,15,15,20,19,15,15,15,19,20,15,14,
+ 14,20,20,15,15,15,20,19,15,14,14,19,19,15,15,15,
+ 19,19,15,15,15,20,19,15,14,14,21,19,15,15,15,20,
+ 21,15,14,14,21,19,15,15,15,19,19,15,15,15,20,20,
+ 15,14,14,19,21,15,15,15,19,19,15,14,14,19,20,15,
+ 15,15,19,19,13,12,12,13,13,17,16,16,11,11,17,16,
+ 15,12,12,18,16,16,11,11,17,16,16,11,11,18,17,17,
+ 13,13,18,16,16,13,13,17,17,17,12,13,18,17,16,13,
+ 13,18,17,17,13,13,17,17,17,13,13,17,16,16,13,13,
+ 18,16,17,12,12,17,16,16,13,12,17,17,17,12,12,18,
+ 17,17,13,12,18,16,16,13,13,18,17,17,12,12,17,16,
+ 16,12,12,17,17,17,11,11,17,16,16,12,12,17,16,16,
+ 13,13,17,16,16,11,11,17,16,16,12,12,17,17,17,11,
+ 11,13,14,14, 9, 9,16,14,14,13,13,16,15,15,14,14,
+ 17,14,14,12,12,16,14,14,13,13,17,15,15,14,14,17,
+ 15,16,15,15,17,15,15,14,14,17,15,16,14,15,18,15,
+ 15,14,14,17,15,15,14,14,16,16,16,15,15,18,15,15,
+ 13,14,17,15,15,14,14,18,15,15,14,14,17,15,15,14,
+ 14,17,16,16,15,15,17,15,15,13,13,17,15,15,14,14,
+ 18,15,15,13,13,17,15,15,14,14,17,16,16,15,15,17,
+ 15,15,13,13,17,15,15,14,14,18,15,15,13,13,13,11,
+ 11,10,10,16,14,14,12,12,16,14,14,13,13,17,14,14,
+ 11,11,17,14,14,12,12,17,15,15,14,14,17,14,14,14,
+ 14,17,15,15,13,13,17,15,14,13,13,16,15,15,13,13,
+ 16,15,15,13,13,17,14,14,14,14,17,15,15,13,13,17,
+ 14,14,13,13,16,15,15,13,13,16,15,15,13,13,17,14,
+ 14,13,13,17,15,15,12,12,17,14,14,12,12,16,15,15,
+ 12,12,17,15,15,13,13,17,14,14,13,13,17,15,15,12,
+ 12,17,14,14,12,12,16,15,15,12,12,14,14,14, 8, 8,
+ 14,14,14,18,18,14,15,15,19,18,14,14,14,18,18,14,
+ 14,14,18,19,15,16,15,19,19,15,17,16,20,20,15,15,
+ 15,19,19,15,16,16,19,19,15,15,15,19,19,15,16,15,
+ 18,19,15,16,16,20,20,15,15,15,19,19,15,16,16,19,
+ 20,15,15,15,19,19,15,15,16,19,19,15,16,16,20,20,
+ 15,15,15,19,19,15,15,15,19,20,15,15,15,19,19,15,
+ 15,15,19,19,15,16,16,20,20,15,15,15,19,20,15,16,
+ 16,20,20,15,15,15,19,19,13,12,12, 8, 8,14,14,14,
+ 19,20,14,14,14,19,19,14,14,14,18,19,14,14,14,19,
+ 20,15,15,15,19,20,15,14,14,21,20,15,15,15,20,20,
+ 15,15,14,19,19,15,15,15,19,19,15,15,15,19,19,15,
+ 14,14,19,20,15,15,15,19,20,15,14,14,19,19,15,15,
+ 15,19,19,15,15,15,19,19,16,14,14,19,19,15,15,15,
+ 20,20,15,14,14,21,19,15,15,15,19,19,15,15,15,19,
+ 20,16,14,14,19,20,15,15,15,19,19,15,14,14,19,19,
+ 15,15,15,20,19,
+};
+
+static const static_codebook _44p1_p3_1 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p1_p3_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p1_p3_1,
+ 0
+};
+
+static const long _vq_quantlist__44p1_p4_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p1_p4_0[] = {
+ 2, 6, 6,14,14, 6, 7, 7,14,14, 7, 7, 7,14,14, 0,
+ 13,13,16,16, 0,13,13,15,14, 7, 8, 8,15,15, 9,10,
+ 10,16,16, 9, 8, 8,15,15, 0,13,13,17,16, 0,13,13,
+ 15,16, 8, 8, 8,15,15,12,11,11,16,16, 9, 8, 8,14,
+ 14, 0,13,13,17,18, 0,13,13,15,15, 0,14,14,16,16,
+ 0, 0, 0,19,18, 0,12,12,16,15, 0,15,16, 0,20, 0,
+ 14,14,16,16, 0,14,14,17,17, 0, 0, 0,19,18, 0,12,
+ 12,15,15, 0,17,17, 0,20, 0,14,14,16,16, 5, 6, 7,
+ 12,12, 9, 9, 9,14,14,10,10,10,14,14, 0,21,21,18,
+ 17, 0,20,20,18,17, 9,10,10,14,14,12,12,12,16,16,
+ 12,10,10,14,14, 0,20,19,18,17, 0, 0,20,17,18,11,
+ 10,10,14,14,14,13,13,18,18,13,11,11,14,14, 0,20,
+ 20,17,18, 0,21,21,17,17, 0,21, 0,18,18, 0, 0, 0,
+ 0, 0, 0,20,19,16,17, 0, 0, 0,19,19, 0, 0, 0,18,
+ 18, 0,21,21,18,18, 0, 0, 0, 0, 0, 0,20,20,16,17,
+ 0, 0, 0,21,21, 0, 0, 0,18,19, 6, 6, 6,13,12, 8,
+ 6, 6,11,11, 8, 6, 6,13,13, 0, 9, 9,11,11, 0,11,
+ 10,14,14, 9, 7, 7,13,13,11, 9, 9,13,13,10, 6, 6,
+ 13,13, 0,10,10,14,15, 0,10,10,13,13, 9, 7, 7,13,
+ 13,13,10, 9,13,13,10, 6, 6,13,13, 0,10,10,15,14,
+ 0,10,10,13,13, 0,11,11,15,15, 0,19,20,17,17, 0,
+ 9, 9,13,13, 0,13,13,20,20, 0,11,11,13,13, 0,11,
+ 11,15,15, 0,19,19,17,17, 0,10,10,13,13, 0,15,15,
+ 20,20, 0,12,12,13,13, 0,10,10,12,12, 0,11,11,15,
+ 15, 0,11,11,15,15, 0,15,15,20, 0, 0,16,16, 0,21,
+ 0,11,11,15,15, 0,14,14,18,17, 0,11,11,15,15, 0,
+ 15,16,19,20, 0,16,16,21,21, 0,12,12,15,15, 0,15,
+ 14,18,18, 0,11,11,16,16, 0,15,15,21,21, 0,16,15,
+ 0, 0, 0,16,16,21, 0, 0, 0, 0, 0, 0, 0,14,14,20,
+ 20, 0,18,18, 0, 0, 0,16,17,21, 0, 0,16,16,21,21,
+ 0, 0, 0, 0, 0, 0,15,15,21,21, 0,20,19, 0,21, 0,
+ 17,17, 0, 0, 0,10,10,12,11, 0,10,10,10,11, 0,11,
+ 11,12,12, 0,11,11, 9, 9, 0,13,13,11,12, 0,11,11,
+ 12,12, 0,13,13,12,12, 0,10,10,12,12, 0,12,12,13,
+ 13, 0,12,12,12,12, 0,11,11,12,12, 0,13,13,12,12,
+ 0,10,10,12,12, 0,13,13,14,14, 0,12,12,12,12, 0,
+ 14,14,14,13, 0,19,20,15,15, 0,12,11,12,12, 0,15,
+ 15,21,20, 0,13,13,11,11, 0,13,13,13,13, 0,19, 0,
+ 15,15, 0,12,12,12,12, 0,17,16,19, 0, 0,13,13,12,
+ 12, 7, 7, 7,16,16,11, 9, 9,15,15,12, 9, 9,16,16,
+ 0,13,13,15,14, 0,14,14,17,16,10, 9, 9,16,16,14,
+ 11,11,17,16,12, 9, 8,15,15, 0,13,13,18,18, 0,13,
+ 13,15,15,12,10,10,18,17,15,12,12,17,17,14, 9, 9,
+ 16,16, 0,13,13,18,19, 0,14,13,17,16, 0,14,14,18,
+ 18, 0, 0, 0,20,21, 0,12,12,16,16, 0,16,16,20,21,
+ 0,14,14,17,16, 0,14,14,18,19, 0, 0, 0,19,21, 0,
+ 13,13,17,17, 0,17,17, 0,21, 0,15,15,16,16, 8, 7,
+ 7,14,14,11,10,10,15,15,12,10,10,15,15, 0,20,20,
+ 18,18, 0, 0, 0,17,17,11,10,10,16,16,14,12,12,18,
+ 17,14,11,11,15,15, 0,20,21,18,18, 0, 0,19,18,17,
+ 12,10,10,16,16,17,14,14,19,19,14,11,11,15,15, 0,
+ 21,21,19,19, 0,21,20,19,18, 0,21, 0,18,19, 0, 0,
+ 0, 0, 0, 0,20,20,18,17, 0,21, 0, 0, 0, 0, 0, 0,
+ 19,18, 0, 0, 0,18,19, 0, 0, 0, 0, 0, 0, 0,21,17,
+ 18, 0, 0, 0, 0,21, 0, 0,21,18,19,11, 9, 9,14,14,
+ 13,10,10,13,13,13,11,11,15,15, 0,13,13,12,12, 0,
+ 15,15,16,16,13,10,10,15,15,16,12,12,15,15,15,10,
+ 10,15,15, 0,14,13,16,15, 0,14,13,15,15,13,10,10,
+ 15,15,18,14,14,15,15,15,10,10,14,15, 0,14,14,16,
+ 16, 0,14,14,16,15, 0,15,15,17,16, 0,21, 0,18,18,
+ 0,12,13,15,15, 0,16,16, 0, 0, 0,14,14,15,15, 0,
+ 15,15,16,16, 0,21,20,18,18, 0,13,13,15,15, 0,19,
+ 18, 0, 0, 0,15,15,15,15, 0,11,11,13,13, 0,12,12,
+ 16,16, 0,12,12,16,16, 0,15,16,20, 0, 0,16,17, 0,
+ 0, 0,12,12,16,16, 0,14,14,18,18, 0,11,11,16,17,
+ 0,15,15,20, 0, 0,16,16, 0, 0, 0,12,12,16,16, 0,
+ 15,15,19,19, 0,11,11,17,17, 0,16,16,21, 0, 0,16,
+ 16, 0, 0, 0,17,17,20,20, 0, 0, 0, 0, 0, 0,15,15,
+ 20, 0, 0,17,18, 0, 0, 0,17,17, 0, 0, 0,16,16, 0,
+ 21, 0, 0, 0, 0, 0, 0,15,15,21, 0, 0,19,18, 0, 0,
+ 0,18,17, 0, 0, 0,11,11,14,14, 0,11,11,15,15, 0,
+ 12,12,16,16, 0,13,13,14,14, 0,14,14,17,17, 0,12,
+ 12,16,16, 0,14,14,16,16, 0,11,11,16,15, 0,13,13,
+ 16,17, 0,13,13,16,16, 0,12,12,15,16, 0,15,14,16,
+ 16, 0,11,11,15,15, 0,14,14,17,17, 0,13,13,16,16,
+ 0,15,14,18,18, 0,21, 0,19,19, 0,13,13,15,15, 0,
+ 16,16,20,20, 0,14,14,16,15, 0,14,14,17,17, 0,21,
+ 0,20,18, 0,13,13,15,15, 0,17,17, 0, 0, 0,14,14,
+ 16,15, 8, 8, 8,16,16,12, 9, 9,16,16,13, 9, 9,16,
+ 16, 0,14,14,18,17, 0,14,14,16,17,12,10,10,18,17,
+ 14,11,11,18,18,14, 9, 9,16,16, 0,13,13,18,18, 0,
+ 13,13,17,16,12, 9, 9,16,17,17,13,13,16,16,14, 9,
+ 9,15,15, 0,14,14,20,20, 0,13,13,15,15, 0,15,14,
+ 18,18, 0, 0, 0,20,21, 0,12,13,16,17, 0,16,16,20,
+ 21, 0,14,14,16,17, 0,14,14,18,17, 0, 0, 0,20,21,
+ 0,13,13,16,16, 0,19,17, 0,21, 0,14,15,16,16, 8,
+ 7, 7,14,13,12,10,10,15,15,13,10,10,15,15, 0,21,
+ 21,18,19, 0,20,21,18,18,12,10,10,16,15,15,12,12,
+ 17,17,14,11,11,15,15, 0,21,21,19,18, 0, 0,21,17,
+ 18,13,11,11,15,15,16,13,13,18,19,15,11,11,15,14,
+ 0,21, 0,19,19, 0, 0,21,18,18, 0, 0,21,19,19, 0,
+ 0, 0, 0, 0, 0,20,19,17,17, 0, 0, 0,21, 0, 0,21,
+ 0,18,19, 0, 0,20,20,19, 0, 0, 0, 0, 0, 0,21,20,
+ 18,17, 0, 0, 0, 0,20, 0, 0, 0,18,19, 0,10,10,15,
+ 14, 0,11,11,14,14, 0,11,11,15,16, 0,14,14,15,15,
+ 0,15,15,16,16, 0,11,11,16,16, 0,14,13,16,16, 0,
+ 11,11,15,15, 0,14,14,16,16, 0,14,14,15,15, 0,11,
+ 11,15,15, 0,13,13,15,15, 0,11,11,15,15, 0,15,15,
+ 18,17, 0,14,14,15,15, 0,15,16,18,18, 0, 0, 0,20,
+ 20, 0,14,13,16,15, 0,17,17,21, 0, 0,15,15,15,15,
+ 0,16,15,17,17, 0, 0, 0,19,19, 0,13,13,15,15, 0,
+ 20,19, 0, 0, 0,15,15,15,15, 0,11,11,13,13, 0,12,
+ 12,16,16, 0,12,12,16,16, 0,15,15,21,21, 0,17,16,
+ 0, 0, 0,12,12,16,16, 0,14,14,17,17, 0,11,11,16,
+ 16, 0,15,15, 0, 0, 0,16,16,21, 0, 0,12,12,17,16,
+ 0,14,15,20,20, 0,11,11,16,16, 0,15,15, 0,20, 0,
+ 16,16, 0,21, 0,16,17,21, 0, 0, 0, 0, 0, 0, 0,15,
+ 15, 0,21, 0,18,18, 0, 0, 0,17,16, 0, 0, 0,17,17,
+ 21, 0, 0, 0, 0, 0, 0, 0,15,15, 0,20, 0,19,20,21,
+ 0, 0,17,18, 0, 0, 0,12,12,15,15, 0,12,12,15,15,
+ 0,12,12,16,16, 0,13,13,15,15, 0,15,15,17,17, 0,
+ 13,12,17,16, 0,14,14,17,16, 0,11,11,16,16, 0,14,
+ 14,17,17, 0,14,14,17,17, 0,12,12,16,16, 0,15,15,
+ 17,17, 0,11,11,16,16, 0,14,14,17,17, 0,14,14,16,
+ 16, 0,15,15,18,17, 0, 0, 0,19, 0, 0,13,13,16,16,
+ 0,16,16, 0,21, 0,14,14,16,16, 0,15,15,18,17, 0,
+ 0, 0,19,19, 0,13,13,16,16, 0,18,17, 0,21, 0,14,
+ 15,16,16, 0,11,11,16,16, 0,13,13,17,17, 0,13,13,
+ 17,17, 0,16,16,16,17, 0,16,16,18,18, 0,12,12,17,
+ 17, 0,16,15,18,17, 0,12,12,16,16, 0,16,15,19,19,
+ 0,16,15,17,17, 0,12,12,17,18, 0,16,16,18,18, 0,
+ 12,12,16,16, 0,16,16,19,19, 0,15,16,17,17, 0,15,
+ 16,18,18, 0, 0, 0,20,20, 0,13,13,16,16, 0,18,18,
+ 21,20, 0,15,15,16,16, 0,16,16,19,18, 0, 0, 0,19,
+ 20, 0,14,14,17,17, 0,19,19, 0,21, 0,15,16,16,16,
+ 0, 9, 9,14,14, 0,13,13,15,15, 0,14,14,15,15, 0,
+ 0,21,19,19, 0, 0,21,18,18, 0,12,12,15,15, 0,15,
+ 15,18,18, 0,14,13,15,15, 0,21,21,18,19, 0,21,20,
+ 18,18, 0,13,13,16,16, 0,17,17,18,19, 0,14,14,15,
+ 15, 0, 0,21,19,19, 0,21,20,18,19, 0,20,20,19,19,
+ 0, 0, 0, 0, 0, 0,19,20,17,17, 0, 0, 0,21,21, 0,
+ 21, 0,18,20, 0,21, 0,18,21, 0, 0, 0, 0, 0, 0,21,
+ 21,19,18, 0, 0, 0, 0, 0, 0, 0, 0,19,19, 0,18,18,
+ 15,15, 0,18,20,17,16, 0,20, 0,17,17, 0,21, 0,17,
+ 17, 0,21,20,19,20, 0,19,19,16,16, 0,21,21,17,18,
+ 0,19,19,17,17, 0,20,21,21,21, 0,20,20,18,18, 0,
+ 19,19,16,16, 0, 0,21,18,19, 0,18,19,16,17, 0,21,
+ 21,19,20, 0,21,19,18,18, 0,21,20,19,21, 0, 0, 0,
+ 20,21, 0,19,19,17,16, 0, 0, 0, 0, 0, 0,21,20,17,
+ 17, 0,20,21,19,18, 0, 0, 0, 0,21, 0,19,18,16,17,
+ 0, 0, 0, 0, 0, 0,20,20,17,17, 0,11,11,14,14, 0,
+ 13,13,16,16, 0,13,13,16,16, 0,17,17,21, 0, 0,17,
+ 18, 0, 0, 0,12,12,16,16, 0,15,15,17,18, 0,12,12,
+ 16,16, 0,16,16, 0,20, 0,17,17, 0,21, 0,12,12,17,
+ 17, 0,16,16,19,20, 0,12,12,17,17, 0,17,17, 0,20,
+ 0,17,17, 0, 0, 0,17,17,21, 0, 0, 0, 0, 0, 0, 0,
+ 15,15, 0,20, 0,19,19, 0, 0, 0,18,18, 0, 0, 0,17,
+ 17, 0, 0, 0, 0, 0, 0, 0, 0,15,15, 0, 0, 0,20,19,
+ 0, 0, 0,19,18, 0, 0, 0,14,14,21,19, 0,16,16,20,
+ 21, 0,16,16,20,20, 0,17,17,20, 0, 0,17,17,20,20,
+ 0,15,15,20,20, 0,19,18,20, 0, 0,15,15,20,20, 0,
+ 17,18,21,20, 0,17,17,20,21, 0,15,15,19,19, 0,19,
+ 18,21,21, 0,15,15,19,20, 0,17,18, 0, 0, 0,17,17,
+ 20,20, 0,17,18,20,21, 0, 0, 0, 0, 0, 0,15,15,20,
+ 20, 0,19,19, 0, 0, 0,17,17,19,21, 0,17,17, 0,21,
+ 0, 0, 0, 0,21, 0,15,15,20,19, 0, 0,20, 0, 0, 0,
+ 17,17,21,20, 0,12,12,16,16, 0,14,14,17,17, 0,13,
+ 13,17,17, 0,16,16,17,18, 0,17,16,18,18, 0,13,13,
+ 18,17, 0,15,16,19,18, 0,13,13,16,16, 0,16,16,19,
+ 19, 0,16,16,17,17, 0,13,12,17,17, 0,16,16,18,17,
+ 0,12,12,16,16, 0,17,17,19,18, 0,16,15,16,16, 0,
+ 16,17,18,19, 0, 0, 0,20,20, 0,14,14,17,16, 0,18,
+ 18,21, 0, 0,16,16,16,16, 0,16,16,18,17, 0, 0,21,
+ 21,21, 0,14,14,16,16, 0,21,20,21, 0, 0,16,16,16,
+ 16, 0,10,10,14,14, 0,14,14,15,16, 0,14,14,15,15,
+ 0, 0,21,18,18, 0, 0,21,18,19, 0,13,13,16,16, 0,
+ 16,16,18,17, 0,14,14,15,15, 0,20, 0,18,18, 0,21,
+ 0,18,17, 0,13,13,16,15, 0,17,17,19,19, 0,14,14,
+ 15,15, 0,20,20,18,19, 0, 0, 0,18,17, 0, 0,21,18,
+ 18, 0, 0, 0, 0, 0, 0,20,21,18,17, 0, 0, 0, 0, 0,
+ 0, 0, 0,19,19, 0, 0,21,18,18, 0, 0, 0, 0, 0, 0,
+ 21, 0,18,17, 0, 0, 0, 0,21, 0, 0, 0,19,20, 0,19,
+ 19,16,16, 0, 0,21,18,17, 0,21, 0,18,18, 0,20, 0,
+ 19,18, 0,21,20,19,19, 0,21,19,17,18, 0, 0,21,19,
+ 19, 0,21,19,18,18, 0,21, 0,20,18, 0, 0,21,18,18,
+ 0,20,21,17,17, 0,21, 0,18,18, 0,21,19,17,17, 0,
+ 21, 0, 0,20, 0, 0,20,17,18, 0, 0, 0,19,20, 0, 0,
+ 0,20,19, 0,19,21,17,18, 0,21, 0, 0, 0, 0,21,21,
+ 18,17, 0, 0,21,18,18, 0, 0, 0, 0,21, 0,20,19,16,
+ 17, 0, 0, 0, 0, 0, 0,21,20,17,17, 0,11,11,13,13,
+ 0,13,13,16,16, 0,13,13,16,16, 0,17,17, 0,21, 0,
+ 18,19,21, 0, 0,12,12,16,16, 0,15,15,19,18, 0,13,
+ 13,16,16, 0,16,17,21,19, 0,17,17,21,21, 0,13,13,
+ 16,16, 0,16,16,20,18, 0,13,13,16,16, 0,17,17, 0,
+ 0, 0,18,18, 0, 0, 0,18,17, 0,20, 0, 0, 0, 0, 0,
+ 0,15,15,21,21, 0,19,18, 0, 0, 0,17,17,21,21, 0,
+ 17,17, 0, 0, 0, 0, 0, 0, 0, 0,15,15,20,21, 0,20,
+ 20, 0, 0, 0,19,19, 0, 0, 0,14,15,21,19, 0,16,16,
+ 0,21, 0,17,16,21,21, 0,17,18,21,20, 0,18,18, 0,
+ 21, 0,16,16, 0,20, 0,19,19, 0, 0, 0,16,15, 0,20,
+ 0,18,18, 0, 0, 0,17,17, 0,21, 0,16,16,20,20, 0,
+ 20,19, 0, 0, 0,15,16,21,22, 0,18,18, 0, 0, 0,18,
+ 17, 0, 0, 0,18,18, 0, 0, 0, 0, 0, 0, 0, 0,16,16,
+ 21,20, 0,19,20, 0, 0, 0,18,17,21, 0, 0,17,18, 0,
+ 0, 0, 0, 0, 0, 0, 0,16,16, 0,20, 0, 0,20, 0, 0,
+ 0,18,18,22, 0,
+};
+
+static const static_codebook _44p1_p4_0 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p1_p4_0,
+ 1, -528744448, 1616642048, 3, 0,
+ (long *)_vq_quantlist__44p1_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44p1_p4_1[] = {
+ 3,
+ 2,
+ 4,
+ 1,
+ 5,
+ 0,
+ 6,
+};
+
+static const long _vq_lengthlist__44p1_p4_1[] = {
+ 2, 3, 3, 3, 3, 3, 3,
+};
+
+static const static_codebook _44p1_p4_1 = {
+ 1, 7,
+ (long *)_vq_lengthlist__44p1_p4_1,
+ 1, -533200896, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p1_p4_1,
+ 0
+};
+
+static const long _vq_quantlist__44p1_p5_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p1_p5_0[] = {
+ 1, 6, 6, 7, 8, 8, 7, 8, 8, 7, 9, 8,10,11,11, 9,
+ 8, 8, 7, 8, 8,11,11,11, 9, 8, 8, 6, 7, 7,10,10,
+ 10,10,10,10,10,10,10,14,13,13,12,11,11,10,10,10,
+ 14,14,13,12,11,11, 6, 6, 6, 8, 5, 5, 8, 7, 7, 9,
+ 7, 7,11,10,10, 9, 7, 7, 9, 7, 7,12,10,10,10, 7,
+ 7, 7, 8, 8,12,11,10,12,10,10,11,10,10,15,13,13,
+ 13,10,10,11,10,10,17,14,13,13,10,10, 7, 7, 7,12,
+ 11,12,12,11,11,12,11,11,16,14,14,13,12,12,12,11,
+ 11,17,15,14,14,12,12,10, 9, 9,13,11,11,13,11,11,
+ 13,11,11,17,14,13,14,11,11,12,11,11,16,15,14,14,
+ 11,11, 7, 8, 8,12,11,11,12,10,10,12,10,10,15,13,
+ 13,14,11,10,12,10,10,16,14,14,14,10,10, 8, 7, 7,
+ 12,11,11,12,11,11,12,11,11,17,14,14,14,12,12,12,
+ 11,11,16,15,15,14,12,12,10,10,10,13,11,11,13,11,
+ 11,13,11,12,16,14,14,14,11,11,13,12,11,16,15,15,
+ 14,11,11,
+};
+
+static const static_codebook _44p1_p5_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p1_p5_0,
+ 1, -527106048, 1620377600, 2, 0,
+ (long *)_vq_quantlist__44p1_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44p1_p5_1[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p1_p5_1[] = {
+ 2, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 9, 8, 8, 8,
+ 7, 7, 8, 8, 8, 9, 8, 8, 9, 7, 7, 6, 6, 6, 9, 8,
+ 7, 9, 7, 7, 9, 8, 8,10, 8, 8,10, 8, 8,10, 8, 8,
+ 10, 8, 8,10, 8, 8, 7, 6, 6, 9, 6, 6, 9, 7, 7, 9,
+ 7, 7,10, 8, 8, 9, 6, 6, 9, 7, 7,10, 8, 8, 9, 7,
+ 7, 7, 8, 8,11, 9, 9,11, 9, 9,11, 8, 9,12, 9, 9,
+ 12, 8, 8,11, 9, 9,12, 9, 9,12, 8, 8, 8, 7, 7,10,
+ 9, 9,10,10, 9,10, 9, 9,11,10,10,11, 9, 9,11, 9,
+ 9,11,10,11,11, 9, 9,10, 8, 8,11, 9, 9,10, 9, 9,
+ 11, 9, 9,11,10,10,11, 9, 9,11, 9, 9,11,10,10,11,
+ 9, 9, 9, 8, 8,11, 9, 9,12, 9, 9,11, 9, 9,12, 9,
+ 9,12, 8, 8,12, 9, 9,12, 9, 9,12, 8, 8, 9, 7, 7,
+ 11, 9, 9,11,10,10,11, 9, 9,11,11,11,11, 9, 9,11,
+ 10,10,11,11,11,11, 9, 9,10, 9, 9,11, 9, 9,11,10,
+ 10,11, 9, 9,11,10,10,11, 9, 9,11, 9,10,11,10,10,
+ 11, 9, 9,
+};
+
+static const static_codebook _44p1_p5_1 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p1_p5_1,
+ 1, -530841600, 1616642048, 2, 0,
+ (long *)_vq_quantlist__44p1_p5_1,
+ 0
+};
+
+static const long _vq_quantlist__44p1_p6_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p1_p6_0[] = {
+ 1, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 8, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 7, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 7, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9,
+};
+
+static const static_codebook _44p1_p6_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p1_p6_0,
+ 1, -516716544, 1630767104, 2, 0,
+ (long *)_vq_quantlist__44p1_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44p1_p6_1[] = {
+ 12,
+ 11,
+ 13,
+ 10,
+ 14,
+ 9,
+ 15,
+ 8,
+ 16,
+ 7,
+ 17,
+ 6,
+ 18,
+ 5,
+ 19,
+ 4,
+ 20,
+ 3,
+ 21,
+ 2,
+ 22,
+ 1,
+ 23,
+ 0,
+ 24,
+};
+
+static const long _vq_lengthlist__44p1_p6_1[] = {
+ 1, 3, 2, 5, 4, 7, 7, 8, 8, 9, 9,10,10,11,11,12,
+ 12,13,13,13,14,16,16,16,16,
+};
+
+static const static_codebook _44p1_p6_1 = {
+ 1, 25,
+ (long *)_vq_lengthlist__44p1_p6_1,
+ 1, -518864896, 1620639744, 5, 0,
+ (long *)_vq_quantlist__44p1_p6_1,
+ 0
+};
+
+static const long _vq_quantlist__44p1_p6_2[] = {
+ 12,
+ 11,
+ 13,
+ 10,
+ 14,
+ 9,
+ 15,
+ 8,
+ 16,
+ 7,
+ 17,
+ 6,
+ 18,
+ 5,
+ 19,
+ 4,
+ 20,
+ 3,
+ 21,
+ 2,
+ 22,
+ 1,
+ 23,
+ 0,
+ 24,
+};
+
+static const long _vq_lengthlist__44p1_p6_2[] = {
+ 3, 4, 4, 5, 4, 5, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5,
+};
+
+static const static_codebook _44p1_p6_2 = {
+ 1, 25,
+ (long *)_vq_lengthlist__44p1_p6_2,
+ 1, -529006592, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44p1_p6_2,
+ 0
+};
+
+static const long _huff_lengthlist__44p1_short[] = {
+ 4, 5, 7, 8,10,13,14, 4, 2, 4, 6, 8,11,12, 7, 4,
+ 3, 5, 8,12,14, 8, 5, 4, 4, 8,12,12, 9, 7, 7, 7,
+ 9,10,11,13,11,11, 9, 7, 8,10,13,11,10, 6, 5, 7,
+ 9,
+};
+
+static const static_codebook _huff_book__44p1_short = {
+ 2, 49,
+ (long *)_huff_lengthlist__44p1_short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44p2_l0_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44p2_l0_0[] = {
+ 1, 4, 4, 7, 7, 8, 8, 9, 9,10,10,11,11, 4, 6, 5,
+ 8, 7, 9, 8,10, 9,11,10,11,11, 4, 5, 6, 7, 8, 8,
+ 9, 9,10,10,10,10,11, 8, 9, 8,10, 8,10, 9,11,10,
+ 11,11,11,11, 8, 8, 9, 8,10, 9,10,10,11,11,11,11,
+ 11, 9,10,10,11,11,11,11,11,11,12,11,12,11, 9,10,
+ 10,10,11,11,11,11,11,11,12,11,12,10,11,11,12,11,
+ 12,12,12,12,12,12,12,12,10,11,11,11,11,12,12,12,
+ 13,12,12,12,12,11,12,12,12,12,13,13,12,12,12,12,
+ 12,12,11,12,12,12,12,13,13,12,13,12,12,12,12,12,
+ 13,13,13,13,13,13,12,13,12,13,12,12,12,13,13,13,
+ 13,13,13,13,12,13,12,12,12,
+};
+
+static const static_codebook _44p2_l0_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44p2_l0_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44p2_l0_0,
+ 0
+};
+
+static const long _vq_quantlist__44p2_l0_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p2_l0_1[] = {
+ 2, 4, 4, 5, 5, 4, 5, 5, 6, 5, 4, 5, 5, 5, 6, 5,
+ 5, 6, 6, 6, 5, 6, 5, 6, 6,
+};
+
+static const static_codebook _44p2_l0_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44p2_l0_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p2_l0_1,
+ 0
+};
+
+static const long _vq_quantlist__44p2_l1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p2_l1_0[] = {
+ 1, 4, 4, 4, 4, 4, 4, 4, 4,
+};
+
+static const static_codebook _44p2_l1_0 = {
+ 2, 9,
+ (long *)_vq_lengthlist__44p2_l1_0,
+ 1, -516716544, 1630767104, 2, 0,
+ (long *)_vq_quantlist__44p2_l1_0,
+ 0
+};
+
+static const long _huff_lengthlist__44p2_lfe[] = {
+ 1, 3, 2, 3,
+};
+
+static const static_codebook _huff_book__44p2_lfe = {
+ 2, 4,
+ (long *)_huff_lengthlist__44p2_lfe,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44p2_long[] = {
+ 3, 4, 9, 8, 8,10,13,16, 4, 2, 9, 5, 7,10,14,18,
+ 9, 7, 6, 5, 7, 9,12,16, 7, 5, 5, 3, 5, 8,11,13,
+ 8, 7, 7, 5, 5, 7, 9,11,10,10, 9, 8, 6, 6, 8,10,
+ 13,14,13,11, 9, 8, 9,10,17,18,16,14,11,10,10,10,
+};
+
+static const static_codebook _huff_book__44p2_long = {
+ 2, 64,
+ (long *)_huff_lengthlist__44p2_long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44p2_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p2_p1_0[] = {
+ 1, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0,
+};
+
+static const static_codebook _44p2_p1_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p2_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44p2_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44p2_p2_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p2_p2_0[] = {
+ 1, 4, 4, 0, 0, 0, 8, 8, 0, 0, 0, 9, 9, 0, 0, 0,
+ 10,10, 0, 0, 0, 0, 0, 0, 0, 0,10,10, 0, 0, 0, 0,
+ 0, 0, 0, 0, 9, 9, 0, 0, 0,11,11, 0, 0, 0, 0, 0,
+ 0, 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0,
+ 0, 0,11,11, 0, 0, 0, 0, 0, 0, 0, 0,11,11, 0, 0,
+ 0, 0, 0, 0, 0, 0,10,10, 0, 0, 0,11,11, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7, 0, 0, 0,
+ 6, 6, 0, 0, 0, 7, 7, 0, 0, 0, 8, 8, 0, 0, 0, 0,
+ 0, 0, 0, 0, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7,
+ 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 0,
+ 0, 0, 0, 0, 0, 0, 0, 7, 7, 0, 0, 0, 9, 9, 0, 0,
+ 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0,
+ 8, 8, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 0, 0, 0, 8, 8, 0,
+ 0, 0,10,10, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0,
+ 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0,
+ 11,11, 0, 0, 0, 0, 0, 0, 0, 0,10,10, 0, 0, 0, 0,
+ 0, 0, 0, 0, 9, 9, 0, 0, 0,11,10, 0, 0, 0, 0, 0,
+ 0, 0, 0,11,11, 0, 0, 0, 0, 0, 0, 0, 0,10,10, 0,
+ 0, 0,11,11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 8, 8, 0, 0, 0,10,10, 0, 0, 0,11,11, 0, 0,
+ 0,12,12, 0, 0, 0, 0, 0, 0, 0, 0,11,11, 0, 0, 0,
+ 0, 0, 0, 0, 0,10,10, 0, 0, 0,13,13, 0, 0, 0, 0,
+ 0, 0, 0, 0,13,13, 0, 0, 0, 0, 0, 0, 0, 0,12,12,
+ 0, 0, 0,13,13, 0, 0, 0, 0, 0, 0, 0, 0,13,13, 0,
+ 0, 0, 0, 0, 0, 0, 0,12,12, 0, 0, 0,13,13, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6,
+ 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0,11,11,
+ 0, 0, 0,12,12, 0, 0, 0,12,12, 0, 0, 0, 0, 0, 0,
+ 0, 0,13,13, 0, 0, 0, 0, 0, 0, 0, 0,12,11, 0, 0,
+ 0,12,12, 0, 0, 0, 0, 0, 0, 0, 0,13,13, 0, 0, 0,
+ 0, 0, 0, 0, 0,12,12, 0, 0, 0,13,13, 0, 0, 0, 0,
+ 0, 0, 0, 0,13,13, 0, 0, 0, 0, 0, 0, 0, 0,12,12,
+ 0, 0, 0,13,13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 8, 8, 0, 0, 0,10,10, 0, 0, 0,11,11, 0,
+ 0, 0,12,12, 0, 0, 0, 0, 0, 0, 0, 0,13,13, 0, 0,
+ 0, 0, 0, 0, 0, 0,12,12, 0, 0, 0,13,13, 0, 0, 0,
+ 0, 0, 0, 0, 0,11,11, 0, 0, 0, 0, 0, 0, 0, 0,10,
+ 10, 0, 0, 0,13,13, 0, 0, 0, 0, 0, 0, 0, 0,14,13,
+ 0, 0, 0, 0, 0, 0, 0, 0,13,12, 0, 0, 0,13,13, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0,11,
+ 11, 0, 0, 0,12,12, 0, 0, 0,12,12, 0, 0, 0, 0, 0,
+ 0, 0, 0,12,12, 0, 0, 0, 0, 0, 0, 0, 0,12,12, 0,
+ 0, 0,13,13, 0, 0, 0, 0, 0, 0, 0, 0,13,13, 0, 0,
+ 0, 0, 0, 0, 0, 0,12,12, 0, 0, 0,12,12, 0, 0, 0,
+ 0, 0, 0, 0, 0,13,13, 0, 0, 0, 0, 0, 0, 0, 0,12,
+ 12, 0, 0, 0,13,13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 9, 9, 0, 0, 0,11,11, 0, 0, 0,12,12,
+ 0, 0, 0,12,12, 0, 0, 0, 0, 0, 0, 0, 0,12,12, 0,
+ 0, 0, 0, 0, 0, 0, 0,11,11, 0, 0, 0,14,14, 0, 0,
+ 0, 0, 0, 0, 0, 0,13,13, 0, 0, 0, 0, 0, 0, 0, 0,
+ 12,12, 0, 0, 0,12,13, 0, 0, 0, 0, 0, 0, 0, 0,12,
+ 12, 0, 0, 0, 0, 0, 0, 0, 0,11,11, 0, 0, 0,14,13,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0,
+ 11,11, 0, 0, 0,12,12, 0, 0, 0,13,13, 0, 0, 0, 0,
+ 0, 0, 0, 0,13,13, 0, 0, 0, 0, 0, 0, 0, 0,12,12,
+ 0, 0, 0,13,13, 0, 0, 0, 0, 0, 0, 0, 0,12,12, 0,
+ 0, 0, 0, 0, 0, 0, 0,12,12, 0, 0, 0,14,14, 0, 0,
+ 0, 0, 0, 0, 0, 0,14,14, 0, 0, 0, 0, 0, 0, 0, 0,
+ 12,12, 0, 0, 0,13,13, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+};
+
+static const static_codebook _44p2_p2_0 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p2_p2_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p2_p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44p2_p3_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p2_p3_0[] = {
+ 1, 5, 5, 6, 7, 7, 0, 8, 8, 6, 9, 9, 8,11,11, 0,
+ 8, 8, 0, 9, 9, 0,12,12, 0, 8, 8, 5, 7, 7, 7,10,
+ 10, 0,12,12, 8,11,11, 9,12,12, 0,11,12, 0,12,12,
+ 0,15,15, 0,12,12, 0, 6, 6, 0, 6, 6, 0, 7, 7, 0,
+ 7, 7, 0,10,10, 0, 7, 7, 0, 8, 8, 0,11,11, 0, 7,
+ 7, 6, 7, 7,10, 9, 9, 0,11,10,10, 9, 9,12,12,12,
+ 0,10,10, 0,11,11, 0,13,13, 0,11,11, 7, 6, 6,10,
+ 10,10, 0,11,11,11,11,11,12,12,12, 0,11,11, 0,12,
+ 12, 0,15,15, 0,11,11, 0,11,11, 0,11,11, 0,12,12,
+ 0,12,12, 0,14,14, 0,12,12, 0,12,12, 0,15,15, 0,
+ 11,11, 0, 8, 8, 0,10,10, 0,11,11, 0,11,11, 0,12,
+ 12, 0,12,12, 0,11,11, 0,15,15, 0,11,11, 0, 6, 6,
+ 0,10,10, 0,12,12, 0,10,10, 0,13,13, 0,12,12, 0,
+ 13,13, 0,14,14, 0,12,12, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0,
+};
+
+static const static_codebook _44p2_p3_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p2_p3_0,
+ 1, -533200896, 1614282752, 2, 0,
+ (long *)_vq_quantlist__44p2_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44p2_p3_1[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p2_p3_1[] = {
+ 2, 3, 3, 0, 8, 8, 0, 8, 8, 0, 9, 9, 0, 9, 9, 0,
+ 9, 9, 0, 9, 9, 0, 9, 9, 0, 8, 8, 0, 6, 6, 0, 7,
+ 7, 0, 7, 7, 0, 8, 8, 0, 8, 8, 0, 8, 8, 0, 8, 8,
+ 0, 8, 8, 0, 8, 8, 0, 6, 6, 0, 6, 6, 0, 6, 6, 0,
+ 8, 8, 0, 9, 9, 0, 7, 7, 0, 8, 8, 0, 9, 9, 0, 6,
+ 6, 0, 8, 8, 0, 9, 9, 0, 9, 9, 0,10,10, 0,10,10,
+ 0,10,10, 0,10,10, 0,11,11, 0, 9, 9, 0, 7, 7, 0,
+ 10,10, 0,10,10, 0,12,11, 0,12,12, 0,11,11, 0,11,
+ 11, 0,12,12, 0,10,10, 0, 7, 7, 0,10,10, 0,10,10,
+ 0,12,12, 0,11,12, 0,11,11, 0,11,11, 0,11,11, 0,
+ 10,10, 0, 8, 8, 0, 9, 9, 0, 9, 9, 0,10,10, 0,10,
+ 10, 0,10, 9, 0,10,10, 0,10,10, 0, 9, 9, 0, 6, 6,
+ 0,10,10, 0,10,10, 0,11,11, 0,12,12, 0,11,11, 0,
+ 11,11, 0,12,12, 0,11,11, 0, 7, 7, 0, 9, 9, 0, 9,
+ 9, 0,11,11, 0,11,11, 0,10,10, 0,10,10, 0,11,11,
+ 0, 9, 9,
+};
+
+static const static_codebook _44p2_p3_1 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p2_p3_1,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44p2_p3_1,
+ 0
+};
+
+static const long _vq_quantlist__44p2_p4_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p2_p4_0[] = {
+ 1, 6, 6, 6, 7, 7, 7, 8, 8, 7, 8, 8,10,11,11, 9,
+ 8, 8, 7, 8, 8,11,11,11, 9, 8, 8, 6, 7, 7, 9,11,
+ 11, 9,11,11,10,11,11,12,13,13,11,12,12,10,11,11,
+ 13,14,14,12,12,12, 6, 6, 6, 8, 6, 6, 8, 7, 7, 9,
+ 7, 7,11,10,10,10, 6, 6, 9, 7, 7,12,10,10,11, 6,
+ 7, 7, 7, 7,11,10,10,12,10,10,11,10,10,14,13,13,
+ 13,10,10,12,11,11,15,13,13,14,10,10, 8, 7, 7,12,
+ 11,11,12,11,11,11,11,11,14,14,14,13,12,12,12,11,
+ 11,15,15,15,13,12,12, 0,10,10, 0,11,11, 0,11,11,
+ 0,11,11, 0,14,14, 0,11,11, 0,11,11, 0,15,15, 0,
+ 11,11, 7, 8, 8,12,10,10,12,10,10,12,11,11,15,13,
+ 13,14,11,11,12,10,10,16,14,14,14,10,10, 8, 7, 7,
+ 12,11,11,12,11,11,12,11,11,16,14,14,14,12,12,13,
+ 12,12,15,14,14,15,12,12, 0,11,11, 0,12,12, 0,12,
+ 12, 0,12,12, 0,15,15, 0,12,12, 0,12,12, 0,14,14,
+ 0,12,12,
+};
+
+static const static_codebook _44p2_p4_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p2_p4_0,
+ 1, -531365888, 1616117760, 2, 0,
+ (long *)_vq_quantlist__44p2_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44p2_p4_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p2_p4_1[] = {
+ 3, 4, 4, 8, 8,11, 9, 9,12,12,11,10,10,12,12,12,
+ 10,10,11,11,12,12,12,12,12,12,11,11,13,13,12,12,
+ 12,13,13,12,10,10,12,12,12,11,11,13,13,12,13,13,
+ 13,13,12,11,11,13,13,12,12,12,13,13,12,10,10,12,
+ 12,12,11,11,13,13,12,13,13,12,12,12,11,11,13,13,
+ 12,13,13,13,13,12,11,11,12,12,12,11,11,12,12,12,
+ 13,13,12,12,12,13,13,13,13,12,13,13,13,13,13,13,
+ 13,12,12,12,13,13,13,13,12,13,13,12,12,11, 8, 8,
+ 10,10,12,11,11,11,11,12,10,10,10,10,13,11,11,10,
+ 10,13,11,11,10,10,13,12,12,12,12,13,11,11,11,11,
+ 13,12,12,11,11,13,12,12,11,11,13,12,12,12,11,13,
+ 12,12,12,12,13,11,11,11,11,13,12,12,11,11,13,11,
+ 12,11,11,13,12,12,11,11,14,12,12,11,11,13,11,11,
+ 11,11,14,12,12,11,11,13,11,12,10,10,14,12,12,11,
+ 11,14,12,12,11,11,14,11,11,11,11,14,12,12,11,11,
+ 13,12,12,11,11,14,12,12,11,11,11, 8, 8,10,10,12,
+ 7, 7,10,10,12, 9, 9,11,11,13, 9, 9, 9, 9,13,13,
+ 13,10,10,13, 9, 9,12,12,13,13,13,12,12,13, 9, 8,
+ 11,11,13,10,10,12,12,14,13,13,11,11,13, 9, 9,11,
+ 11,13,13,13,12,12,13, 9, 9,10,10,13,10,10,11,11,
+ 13,13,13,10,10,14,10,10,11,11,14,14,14,12,12,13,
+ 9, 9,10,10,13,10,10,11,11,14,13,14,10,10,14,14,
+ 14,11,12,14,14,14,14,14,14,13,13,10,10,13,14,14,
+ 11,11,14,14,14,10,10,14, 9, 9, 9, 9,14, 9, 9, 9,
+ 9,14,10,10, 9, 9,14,10,10, 8, 8,14,11,11, 8, 8,
+ 15,11,11,10,10,15,12,12,10,10,15,10,10,10,10,15,
+ 11,11,10,10,15,13,13,10,10,15,11,11,10,10,15,12,
+ 12,10,10,15,10,10,10,10,15,11,11,10,10,15,13,13,
+ 10,10,15,11,11,10,10,15,12,12,10,10,15,11,11, 9,
+ 9,15,11,11, 9, 9,15,13,13, 9, 9,15,13,13,10,10,
+ 15,12,12,10,10,15,13,13,10,10,15,13,12, 9, 9,15,
+ 13,13, 9, 9,14,12,12, 9, 9,14,13,13, 9, 9,14,13,
+ 13, 9, 9,14,13,13, 7, 7,14,13,13, 8, 8,15,14,14,
+ 10,10,15,14,14,10,10,15,14,14,10,10,15,14,14,10,
+ 10,15,14,14, 9, 9,15,14,14,10,10,15,14,14,10,10,
+ 14,14,14, 9, 9,15,14,14,10,10,14,14,14, 9, 9,15,
+ 14,14,10,10,15,14,14,10,10,14,14,14, 9, 9,14,14,
+ 14, 9, 9,14,14,14, 8, 8,15,14,14,10,10,15,14,14,
+ 11,11,15,14,14, 9, 9,15,14,14, 9, 9,14,14,14, 8,
+ 8,13, 9, 9,12,12,17,11,11,12,12,17,12,12,12,12,
+ 17,12,12,11,11,18,15,15,12,12,17,12,12,12,12,17,
+ 14,15,13,13,17,12,12,12,12,17,13,13,12,13,17,15,
+ 15,12,12,18,13,13,13,13,18,15,15,13,13,18,12,12,
+ 12,12,18,13,13,13,13,18,15,15,12,12,18,13,13,12,
+ 12,18,15,15,13,13,18,13,13,12,12,17,13,13,12,12,
+ 17,15,15,12,12,18,15,15,13,13,18,15,15,13,14,18,
+ 15,16,12,12,18,15,15,12,12,18,16,16,12,12,13, 8,
+ 8,10,10,14,15,14,11,11,14,15,15,12,12,15,14,14,
+ 12,11,15,15,15,12,12,15,15,15,12,12,15,15,15,13,
+ 13,15,15,15,12,12,15,15,15,13,13,15,15,15,13,13,
+ 15,15,15,13,13,15,15,16,13,13,15,15,15,12,12,15,
+ 15,15,13,13,15,15,15,13,13,15,15,15,13,13,15,15,
+ 15,13,13,15,15,14,12,12,15,15,15,12,12,16,15,14,
+ 12,12,16,15,15,13,13,16,16,16,13,13,16,15,15,12,
+ 12,15,15,15,13,13,15,15,15,12,12,13,12,12,10,10,
+ 14,14,14,11,11,15,14,14,12,12,15,14,14,11,11,15,
+ 14,14,11,11,15,15,15,13,13,15,14,14,13,13,15,15,
+ 15,12,12,15,14,15,13,13,16,15,15,12,12,15,15,15,
+ 13,13,16,14,14,13,13,15,15,15,12,12,15,15,15,13,
+ 13,16,15,15,12,12,16,15,15,12,12,16,14,14,13,13,
+ 15,15,15,11,11,15,15,15,12,12,16,15,15,11,11,16,
+ 15,15,13,13,16,14,15,14,14,16,15,15,12,12,16,15,
+ 14,12,12,16,15,15,12,12,14,10,10, 9, 9,14,11,11,
+ 12,12,14,12,12,13,13,14,12,12,12,12,15,14,14,13,
+ 13,15,13,13,14,14,15,14,14,15,15,15,12,12,13,13,
+ 15,13,13,14,14,15,14,14,13,13,15,13,13,13,14,15,
+ 14,14,15,15,15,12,12,13,13,15,13,13,14,14,15,14,
+ 14,13,13,15,13,13,14,14,15,14,14,15,15,15,13,13,
+ 12,12,15,13,13,13,13,15,14,14,13,12,15,15,15,14,
+ 15,15,15,14,20,20,15,14,14,13,13,15,14,14,13,13,
+ 15,14,14,13,13,14,12,12, 9, 9,14,14,14,12,12,14,
+ 13,13,12,13,14,14,14,12,12,15,14,14,12,12,15,14,
+ 14,14,13,15,14,14,14,14,15,14,14,13,13,15,14,14,
+ 13,13,15,15,15,14,14,15,14,14,13,13,15,14,14,14,
+ 14,15,14,14,13,13,15,14,14,13,13,15,15,15,15,14,
+ 15,15,15,13,13,15,14,14,14,14,15,14,14,13,13,15,
+ 14,14,13,13,14,15,15,14,14,15,15,15,14,14,15,14,
+ 14,14,14,15,15,15,14,14,15,14,14,13,14,15,15,15,
+ 14,14,13,10,10,12,12,17,11,11,12,12,17,12,12,12,
+ 12,17,12,12,11,11,17,15,15,12,11,18,13,13,13,13,
+ 18,15,15,13,13,17,12,12,12,12,18,13,13,13,13,17,
+ 15,15,12,12,17,12,12,12,12,17,15,15,13,13,17,12,
+ 12,12,12,17,13,13,12,12,17,15,15,12,12,18,14,13,
+ 12,12,18,15,15,13,13,18,13,13,12,12,18,13,13,12,
+ 12,18,16,16,12,12,18,16,16,12,12,18,15,15,13,13,
+ 18,16,16,12,12,17,15,15,12,12,17,16,16,12,12,13,
+ 8, 8,10,10,14,14,15,12,12,14,15,15,12,12,15,14,
+ 14,12,12,15,15,14,12,12,15,15,15,13,13,15,15,15,
+ 13,13,15,15,15,12,12,16,15,15,13,13,16,15,15,13,
+ 13,15,15,15,12,12,15,15,15,14,14,15,15,15,12,12,
+ 15,15,15,13,13,16,15,15,13,13,15,15,15,13,13,16,
+ 15,15,13,13,15,15,14,12,12,15,15,15,12,12,16,14,
+ 15,13,13,16,15,15,13,13,15,16,15,13,13,16,15,14,
+ 13,13,16,15,15,13,13,16,15,15,13,13,13,12,12,11,
+ 11,14,14,14,11,11,14,14,14,12,12,15,14,14,11,11,
+ 16,14,14,11,11,15,15,15,12,13,16,14,14,13,13,15,
+ 15,15,12,12,15,14,14,13,13,16,15,15,12,12,15,15,
+ 15,12,12,15,14,14,13,13,15,15,15,12,12,15,14,14,
+ 12,12,16,15,15,12,12,16,15,15,12,12,16,14,14,13,
+ 13,15,15,15,11,11,15,15,14,12,12,16,15,15,11,11,
+ 16,15,15,12,12,16,14,14,13,13,16,15,15,11,11,16,
+ 14,14,12,12,16,15,15,11,11,14,10,10, 9, 9,14,11,
+ 11,12,12,14,12,12,13,14,14,12,12,12,12,14,14,14,
+ 13,13,15,13,13,14,14,15,14,14,15,15,15,12,12,13,
+ 13,15,13,13,14,14,15,15,15,14,14,15,13,13,14,14,
+ 15,15,15,15,15,15,12,12,13,13,15,13,13,14,14,15,
+ 14,14,13,13,15,13,13,14,14,15,14,14,15,15,15,12,
+ 12,13,13,15,13,13,13,13,14,14,14,13,13,15,15,15,
+ 14,15,15,15,15,21,19,15,14,14,13,13,15,14,14,14,
+ 14,14,14,14,13,13,14,12,12, 9, 9,14,14,14,12,12,
+ 14,14,13,13,13,14,14,14,12,12,14,14,14,12,12,15,
+ 14,14,13,13,15,14,14,14,14,15,14,14,13,13,15,14,
+ 14,13,13,15,15,15,15,15,15,14,14,13,13,15,14,14,
+ 14,14,15,14,14,13,13,15,14,14,13,13,14,15,15,15,
+ 15,15,14,15,13,13,15,14,14,14,14,15,14,14,13,13,
+ 15,14,14,13,13,14,15,15,14,14,15,15,15,14,14,15,
+ 14,14,14,14,15,15,15,15,15,15,14,14,14,13,14,15,
+ 15,14,14,13,10,10,12,12,18,12,12,12,12,17,12,12,
+ 12,12,18,13,13,11,11,18,15,14,11,11,17,13,13,13,
+ 13,18,15,15,12,12,18,12,12,12,12,17,13,13,12,12,
+ 18,15,15,12,12,18,13,13,13,12,18,15,15,13,13,18,
+ 13,13,12,12,18,13,13,12,12,18,15,15,12,12,17,13,
+ 13,12,12,17,15,15,12,12,17,12,12,11,11,17,13,13,
+ 11,11,17,15,15,11,11,18,16,16,12,12,18,15,15,13,
+ 13,18,15,15,11,11,17,15,15,12,12,18,15,15,11,11,
+ 13, 8, 8,10,10,14,14,14,11,11,15,15,15,12,12,15,
+ 14,14,11,11,16,14,14,12,12,15,15,15,12,12,15,15,
+ 15,13,13,15,15,15,12,12,15,15,15,12,12,16,15,15,
+ 13,13,15,15,15,12,12,15,15,15,13,13,16,15,15,12,
+ 12,15,15,15,12,12,16,15,15,13,13,16,15,15,12,12,
+ 15,15,15,13,13,15,14,14,12,12,15,15,15,12,12,16,
+ 15,14,12,12,16,15,15,13,13,16,16,16,13,13,16,14,
+ 15,13,13,15,15,15,13,13,16,15,15,12,12,13,12,12,
+ 10,10,14,14,14,11,11,15,14,14,12,12,15,14,14,11,
+ 11,16,14,14,11,11,15,14,15,12,12,15,14,14,13,13,
+ 15,15,15,12,12,15,14,14,12,12,15,14,15,12,12,15,
+ 15,15,12,12,16,14,14,13,13,15,15,15,11,12,16,14,
+ 14,12,12,16,15,15,12,12,15,15,15,12,12,16,14,14,
+ 12,12,15,15,15,11,11,15,14,14,11,12,15,15,14,11,
+ 11,16,15,15,12,12,16,14,14,13,13,16,15,15,11,11,
+ 16,14,14,12,12,16,15,15,11,11,13,10,10, 8, 8,14,
+ 12,12,12,12,14,12,12,13,13,14,12,12,12,12,14,14,
+ 14,13,13,15,13,13,14,14,15,15,14,15,15,15,13,13,
+ 13,13,15,13,13,14,14,15,14,15,14,14,15,13,13,13,
+ 13,15,15,15,15,15,15,12,12,13,12,15,13,13,14,14,
+ 15,14,14,13,13,15,13,13,14,13,15,15,15,16,16,15,
+ 13,13,12,12,15,13,13,13,13,14,14,14,12,12,15,15,
+ 15,14,14,15,15,15,20,20,15,14,14,13,13,15,15,14,
+ 14,14,15,14,14,13,13,13,12,12, 9, 9,14,13,13,12,
+ 12,14,13,13,12,12,14,14,14,12,12,14,14,14,13,13,
+ 15,14,14,13,13,15,14,14,14,14,15,15,14,12,12,15,
+ 14,14,13,13,15,14,15,14,15,15,14,14,13,13,15,14,
+ 14,14,14,15,14,14,12,12,15,14,14,13,13,14,15,14,
+ 15,14,15,14,14,13,13,15,14,14,14,14,15,14,14,12,
+ 12,15,14,14,13,13,15,15,15,14,14,15,15,15,14,14,
+ 16,14,14,14,14,15,15,15,14,14,15,14,14,14,14,14,
+ 15,15,14,14,13,13,13,12,13,17,15,15,12,12,17,15,
+ 15,12,12,18,15,15,11,11,17,16,16,11,11,18,16,16,
+ 13,13,18,17,16,13,13,18,16,16,12,12,18,16,16,12,
+ 12,18,17,17,12,12,17,16,16,12,13,17,16,16,12,13,
+ 17,16,16,12,12,17,16,16,12,12,18,17,16,12,12,18,
+ 16,16,12,12,17,16,17,12,12,18,15,15,11,11,18,15,
+ 15,12,12,17,17,17,11,11,17,17,17,12,12,17,16,16,
+ 13,13,18,16,16,11,11,18,16,16,12,12,18,17,16,11,
+ 11,14,14,14,10,10,16,15,14,11,11,16,15,15,12,12,
+ 16,14,14,12,12,17,14,14,13,13,17,15,15,13,13,17,
+ 15,15,14,14,16,15,15,12,12,16,15,15,13,13,18,15,
+ 15,14,14,16,15,15,12,12,16,15,15,14,14,16,15,15,
+ 12,12,16,15,15,13,13,17,15,15,13,13,17,15,15,13,
+ 13,17,15,15,14,14,16,14,14,12,12,17,15,15,12,12,
+ 18,15,15,13,13,17,15,15,14,14,17,16,16,15,15,17,
+ 15,14,13,13,17,15,15,14,14,17,15,15,13,13,14,12,
+ 12,11,11,15,14,14,12,12,16,14,14,12,12,16,14,14,
+ 11,11,17,14,14,12,12,16,15,14,13,13,16,14,14,13,
+ 13,16,15,15,12,12,16,14,14,13,13,17,15,15,13,13,
+ 16,15,15,13,13,17,14,14,13,13,16,15,15,12,12,16,
+ 14,14,12,12,16,15,15,12,12,17,15,15,12,12,17,14,
+ 14,13,13,16,15,15,12,12,16,14,14,12,12,16,15,15,
+ 12,12,17,15,15,13,13,17,14,14,13,13,17,15,15,12,
+ 12,17,14,14,12,12,17,15,15,12,12,14,14,14, 8, 8,
+ 14,14,14,13,13,14,15,15,14,14,14,14,14,14,14,15,
+ 15,15,19,19,15,15,15,14,14,15,15,16,20,19,15,15,
+ 15,14,14,15,16,16,15,15,15,15,15,19,19,15,15,15,
+ 14,14,15,16,16,19,20,15,15,15,14,14,15,15,15,15,
+ 15,15,15,15,19,19,15,15,15,15,15,15,15,16,19,20,
+ 15,14,15,14,14,15,15,15,15,15,15,15,15,20,19,15,
+ 15,15,21,19,15,16,16,20,20,15,15,14,19,19,15,15,
+ 16,20,21,15,15,15,20,19,13,12,12, 9, 9,14,14,14,
+ 12,12,14,13,13,13,13,14,14,14,13,13,15,14,14,20,
+ 19,15,14,14,14,13,15,14,14,19,19,15,15,14,13,13,
+ 15,14,14,14,14,15,15,15,19,20,15,14,14,13,13,15,
+ 14,14,20,19,14,15,14,13,13,15,14,14,14,13,15,15,
+ 15,19,20,15,15,14,14,14,15,14,14,21,19,15,15,15,
+ 13,13,15,14,14,14,14,14,15,15,20,20,15,15,15,21,
+ 20,15,14,14,19,20,15,15,15,20,20,15,14,14,19,20,
+ 15,15,15,21,19,
+};
+
+static const static_codebook _44p2_p4_1 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p2_p4_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p2_p4_1,
+ 0
+};
+
+static const long _vq_quantlist__44p2_p5_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p2_p5_0[] = {
+ 2, 6, 6,14,14, 6, 7, 7,14,14, 7, 7, 7,15,15, 0,
+ 13,13,16,16, 0,13,13,15,15, 7, 8, 8,15,15, 9,10,
+ 10,17,16, 9, 8, 8,15,15, 0,13,13,18,17, 0,13,13,
+ 16,16, 8, 8, 8,15,15,12,11,11,16,17, 9, 8, 8,14,
+ 14, 0,13,13,18,17, 0,13,13,16,15, 0,14,14,18,17,
+ 0,20,22,18,20, 0,12,12,16,16, 0,16,16,22,20, 0,
+ 14,14,16,16, 0,14,14,17,17, 0,22,22,22,19, 0,12,
+ 13,16,16, 0,17,17, 0, 0, 0,15,15,16,16, 5, 7, 7,
+ 13,13, 9, 9, 9,15,14,10,10,10,14,14, 0,21,21,18,
+ 17, 0,21,22,18,17, 9,10,10,14,14,12,12,12,17,17,
+ 12,10,10,14,14, 0,19,21,18,17, 0,20,22,18,18,11,
+ 10,10,14,14,14,13,13,18,17,12,11,11,14,14, 0,22,
+ 19,17,18, 0,20, 0,18,17, 0,22,21,17,17, 0, 0, 0,
+ 0, 0, 0,20,22,17,17, 0,22, 0,21,19, 0,22, 0,18,
+ 18, 0, 0,22,18,19, 0, 0, 0, 0, 0, 0,19,21,17,17,
+ 0, 0, 0,20,20, 0, 0, 0,18,18, 6, 6, 6,13,12, 8,
+ 6, 6,11,11, 8, 6, 6,13,13, 0, 9, 9,11,11, 0,11,
+ 11,14,14, 9, 7, 7,13,13,11, 9, 9,13,13,10, 6, 6,
+ 13,13, 0,10,10,14,14, 0,10,10,13,13, 9, 7, 7,13,
+ 14,13, 9, 9,13,13,10, 6, 6,13,12, 0,11,11,15,15,
+ 0,10,10,13,13, 0,12,12,15,15, 0,19, 0,17,17, 0,
+ 9, 9,13,13, 0,13,14,19,20, 0,11,11,13,13, 0,11,
+ 11,14,14, 0,19,20,17,18, 0,10,10,13,13, 0,15,15,
+ 21,19, 0,12,12,13,13, 0,10,10,12,13, 0,11,11,15,
+ 15, 0,11,11,15,15, 0,15,15,22, 0, 0,16,17,22, 0,
+ 0,11,11,15,15, 0,14,14,18,17, 0,11,11,15,16, 0,
+ 15,15,22,21, 0,16,16, 0,20, 0,12,12,16,15, 0,15,
+ 14,19,19, 0,11,11,16,16, 0,15,15,21, 0, 0,16,15,
+ 0, 0, 0,16,16,22,21, 0, 0, 0, 0, 0, 0,15,15,20,
+ 20, 0,18,18, 0, 0, 0,16,17, 0, 0, 0,17,17, 0,22,
+ 0, 0, 0, 0, 0, 0,15,15,21,22, 0,20,18, 0, 0, 0,
+ 18,17,22, 0, 0,10,10,12,11, 0,10,10,10,10, 0,11,
+ 11,12,12, 0,11,11, 9, 9, 0,13,13,12,12, 0,11,11,
+ 12,12, 0,13,13,12,12, 0,10,10,12,12, 0,13,12,13,
+ 13, 0,12,12,12,12, 0,11,11,12,12, 0,13,13,12,12,
+ 0,10,10,12,12, 0,13,13,13,14, 0,12,12,12,12, 0,
+ 13,14,14,14, 0,20,21,15,15, 0,12,11,12,12, 0,15,
+ 16,20,22, 0,13,12,11,11, 0,13,13,14,13, 0,20, 0,
+ 16,15, 0,12,12,12,12, 0,16,16,22,21, 0,13,13,12,
+ 12, 6, 7, 7,16,16,11, 9, 9,15,15,12, 9, 9,16,16,
+ 0,13,13,14,14, 0,14,14,16,17,10, 9, 9,16,16,14,
+ 12,12,16,16,12, 9, 9,15,15, 0,13,13,18,18, 0,13,
+ 13,15,16,12,10,10,17,18,15,12,12,17,17,13, 9, 9,
+ 16,16, 0,13,13,17,18, 0,14,14,16,16, 0,15,15,18,
+ 18, 0,22, 0,20,20, 0,12,12,16,16, 0,16,16,20,22,
+ 0,14,14,16,16, 0,15,14,18,18, 0, 0,22,19,21, 0,
+ 13,13,16,17, 0,17,17,22,22, 0,15,15,16,16, 7, 7,
+ 7,14,14,11,10,10,15,15,12,10,10,15,14, 0,22, 0,
+ 18,18, 0, 0,21,17,18,11,10,10,15,15,14,12,12,17,
+ 17,14,11,11,15,15, 0,22,20,18,18, 0, 0,20,18,17,
+ 12,10,10,16,16,17,14,14,19,18,14,11,11,15,15, 0,
+ 21,22,19,19, 0,21,22,18,18, 0,22, 0,19,21, 0, 0,
+ 0, 0, 0, 0,22,22,18,17, 0, 0, 0,21,20, 0,22,22,
+ 20,19, 0, 0,22,20,20, 0, 0, 0, 0, 0, 0,20,21,17,
+ 17, 0, 0,22,21,21, 0, 0, 0,18,18,10, 9, 9,14,14,
+ 13,10,10,13,13,13,10,11,14,14, 0,13,13,12,12, 0,
+ 15,15,16,16,13,10,10,15,15,15,12,12,14,14,15,10,
+ 10,14,15, 0,14,14,16,15, 0,14,14,15,15,13,10,10,
+ 15,15,18,13,13,15,15,15,10,10,14,15, 0,14,14,16,
+ 16, 0,14,14,15,15, 0,15,15,16,16, 0,22, 0,18,18,
+ 0,12,13,14,14, 0,17,17,22, 0, 0,14,14,14,14, 0,
+ 15,15,16,16, 0,22, 0,18,17, 0,13,13,14,14, 0,19,
+ 18,21,22, 0,15,15,14,14, 0,11,11,13,13, 0,12,12,
+ 16,16, 0,12,12,16,16, 0,15,16,21, 0, 0,16,17, 0,
+ 22, 0,12,12,16,16, 0,14,14,17,18, 0,11,11,16,16,
+ 0,15,15,21,22, 0,16,16, 0, 0, 0,12,12,16,16, 0,
+ 15,15, 0,19, 0,12,12,16,17, 0,16,16,22, 0, 0,16,
+ 16, 0,22, 0,17,17, 0,22, 0, 0, 0, 0, 0, 0,15,15,
+ 20,19, 0,18,18, 0, 0, 0,17,18, 0, 0, 0,17,17, 0,
+ 0, 0, 0, 0, 0, 0, 0,15,15, 0,22, 0,20,18, 0, 0,
+ 0,18,18,22,22, 0,11,11,14,14, 0,12,12,14,14, 0,
+ 12,12,15,15, 0,13,13,14,14, 0,14,14,17,16, 0,12,
+ 12,16,16, 0,14,14,16,16, 0,11,11,15,15, 0,13,13,
+ 16,16, 0,13,13,15,15, 0,12,12,15,15, 0,15,14,16,
+ 16, 0,11,11,15,15, 0,14,14,17,17, 0,13,13,15,15,
+ 0,15,15,17,17, 0, 0, 0,19,18, 0,13,12,15,15, 0,
+ 16,16, 0, 0, 0,14,14,15,15, 0,14,14,16,17, 0,22,
+ 0,18,18, 0,13,13,15,15, 0,17,17, 0, 0, 0,14,14,
+ 15,15, 8, 8, 8,16,16,12,10,10,16,16,13, 9, 9,16,
+ 16, 0,14,14,17,17, 0,14,14,17,16,12,10,10,18,17,
+ 14,11,11,18,18,14, 9,10,16,16, 0,13,13,18,19, 0,
+ 14,13,16,16,12, 9, 9,16,16,17,13,13,17,17,14, 9,
+ 9,15,15, 0,14,14,19,20, 0,13,13,15,15, 0,15,15,
+ 18,19, 0, 0,22,22,22, 0,13,13,17,17, 0,16,16,19,
+ 21, 0,14,14,16,16, 0,14,14,18,18, 0, 0, 0, 0, 0,
+ 0,13,13,16,16, 0,18,18, 0, 0, 0,15,15,16,16, 8,
+ 7, 7,14,14,12,10,10,15,15,13,10,10,15,14, 0,22,
+ 0,18,18, 0,22, 0,18,18,12,10,10,16,15,15,12,12,
+ 17,17,14,11,11,15,15, 0,20,21,19,18, 0, 0, 0,17,
+ 18,13,11,11,15,15,16,13,13,18,18,15,11,11,14,14,
+ 0,22,21,19,19, 0,21,22,18,18, 0,22,22,20,18, 0,
+ 0, 0, 0, 0, 0,22,19,17,17, 0, 0, 0,22,21, 0, 0,
+ 22,19,17, 0, 0,22,19,19, 0, 0, 0, 0, 0, 0,22,21,
+ 18,17, 0, 0, 0,22, 0, 0, 0, 0,19,19, 0,10,10,14,
+ 14, 0,11,11,15,14, 0,11,11,15,15, 0,14,14,15,14,
+ 0,15,15,16,16, 0,11,11,16,16, 0,13,13,16,16, 0,
+ 11,11,15,15, 0,14,14,17,16, 0,14,14,15,15, 0,11,
+ 11,16,16, 0,14,13,15,15, 0,11,11,15,15, 0,15,15,
+ 17,17, 0,14,14,15,14, 0,16,16,17,17, 0, 0,22,18,
+ 18, 0,13,13,15,15, 0,17,17,22, 0, 0,15,15,15,14,
+ 0,15,16,16,17, 0, 0,22,18,19, 0,13,13,15,15, 0,
+ 20,18,21, 0, 0,15,15,14,14, 0,11,11,13,13, 0,12,
+ 12,16,16, 0,12,12,16,15, 0,15,16,22,22, 0,17,17,
+ 0, 0, 0,12,12,16,16, 0,14,14,18,18, 0,11,11,16,
+ 16, 0,15,16,22,20, 0,16,16, 0,22, 0,12,12,16,16,
+ 0,15,15,18,20, 0,11,11,16,16, 0,15,15, 0, 0, 0,
+ 16,16, 0, 0, 0,17,17,22, 0, 0, 0, 0, 0, 0, 0,15,
+ 15, 0,21, 0,18,18, 0, 0, 0,17,16, 0, 0, 0,17,17,
+ 22,22, 0, 0, 0, 0, 0, 0,15,15,21, 0, 0,20,22, 0,
+ 0, 0,18,18, 0, 0, 0,12,12,15,15, 0,12,12,15,15,
+ 0,12,12,16,16, 0,13,13,15,15, 0,15,15,17,17, 0,
+ 13,12,16,16, 0,14,14,16,16, 0,12,11,16,16, 0,14,
+ 14,17,17, 0,14,14,16,16, 0,12,12,16,16, 0,15,15,
+ 17,16, 0,11,11,15,16, 0,14,14,17,17, 0,14,14,16,
+ 16, 0,15,15,18,18, 0, 0, 0,22,19, 0,13,13,15,16,
+ 0,16,17, 0, 0, 0,14,14,16,16, 0,15,15,18,17, 0,
+ 0, 0,20,20, 0,13,13,16,15, 0,17,17,22,22, 0,14,
+ 14,15,15, 0,11,11,16,16, 0,13,13,16,17, 0,13,13,
+ 17,18, 0,16,16,17,17, 0,17,17,18,18, 0,12,12,17,
+ 17, 0,16,15,18,18, 0,12,12,16,16, 0,16,16,18,18,
+ 0,15,15,17,17, 0,12,12,17,17, 0,16,16,19,18, 0,
+ 12,12,16,17, 0,16,16,19,19, 0,15,16,16,17, 0,16,
+ 16,19,17, 0, 0, 0,20,22, 0,13,13,16,16, 0,19,18,
+ 21, 0, 0,15,15,16,16, 0,16,16,18,18, 0, 0, 0,22,
+ 21, 0,14,14,16,16, 0,21,19,21,22, 0,16,16,16,16,
+ 0, 9, 9,14,14, 0,13,13,15,15, 0,14,14,15,15, 0,
+ 0,20,18,19, 0, 0,22,18,18, 0,12,12,15,15, 0,15,
+ 15,17,18, 0,14,13,14,14, 0,20, 0,18,18, 0,21, 0,
+ 18,17, 0,13,13,15,16, 0,17,17,18,18, 0,14,14,15,
+ 15, 0,22,22,20,19, 0,20,21,18,18, 0,20,22,19,19,
+ 0, 0, 0, 0, 0, 0,20,20,17,17, 0, 0,22,22,21, 0,
+ 22, 0,18,18, 0,20,22,19,19, 0, 0, 0, 0, 0, 0,21,
+ 21,17,18, 0, 0, 0,21,20, 0, 0,22,19,18, 0,18,18,
+ 15,15, 0,22,21,17,16, 0, 0,22,17,17, 0,20,22,18,
+ 18, 0, 0,22,20,20, 0,21,19,16,16, 0,21,21,18,18,
+ 0,19,19,17,17, 0, 0,22,19,19, 0,22,20,17,17, 0,
+ 21,19,16,16, 0,22,22,19,18, 0,19,20,16,16, 0,22,
+ 21,19,21, 0,21,22,17,18, 0,21,20,18,18, 0, 0, 0,
+ 19,20, 0,20,19,16,16, 0,22,22, 0, 0, 0,21,21,17,
+ 16, 0,22,20,19,18, 0, 0, 0,20,20, 0,20,19,16,16,
+ 0, 0, 0, 0, 0, 0,21,22,17,17, 0,11,11,13,13, 0,
+ 13,13,15,16, 0,13,13,16,16, 0,17,18,21, 0, 0,17,
+ 18, 0, 0, 0,12,12,15,16, 0,15,15,19,18, 0,12,12,
+ 16,16, 0,17,17,22, 0, 0,17,17, 0,22, 0,12,12,17,
+ 16, 0,16,16,19,20, 0,12,12,16,16, 0,17,17, 0, 0,
+ 0,17,17, 0,21, 0,17,16,22, 0, 0, 0, 0, 0, 0, 0,
+ 15,15,20,22, 0,20,18, 0, 0, 0,18,18, 0, 0, 0,17,
+ 17,21, 0, 0, 0, 0, 0, 0, 0,15,15,21,22, 0,19,20,
+ 22, 0, 0,19,18, 0, 0, 0,14,14,18,18, 0,16,16,22,
+ 20, 0,16,16,22,19, 0,17,17,20,22, 0,19,19, 0, 0,
+ 0,15,15,20, 0, 0,18,21, 0,20, 0,15,15,21,20, 0,
+ 18,17, 0, 0, 0,17,17, 0,22, 0,15,15,19,19, 0,19,
+ 18, 0, 0, 0,15,15,20, 0, 0,18,18,22,22, 0,17,17,
+ 0,20, 0,18,18, 0, 0, 0, 0,22, 0, 0, 0,15,15,19,
+ 20, 0,20,19, 0, 0, 0,17,17,20,21, 0,17,18,20,22,
+ 0, 0, 0, 0,22, 0,15,15,20,20, 0,22,20, 0, 0, 0,
+ 17,18,20, 0, 0,12,12,17,16, 0,14,14,17,17, 0,13,
+ 13,17,17, 0,16,16,18,18, 0,17,16,17,17, 0,13,13,
+ 17,17, 0,15,16,18,18, 0,13,13,16,16, 0,16,16,18,
+ 18, 0,16,16,17,16, 0,13,13,16,16, 0,17,17,18,17,
+ 0,12,12,15,16, 0,17,17,19,19, 0,16,16,16,16, 0,
+ 16,17,19,18, 0, 0, 0,21,22, 0,14,14,16,16, 0,18,
+ 18, 0,22, 0,16,16,16,16, 0,16,16,18,17, 0, 0, 0,
+ 21,20, 0,14,14,16,16, 0,21,22,22, 0, 0,16,16,16,
+ 16, 0, 9, 9,14,13, 0,13,14,15,16, 0,14,13,15,14,
+ 0,22, 0,18,18, 0,21, 0,17,18, 0,13,13,15,15, 0,
+ 15,16,18,17, 0,14,14,15,14, 0,20,22,18,18, 0,22,
+ 21,17,17, 0,13,13,15,15, 0,17,17,19,19, 0,14,14,
+ 14,14, 0, 0,22,18,18, 0, 0,22,17,17, 0, 0,22,19,
+ 20, 0, 0, 0, 0, 0, 0,21,20,17,16, 0, 0, 0,21,22,
+ 0, 0, 0,18,19, 0, 0, 0,18,18, 0, 0, 0, 0, 0, 0,
+ 22, 0,17,17, 0, 0, 0,20,22, 0, 0, 0,18,19, 0,18,
+ 19,16,16, 0,22,20,17,17, 0,22,22,17,18, 0,22,22,
+ 18,17, 0, 0,22,18,19, 0,20,20,17,18, 0, 0,22,19,
+ 18, 0,22,22,17,17, 0,22, 0,19,19, 0, 0,22,18,18,
+ 0,20,22,17,17, 0, 0,22,18,18, 0,19,20,17,17, 0,
+ 22, 0,20,19, 0,22,21,17,17, 0, 0, 0,18,18, 0, 0,
+ 0,22,19, 0,20, 0,17,17, 0,22, 0, 0,22, 0, 0,20,
+ 17,18, 0,22, 0,19,19, 0, 0, 0, 0,19, 0,19,21,17,
+ 17, 0, 0, 0, 0, 0, 0,20,21,17,16, 0,11,11,13,13,
+ 0,13,13,16,16, 0,13,13,15,16, 0,17,17,21,22, 0,
+ 17,18, 0, 0, 0,12,12,16,16, 0,15,15,18,18, 0,13,
+ 13,16,16, 0,17,16,21,21, 0,17,17, 0, 0, 0,13,13,
+ 16,16, 0,16,16,19,18, 0,13,13,16,16, 0,17,17, 0,
+ 22, 0,17,18,20,22, 0,17,18, 0, 0, 0, 0, 0, 0, 0,
+ 0,15,15,20, 0, 0,18,19, 0, 0, 0,17,17, 0, 0, 0,
+ 18,17,22, 0, 0, 0, 0, 0, 0, 0,15,16,21,20, 0,20,
+ 20, 0, 0, 0,18,19, 0, 0, 0,15,15,22,22, 0,17,16,
+ 20,22, 0,17,17,20,22, 0,18,18, 0,21, 0,19,18, 0,
+ 0, 0,16,16,20,20, 0,19,19,22, 0, 0,15,16,21,22,
+ 0,18,19,22, 0, 0,17,18, 0, 0, 0,16,16,22, 0, 0,
+ 19,19, 0,21, 0,15,16,20, 0, 0,18,18, 0,22, 0,18,
+ 17, 0, 0, 0,18,18, 0, 0, 0, 0, 0, 0, 0, 0,16,16,
+ 22,21, 0,20,21, 0, 0, 0,17,18,22, 0, 0,18,18, 0,
+ 0, 0, 0, 0, 0, 0, 0,16,16,20,19, 0,22,21, 0, 0,
+ 0,18,18,22,22,
+};
+
+static const static_codebook _44p2_p5_0 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p2_p5_0,
+ 1, -528744448, 1616642048, 3, 0,
+ (long *)_vq_quantlist__44p2_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44p2_p5_1[] = {
+ 3,
+ 2,
+ 4,
+ 1,
+ 5,
+ 0,
+ 6,
+};
+
+static const long _vq_lengthlist__44p2_p5_1[] = {
+ 2, 3, 3, 3, 3, 3, 3,
+};
+
+static const static_codebook _44p2_p5_1 = {
+ 1, 7,
+ (long *)_vq_lengthlist__44p2_p5_1,
+ 1, -533200896, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p2_p5_1,
+ 0
+};
+
+static const long _vq_quantlist__44p2_p6_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p2_p6_0[] = {
+ 1, 7, 7, 7, 8, 8, 7, 8, 8, 7, 9, 9,10,11,11, 9,
+ 8, 8, 7, 8, 9,11,11,11, 9, 8, 8, 6, 7, 7,10,10,
+ 10,10,10,10,10,10,10,14,14,14,12,11,11,10,11,11,
+ 15,14,14,13,11,11, 6, 6, 6, 8, 5, 5, 8, 7, 7, 8,
+ 7, 7,11,10,10, 9, 7, 7, 9, 7, 7,12,10,10,10, 7,
+ 7, 6, 8, 7,12,10,10,12,10,10,11,10,10,15,14,13,
+ 13,10,10,11,10,10,16,14,14,14,10,10, 7, 7, 7,12,
+ 11,11,12,11,11,11,11,11,16,14,14,13,12,12,11,11,
+ 11,17,15,15,14,12,12,10, 9, 9,13,11,11,13,11,11,
+ 12,11,11,16,14,13,14,11,11,12,11,11,17,15,14,14,
+ 11,11, 7, 8, 8,12,11,11,12,10,10,12,10,10,16,13,
+ 14,13,10,10,11,10,10,17,14,14,14,10,10, 7, 7, 7,
+ 12,11,11,12,11,11,12,11,11,15,14,15,14,12,12,12,
+ 11,11,17,15,15,14,12,12,10,10, 9,13,11,11,13,11,
+ 11,13,11,11,16,14,14,14,11,11,13,11,11,16,15,15,
+ 15,11,11,
+};
+
+static const static_codebook _44p2_p6_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p2_p6_0,
+ 1, -527106048, 1620377600, 2, 0,
+ (long *)_vq_quantlist__44p2_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44p2_p6_1[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p2_p6_1[] = {
+ 2, 6, 6, 7, 7, 7, 7, 7, 7, 7, 8, 8, 9, 9, 9, 8,
+ 7, 7, 8, 8, 8, 9, 9, 9, 9, 8, 8, 6, 7, 7, 9, 8,
+ 8, 9, 7, 7, 9, 8, 8,10, 8, 8,10, 8, 8,10, 8, 8,
+ 10, 8, 9,10, 8, 8, 7, 6, 6, 8, 6, 6, 9, 6, 6, 9,
+ 7, 7,10, 8, 8, 9, 6, 6, 9, 7, 7,10, 9, 8, 9, 7,
+ 7, 7, 7, 7,11, 8, 8,11, 9, 9,10, 9, 9,12, 9, 9,
+ 12, 8, 8,11, 9, 9,12, 9, 9,12, 8, 8, 8, 7, 7,10,
+ 9, 9,10, 9, 9,10, 9, 9,11,10,11,11, 9, 9,11, 9,
+ 9,11,11,11,11, 9, 9,10, 8, 8,11, 9, 9,10, 9, 9,
+ 11, 9, 9,11,10,10,11, 9, 9,11, 9, 9,12,10,10,11,
+ 9, 9, 8, 8, 8,11, 9, 9,12, 9, 9,11, 9, 9,12, 9,
+ 9,12, 8, 8,12, 9, 9,12, 9,10,12, 8, 8, 9, 7, 7,
+ 11, 9, 9,11,10,10,11, 9, 9,11,11,11,11, 9, 9,11,
+ 10,10,12,11,11,11, 9,10,10, 9, 9,11, 9, 9,11,10,
+ 10,11,10,10,11,11,11,11, 9, 9,11, 9,10,11,11,11,
+ 11, 9, 9,
+};
+
+static const static_codebook _44p2_p6_1 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p2_p6_1,
+ 1, -530841600, 1616642048, 2, 0,
+ (long *)_vq_quantlist__44p2_p6_1,
+ 0
+};
+
+static const long _vq_quantlist__44p2_p7_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p2_p7_0[] = {
+ 1, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9,
+};
+
+static const static_codebook _44p2_p7_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p2_p7_0,
+ 1, -513979392, 1633504256, 2, 0,
+ (long *)_vq_quantlist__44p2_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44p2_p7_1[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p2_p7_1[] = {
+ 1, 9, 9, 6, 9, 9, 5, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,
+};
+
+static const static_codebook _44p2_p7_1 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p2_p7_1,
+ 1, -516716544, 1630767104, 2, 0,
+ (long *)_vq_quantlist__44p2_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44p2_p7_2[] = {
+ 12,
+ 11,
+ 13,
+ 10,
+ 14,
+ 9,
+ 15,
+ 8,
+ 16,
+ 7,
+ 17,
+ 6,
+ 18,
+ 5,
+ 19,
+ 4,
+ 20,
+ 3,
+ 21,
+ 2,
+ 22,
+ 1,
+ 23,
+ 0,
+ 24,
+};
+
+static const long _vq_lengthlist__44p2_p7_2[] = {
+ 1, 3, 2, 5, 4, 7, 7, 8, 8, 9, 9,10,10,11,11,12,
+ 12,13,13,14,14,15,15,15,15,
+};
+
+static const static_codebook _44p2_p7_2 = {
+ 1, 25,
+ (long *)_vq_lengthlist__44p2_p7_2,
+ 1, -518864896, 1620639744, 5, 0,
+ (long *)_vq_quantlist__44p2_p7_2,
+ 0
+};
+
+static const long _vq_quantlist__44p2_p7_3[] = {
+ 12,
+ 11,
+ 13,
+ 10,
+ 14,
+ 9,
+ 15,
+ 8,
+ 16,
+ 7,
+ 17,
+ 6,
+ 18,
+ 5,
+ 19,
+ 4,
+ 20,
+ 3,
+ 21,
+ 2,
+ 22,
+ 1,
+ 23,
+ 0,
+ 24,
+};
+
+static const long _vq_lengthlist__44p2_p7_3[] = {
+ 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5,
+};
+
+static const static_codebook _44p2_p7_3 = {
+ 1, 25,
+ (long *)_vq_lengthlist__44p2_p7_3,
+ 1, -529006592, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44p2_p7_3,
+ 0
+};
+
+static const long _huff_lengthlist__44p2_short[] = {
+ 4, 4,12, 9, 8,12,15,17, 4, 2,11, 6, 5, 9,13,15,
+ 11, 7, 8, 7, 7,10,14,13, 8, 5, 7, 5, 5, 8,12,12,
+ 8, 4, 7, 4, 3, 6,11,12,11, 8, 9, 7, 6, 8,11,12,
+ 15,13,14,12, 9, 7,10,13,16,12,17,12, 7, 5, 8,11,
+};
+
+static const static_codebook _huff_book__44p2_short = {
+ 2, 64,
+ (long *)_huff_lengthlist__44p2_short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44p3_l0_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44p3_l0_0[] = {
+ 1, 4, 4, 8, 8, 8, 8, 9, 9,10,10,10,10, 4, 6, 5,
+ 8, 7, 9, 9, 9, 9,10, 9,11, 9, 4, 5, 6, 7, 8, 9,
+ 9, 9, 9, 9,10, 9,10, 8, 9, 8, 9, 8,10, 9,11, 9,
+ 12,10,12,10, 8, 8, 9, 8, 9, 9,10, 9,11,10,12,10,
+ 12, 9,10,10,11,10,12,11,12,11,12,12,12,12, 9,10,
+ 10,11,11,11,11,11,12,12,12,12,12,10,11,11,12,12,
+ 12,12,12,12,12,12,12,12,10,11,11,12,12,12,12,12,
+ 12,12,12,12,12,11,12,12,12,12,12,13,12,13,12,13,
+ 12,12,11,12,12,12,12,12,12,13,12,12,12,12,12,12,
+ 12,12,13,13,12,13,12,13,12,13,12,12,12,13,12,13,
+ 12,13,12,13,12,13,12,12,12,
+};
+
+static const static_codebook _44p3_l0_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44p3_l0_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44p3_l0_0,
+ 0
+};
+
+static const long _vq_quantlist__44p3_l0_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p3_l0_1[] = {
+ 3, 4, 4, 5, 5, 4, 4, 5, 5, 5, 4, 5, 4, 5, 5, 5,
+ 5, 6, 5, 6, 5, 6, 5, 6, 5,
+};
+
+static const static_codebook _44p3_l0_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44p3_l0_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p3_l0_1,
+ 0
+};
+
+static const long _vq_quantlist__44p3_l1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p3_l1_0[] = {
+ 1, 4, 4, 4, 4, 4, 4, 4, 4,
+};
+
+static const static_codebook _44p3_l1_0 = {
+ 2, 9,
+ (long *)_vq_lengthlist__44p3_l1_0,
+ 1, -516716544, 1630767104, 2, 0,
+ (long *)_vq_quantlist__44p3_l1_0,
+ 0
+};
+
+static const long _huff_lengthlist__44p3_lfe[] = {
+ 1, 3, 2, 3,
+};
+
+static const static_codebook _huff_book__44p3_lfe = {
+ 2, 4,
+ (long *)_huff_lengthlist__44p3_lfe,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44p3_long[] = {
+ 3, 4,13, 9, 9,12,15,17, 4, 2,18, 5, 7,10,14,18,
+ 11, 8, 6, 5, 6, 8,11,14, 8, 5, 5, 3, 5, 8,11,13,
+ 9, 6, 7, 5, 5, 7, 9,10,11,10, 9, 8, 6, 6, 8,10,
+ 14,14,11,11, 9, 8, 9,10,17,17,14,13,10, 9,10,10,
+};
+
+static const static_codebook _huff_book__44p3_long = {
+ 2, 64,
+ (long *)_huff_lengthlist__44p3_long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44p3_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p3_p1_0[] = {
+ 1, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0,
+};
+
+static const static_codebook _44p3_p1_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p3_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44p3_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44p3_p2_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p3_p2_0[] = {
+ 3, 7, 7, 0, 0, 0, 8, 8, 0, 0, 0, 8, 8, 0, 0, 0,
+ 11,11, 0, 0, 0, 0, 0, 0, 0, 0,10, 9, 0, 0, 0, 0,
+ 0, 0, 0, 0, 9, 9, 0, 0, 0,10,11, 0, 0, 0, 0, 0,
+ 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0,
+ 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0,12,12, 0, 0,
+ 0, 0, 0, 0, 0, 0,11,11, 0, 0, 0,12,12, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7, 0, 0, 0,
+ 5, 5, 0, 0, 0, 7, 7, 0, 0, 0, 9, 9, 0, 0, 0, 0,
+ 0, 0, 0, 0, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5,
+ 0, 0, 0, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7, 0,
+ 0, 0, 0, 0, 0, 0, 0, 5, 6, 0, 0, 0, 7, 7, 0, 0,
+ 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0,
+ 8, 8, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,11,11, 0, 0, 0, 9, 9, 0,
+ 0, 0,10,10, 0, 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0,
+ 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0,
+ 10,10, 0, 0, 0, 0, 0, 0, 0, 0,10,10, 0, 0, 0, 0,
+ 0, 0, 0, 0, 9, 9, 0, 0, 0,10,10, 0, 0, 0, 0, 0,
+ 0, 0, 0,11,12, 0, 0, 0, 0, 0, 0, 0, 0,11,11, 0,
+ 0, 0,12,12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 9, 9, 0, 0, 0, 7, 7, 0, 0, 0, 8, 8, 0, 0,
+ 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 0, 0, 0,
+ 0, 0, 0, 0, 0, 7, 7, 0, 0, 0, 9, 9, 0, 0, 0, 0,
+ 0, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8,
+ 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0,10,10, 0,
+ 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0,11,11, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
+ 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0, 7, 7,
+ 0, 0, 0, 9, 9, 0, 0, 0,10,10, 0, 0, 0, 0, 0, 0,
+ 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 0, 0,
+ 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0,
+ 0, 0, 0, 0, 0, 7, 7, 0, 0, 0, 9, 9, 0, 0, 0, 0,
+ 0, 0, 0, 0,11,11, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9,
+ 0, 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 9, 9, 0, 0, 0, 7, 7, 0, 0, 0, 8, 8, 0,
+ 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0,
+ 0, 0, 0, 0, 0, 0, 8, 7, 0, 0, 0, 9, 9, 0, 0, 0,
+ 0, 0, 0, 0, 0, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 7,
+ 7, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0,11,11,
+ 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0,10,10, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0, 7,
+ 7, 0, 0, 0, 9, 9, 0, 0, 0,10,10, 0, 0, 0, 0, 0,
+ 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7, 0,
+ 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0,
+ 0, 0, 0, 0, 0, 0, 8, 8, 0, 0, 0, 9, 9, 0, 0, 0,
+ 0, 0, 0, 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 9,
+ 9, 0, 0, 0,11,11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0,10,10, 0, 0, 0, 9, 9, 0, 0, 0,10,10,
+ 0, 0, 0,11,12, 0, 0, 0, 0, 0, 0, 0, 0,10,10, 0,
+ 0, 0, 0, 0, 0, 0, 0, 8, 8, 0, 0, 0,11,11, 0, 0,
+ 0, 0, 0, 0, 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0,
+ 9, 9, 0, 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0,11,
+ 11, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0,12,12,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,10,10, 0, 0, 0,
+ 9, 9, 0, 0, 0,10,10, 0, 0, 0,12,12, 0, 0, 0, 0,
+ 0, 0, 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9,
+ 0, 0, 0,11,11, 0, 0, 0, 0, 0, 0, 0, 0,10,10, 0,
+ 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0,11,11, 0, 0,
+ 0, 0, 0, 0, 0, 0,12,12, 0, 0, 0, 0, 0, 0, 0, 0,
+ 10,10, 0, 0, 0,11,11, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+};
+
+static const static_codebook _44p3_p2_0 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p3_p2_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p3_p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44p3_p3_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p3_p3_0[] = {
+ 1, 5, 5, 5, 8, 8, 0, 8, 8, 6, 9, 9, 8,10,10, 0,
+ 8, 8, 0, 9, 9, 0,12,12, 0, 8, 8, 4, 7, 7, 6,10,
+ 10, 0,12,12, 7,11,11, 9,12,12, 0,12,12, 0,13,13,
+ 0,15,15, 0,12,12, 0, 7, 7, 0, 7, 7, 0, 8, 8, 0,
+ 8, 8, 0,10,10, 0, 7, 7, 0, 8, 8, 0,11,11, 0, 7,
+ 7, 5, 7, 7, 9, 9, 9, 0,11,10, 9, 9, 9,11,12,12,
+ 0,10,10, 0,11,11, 0,13,13, 0,11,11, 6, 7, 7, 9,
+ 10,10, 0,12,12,10,11,11,11,12,12, 0,12,12, 0,13,
+ 13, 0,15,15, 0,12,12, 0,10,10, 0,11,11, 0,11,11,
+ 0,12,12, 0,13,13, 0,11,11, 0,12,12, 0,15,15, 0,
+ 11,11, 0, 8, 8, 0,10,10, 0,12,12, 0,11,11, 0,12,
+ 12, 0,12,12, 0,12,12, 0,15,15, 0,11,11, 0, 7, 7,
+ 0,10,10, 0,12,12, 0,10,10, 0,12,13, 0,12,12, 0,
+ 13,13, 0,14,14, 0,12,12, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0,
+};
+
+static const static_codebook _44p3_p3_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p3_p3_0,
+ 1, -533200896, 1614282752, 2, 0,
+ (long *)_vq_quantlist__44p3_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44p3_p3_1[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p3_p3_1[] = {
+ 3, 4, 4, 0, 8, 8, 0, 8, 8, 0, 9, 9, 0,10,10, 0,
+ 8, 8, 0, 9, 9, 0,10,10, 0, 8, 8, 0, 7, 7, 0, 8,
+ 8, 0, 8, 8, 0, 8, 8, 0, 8, 8, 0, 8, 8, 0, 8, 8,
+ 0, 8, 8, 0, 8, 8, 0, 7, 7, 0, 6, 6, 0, 7, 7, 0,
+ 7, 7, 0,10,10, 0, 6, 6, 0, 7, 7, 0,10,10, 0, 6,
+ 5, 0, 8, 8, 0, 7, 7, 0, 8, 8, 0, 8, 8, 0, 9, 9,
+ 0, 7, 7, 0, 8, 8, 0, 9, 9, 0, 7, 7, 0, 6, 6, 0,
+ 9,10, 0,10,10, 0,10,10, 0,11,11, 0, 9, 9, 0,10,
+ 10, 0,11,11, 0, 9, 9, 0, 8, 8, 0, 8, 8, 0, 8, 8,
+ 0, 9, 9, 0, 9, 9, 0, 8, 8, 0, 8, 8, 0, 9, 9, 0,
+ 7, 7, 0, 8, 8, 0, 7, 7, 0, 7, 7, 0, 8, 8, 0, 9,
+ 9, 0, 7, 7, 0, 7, 7, 0, 9, 9, 0, 6, 6, 0, 6, 6,
+ 0,10,10, 0,10,10, 0,10,10, 0,12,12, 0, 9, 9, 0,
+ 10,10, 0,12,12, 0, 9, 9, 0, 8, 8, 0, 7, 7, 0, 8,
+ 8, 0, 8, 8, 0, 9, 9, 0, 7, 7, 0, 8, 8, 0, 9, 9,
+ 0, 7, 7,
+};
+
+static const static_codebook _44p3_p3_1 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p3_p3_1,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44p3_p3_1,
+ 0
+};
+
+static const long _vq_quantlist__44p3_p4_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p3_p4_0[] = {
+ 1, 6, 6, 7, 7, 7, 7, 7, 7, 7, 8, 8,10,11,11, 9,
+ 8, 8, 8, 8, 8,11,11,11,10, 8, 8, 5, 7, 7, 9,11,
+ 11,10,11,11,10,11,11,12,13,14,11,12,12,10,11,11,
+ 13,14,14,12,12,12, 5, 6, 6, 8, 6, 6, 8, 7, 7, 8,
+ 7, 7,11,10,10,10, 7, 7, 9, 7, 7,12,11,11,11, 7,
+ 7, 7, 7, 7,11,10,10,12,10,10,11,10,10,15,13,13,
+ 13,10,10,12,11,11,15,13,13,14,11,11, 7, 7, 7,11,
+ 11,11,12,11,11,12,11,11,14,14,14,14,12,12,12,12,
+ 12,16,15,15,14,12,12, 0,10,10, 0,11,11, 0,11,12,
+ 0,11,11, 0,14,14, 0,11,11, 0,12,12, 0,15,15, 0,
+ 11,11, 8, 8, 8,12,10,10,12,10,10,13,11,11,15,13,
+ 13,14,11,11,12,10,10,16,14,14,14,10,10, 8, 7, 7,
+ 12,11,11,13,11,11,12,11,11,15,14,14,14,12,12,13,
+ 12,12,15,14,14,15,12,12, 0,11,11, 0,12,12, 0,12,
+ 12, 0,12,12, 0,15,15, 0,12,12, 0,13,13, 0,14,15,
+ 0,12,12,
+};
+
+static const static_codebook _44p3_p4_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p3_p4_0,
+ 1, -531365888, 1616117760, 2, 0,
+ (long *)_vq_quantlist__44p3_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44p3_p4_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p3_p4_1[] = {
+ 3, 4, 5, 8, 8,12,10,10,12,12,12,10,10,12,12,13,
+ 11,11,12,12,13,12,12,12,12,13,10,10,13,13,13,13,
+ 13,13,13,13,10,10,13,13,13,11,11,13,13,14,13,13,
+ 12,12,13,10,10,13,13,13,13,13,13,13,13,10,10,12,
+ 12,13,11,11,13,13,13,13,13,12,12,13,12,12,13,13,
+ 13,13,13,13,13,14,11,11,12,12,14,12,12,13,12,14,
+ 14,14,12,12,13,14,14,13,13,14,13,13,13,13,14,14,
+ 14,12,12,14,13,13,13,13,14,14,14,12,12,12, 8, 8,
+ 11,11,12,12,12,11,11,12,11,11,10,10,13,12,12,10,
+ 10,13,12,12,10,10,13,12,12,12,12,14,12,12,12,12,
+ 13,13,13,11,11,14,12,12,11,11,14,12,12,12,12,14,
+ 12,12,12,12,13,12,12,12,12,13,13,13,11,11,14,12,
+ 12,11,11,14,12,12,12,12,14,13,13,12,12,14,12,12,
+ 12,11,14,13,13,11,11,14,13,12,11,11,14,13,13,11,
+ 11,14,13,13,12,12,14,12,12,12,12,15,13,13,12,12,
+ 14,12,12,11,11,14,13,13,11,11,12, 9, 9,10,10,12,
+ 7, 7,11,11,12, 9, 9,12,12,13,10,10,10,10,14,14,
+ 14,11,11,13, 9, 9,12,12,14,14,14,12,12,13, 8, 8,
+ 11,11,14, 9, 9,12,12,14,14,14,11,11,13, 9, 9,12,
+ 12,14,14,14,12,12,14, 8, 8,11,11,14, 9, 9,12,12,
+ 14,14,14,11,11,14,10,10,12,12,14,14,14,13,13,14,
+ 9, 9,11,11,14,10,10,12,12,14,14,14,11,11,14,14,
+ 15,12,12,15,14,14,14,14,15,14,14,11,11,14,14,14,
+ 12,12,14,14,14,11,11,14,11,11,10,10,14,10,10,10,
+ 10,14,10,10,10,10,15,11,11, 9, 9,14,12,12, 9, 9,
+ 15,11,11,11,11,15,13,13,11,11,15,10,10,10,10,15,
+ 11,11,10,10,15,13,13,11,11,15,11,11,11,11,15,13,
+ 13,11,11,15,10,10,10,10,15,11,11,10,10,15,13,13,
+ 11,11,15,12,12,11,11,15,13,13,11,11,15,11,11,10,
+ 10,15,12,12,10,10,15,13,13,10,10,15,14,14,11,11,
+ 15,13,13,11,11,15,14,14,10,11,15,13,13,10,10,15,
+ 13,14,10,10,14,13,13,10,10,14,13,13,10,10,14,13,
+ 13,10,10,14,13,13, 9, 9,14,14,14, 9, 9,15,14,14,
+ 11,11,15,14,14,10,10,15,14,14,10,10,15,14,14,11,
+ 11,15,14,14,10,10,15,14,14,11,11,15,14,14,10,10,
+ 14,14,14,10,10,15,14,14,10,10,14,14,14,10,10,15,
+ 14,14,11,11,15,14,14,11,11,14,14,14,10,10,15,14,
+ 14,10,10,14,14,14, 9, 9,15,15,15,11,11,15,14,14,
+ 12,12,15,15,14,10,10,15,14,14,10,10,14,15,15, 9,
+ 9,14,10,10,12,12,17, 9, 9,12,12,17,10,10,13,13,
+ 17,11,11,12,12,18,14,14,12,12,17,10,10,13,13,17,
+ 14,14,12,12,17, 9, 9,12,12,17,11,11,12,12,17,14,
+ 14,12,12,18,10,10,13,13,18,14,14,13,13,18, 9, 9,
+ 12,12,18,10,10,13,13,18,14,14,12,12,18,11,11,13,
+ 13,18,14,14,13,13,18,10,10,12,12,17,11,11,12,12,
+ 17,14,14,12,12,18,15,15,13,13,18,14,14,14,14,18,
+ 15,15,12,12,18,14,14,12,12,18,15,15,12,12,13, 7,
+ 7,11,11,14,15,15,11,11,14,15,15,12,12,14,15,15,
+ 11,11,15,15,15,11,11,14,15,15,12,12,14,15,15,12,
+ 12,14,15,15,11,11,14,15,15,11,11,15,15,15,12,12,
+ 14,15,15,12,12,14,15,15,12,12,14,15,15,11,11,14,
+ 15,15,11,11,15,15,15,12,12,15,15,15,12,12,14,15,
+ 15,12,12,14,15,14,12,12,14,15,15,11,11,15,14,14,
+ 12,12,15,15,15,12,12,15,16,16,12,12,15,15,15,12,
+ 12,15,15,15,12,12,15,15,15,12,12,13,13,13,11,10,
+ 14,14,15,11,11,14,14,14,12,12,15,14,14,10,10,15,
+ 15,15,11,11,14,15,15,12,12,14,14,14,11,11,14,15,
+ 15,11,11,14,15,15,12,12,15,15,15,11,11,14,15,15,
+ 12,12,14,14,14,12,12,14,15,15,11,11,14,15,15,12,
+ 12,15,15,15,11,11,15,15,15,12,12,15,14,14,12,12,
+ 14,15,15,11,11,14,15,15,11,11,15,15,15,10,10,15,
+ 15,16,12,12,15,15,15,14,14,15,15,15,11,11,15,15,
+ 15,12,12,15,15,15,11,11,14,11,11,10,10,15, 9, 9,
+ 12,12,15,10,10,12,12,15,11,11,11,11,15,14,14,12,
+ 12,15,10,10,13,13,15,14,14,12,12,15, 9, 9,12,12,
+ 15,10,10,13,13,15,13,13,12,11,15,10,10,12,12,15,
+ 14,14,12,12,15, 9, 9,11,11,15,11,11,12,12,15,13,
+ 13,11,11,15,11,11,13,13,15,13,14,13,14,15,11,11,
+ 11,11,15,11,11,12,12,15,14,14,11,11,15,14,14,13,
+ 13,15,14,14,20,20,15,14,14,12,12,15,14,14,12,12,
+ 15,14,14,11,11,14,13,13,10,10,14,13,13,12,12,14,
+ 14,13,12,12,15,14,14,12,12,15,14,14,11,11,15,14,
+ 14,12,12,15,14,14,13,13,15,14,14,12,11,15,14,14,
+ 11,11,15,14,14,13,13,15,14,14,12,12,15,14,14,13,
+ 13,15,14,14,12,11,15,14,14,12,12,15,14,14,13,13,
+ 15,14,14,13,13,15,14,14,12,12,15,14,14,12,12,15,
+ 14,14,12,12,15,15,15,13,13,15,15,15,13,13,15,14,
+ 14,13,13,15,15,15,13,13,15,14,15,12,12,15,15,15,
+ 13,13,14,10,10,12,13,17, 9, 9,12,12,17,10,10,13,
+ 13,17,11,11,12,12,18,14,14,12,12,18,10,10,13,13,
+ 18,14,14,12,12,17, 9, 9,12,12,18,10,11,13,13,18,
+ 14,14,12,12,17,10,10,12,12,17,14,14,12,12,17, 9,
+ 9,12,12,17,11,11,12,12,17,14,14,12,12,18,11,11,
+ 12,12,18,14,14,13,13,18,11,11,12,12,18,11,11,12,
+ 12,18,14,14,12,12,18,15,15,12,12,18,14,14,13,13,
+ 18,15,15,12,12,17,14,14,12,12,17,15,15,12,12,13,
+ 7, 7,11,11,14,15,15,11,11,14,15,15,11,11,14,15,
+ 14,12,12,15,15,15,12,11,14,15,15,12,12,14,15,15,
+ 12,12,14,15,15,11,11,14,15,15,11,11,15,15,15,13,
+ 13,14,15,15,11,11,14,15,15,13,12,14,15,15,11,11,
+ 14,15,15,11,11,15,15,15,13,13,14,15,15,12,12,15,
+ 15,15,12,12,15,15,15,11,11,15,15,15,11,11,15,15,
+ 15,12,12,15,15,15,13,13,15,16,16,12,12,15,15,15,
+ 12,13,15,15,15,12,12,15,15,15,12,12,13,13,13,11,
+ 11,14,14,14,11,11,14,14,14,12,12,14,14,14,10,10,
+ 15,14,14,11,11,14,15,15,12,12,14,14,14,12,12,14,
+ 15,15,11,11,14,15,14,12,12,15,14,14,11,11,14,15,
+ 15,12,12,14,14,14,11,11,14,15,15,11,11,14,14,14,
+ 12,12,15,15,14,11,11,15,15,15,12,12,15,14,14,12,
+ 12,14,15,15,11,11,14,15,14,11,11,15,15,15,10,10,
+ 15,15,15,12,12,15,14,14,14,13,15,15,15,11,11,15,
+ 15,15,11,11,15,15,15,10,10,14,11,11,10,10,15, 9,
+ 9,12,12,15,10,10,12,12,15,11,11,11,11,15,14,14,
+ 12,12,15,10,10,13,13,15,13,13,12,12,15, 9, 9,12,
+ 12,15,11,11,13,13,15,14,14,12,12,15,10,10,13,13,
+ 15,13,14,12,12,15, 9, 9,12,12,15,10,10,13,13,15,
+ 13,13,11,11,15,11,11,13,13,15,14,14,13,13,15,10,
+ 10,11,11,15,11,11,12,12,15,14,14,11,11,15,14,14,
+ 13,13,15,14,14,21,20,15,14,14,11,11,15,14,14,12,
+ 12,15,14,14,11,11,14,13,13,10,10,14,13,13,11,11,
+ 15,14,14,12,12,15,14,14,12,12,14,14,14,12,12,15,
+ 14,14,12,12,15,14,14,13,13,14,14,14,11,11,15,14,
+ 14,11,11,15,14,14,13,13,15,14,14,12,12,15,14,14,
+ 13,13,14,14,14,11,11,15,14,14,11,11,14,14,14,13,
+ 13,15,14,14,12,12,15,14,14,12,12,15,14,14,12,12,
+ 15,14,14,12,12,14,14,14,13,13,15,15,15,13,13,16,
+ 14,14,12,13,15,15,15,13,13,15,14,14,12,12,15,15,
+ 15,13,13,15,11,11,13,12,18,10,10,12,12,17,11,11,
+ 12,12,18,12,12,11,11,18,14,14,12,12,18,11,11,13,
+ 13,17,14,14,12,12,18,10,10,12,12,18,12,12,12,12,
+ 18,14,15,12,12,18,11,11,13,13,18,14,14,12,12,17,
+ 10,10,12,12,18,11,11,12,12,18,15,14,12,12,17,12,
+ 12,12,12,17,14,14,12,12,17,11,11,11,11,17,12,12,
+ 12,11,17,15,15,11,11,18,15,15,12,12,18,14,15,13,
+ 13,18,15,15,11,11,17,15,15,12,12,18,15,15,11,11,
+ 14, 9, 9,11,11,14,15,15,11,11,15,15,15,11,11,15,
+ 15,15,12,11,15,15,15,12,12,15,15,15,11,11,15,15,
+ 15,13,13,14,15,15,11,11,15,15,15,11,11,15,15,15,
+ 13,13,15,15,15,11,11,15,15,15,13,13,15,15,15,11,
+ 11,15,15,15,11,11,15,15,15,13,13,15,15,15,12,12,
+ 15,15,15,13,13,15,15,14,11,11,15,15,15,12,12,15,
+ 15,15,12,12,16,15,15,13,13,15,16,16,13,13,16,15,
+ 15,12,12,15,15,15,13,12,15,15,15,12,12,13,12,12,
+ 11,11,14,14,14,11,11,14,14,14,12,12,15,14,14,11,
+ 11,15,14,14,12,12,15,14,14,12,12,15,14,14,12,12,
+ 14,15,15,11,11,15,14,14,12,12,15,14,14,11,11,15,
+ 14,14,12,12,15,14,14,12,12,14,15,15,11,11,15,14,
+ 14,12,12,15,14,14,11,11,15,15,15,12,12,15,14,14,
+ 12,12,15,15,15,11,11,15,14,14,11,11,15,14,15,11,
+ 11,15,15,15,12,12,15,14,14,13,13,16,15,15,11,11,
+ 15,14,14,12,12,15,15,15,11,11,14,11,11, 9, 9,15,
+ 10,10,12,12,14,11,11,12,12,15,12,12,12,12,15,14,
+ 14,13,13,15,11,11,13,13,15,14,14,13,13,15,10,10,
+ 12,12,15,12,12,13,13,15,14,14,13,13,15,11,11,12,
+ 12,15,14,14,13,13,14,10,10,12,12,15,12,12,13,13,
+ 15,14,14,12,12,15,12,12,13,13,15,14,14,15,15,15,
+ 11,11,12,12,15,12,12,12,13,15,14,14,12,12,15,15,
+ 15,14,14,15,14,14,20,20,15,14,14,12,12,15,14,14,
+ 13,13,15,14,14,12,12,14,13,13,10,10,14,13,13,11,
+ 11,14,13,13,12,12,14,14,14,12,12,15,14,14,13,13,
+ 15,14,14,12,12,14,14,14,14,14,14,14,14,11,11,15,
+ 14,14,12,12,15,14,14,14,14,15,14,14,12,12,14,14,
+ 14,14,14,14,14,14,11,11,15,14,14,12,12,14,14,14,
+ 14,14,15,14,14,12,12,15,14,14,13,13,15,14,14,12,
+ 12,15,14,14,12,12,14,14,14,14,13,15,15,15,14,14,
+ 15,14,14,13,13,15,15,15,14,14,15,14,14,13,13,15,
+ 15,15,13,13,14,13,13,13,13,18,15,15,12,12,18,15,
+ 15,13,12,18,15,16,11,11,18,16,17,12,12,18,15,15,
+ 13,13,18,17,17,12,12,18,15,15,12,12,17,15,15,12,
+ 12,18,17,17,12,12,18,15,15,13,13,18,16,17,12,12,
+ 17,15,15,12,12,18,15,15,12,12,18,16,17,11,12,18,
+ 16,16,12,12,17,16,17,12,12,18,15,15,11,11,18,15,
+ 15,12,12,18,17,17,11,11,17,17,17,12,12,18,16,16,
+ 13,13,18,17,17,11,11,18,16,16,12,12,18,17,17,11,
+ 11,15,14,14,11,11,16,15,15,11,11,16,15,15,12,12,
+ 16,15,15,12,12,17,15,15,14,13,16,15,15,12,12,17,
+ 15,15,14,14,16,15,15,11,11,16,15,15,12,12,18,15,
+ 15,13,13,16,15,15,11,11,17,15,15,14,14,16,15,15,
+ 11,11,16,15,15,12,12,17,15,15,13,13,16,15,15,12,
+ 12,17,16,15,14,14,16,14,15,12,12,16,15,15,12,12,
+ 18,15,15,13,13,17,15,15,14,14,17,16,16,15,15,17,
+ 15,15,13,13,17,15,15,14,14,18,15,15,13,13,15,12,
+ 13,11,11,15,14,14,12,12,16,14,14,12,12,16,14,14,
+ 12,12,16,14,14,12,12,16,14,14,13,12,17,14,14,13,
+ 13,16,15,15,12,12,16,14,14,12,12,17,14,14,12,12,
+ 16,14,14,12,12,17,14,14,13,13,15,15,15,12,12,16,
+ 14,14,12,12,17,14,14,12,12,17,15,15,12,12,17,14,
+ 14,13,13,16,15,15,12,12,16,14,14,12,12,17,15,15,
+ 12,12,18,15,15,13,13,17,14,14,13,13,17,15,15,12,
+ 12,17,14,14,12,12,17,15,15,12,12,14,15,15, 9, 9,
+ 15,15,15,12,12,15,15,15,13,13,15,15,15,14,14,15,
+ 15,15,19,19,15,15,16,13,13,15,15,16,19,20,15,15,
+ 15,13,12,15,16,16,14,14,15,15,15,19,19,15,15,15,
+ 13,13,15,16,15,20,19,14,15,15,13,13,15,15,15,14,
+ 14,15,15,15,19,19,15,15,15,14,14,15,16,16,19,20,
+ 15,15,15,14,14,15,15,15,14,14,15,15,15,19,19,15,
+ 15,15,20,19,15,16,16,20,19,15,15,15,19,19,15,16,
+ 16,20,20,15,15,15,19,20,14,13,13,10,10,14,14,14,
+ 11,11,14,14,14,12,12,15,14,14,13,13,15,14,14,19,
+ 20,15,14,14,12,12,14,14,14,20,19,14,14,14,11,11,
+ 15,14,14,12,12,15,14,14,20,20,15,14,14,12,12,14,
+ 14,14,20,19,14,14,14,11,11,15,14,14,12,12,15,14,
+ 14,19,20,15,14,14,13,13,15,14,14,22,19,15,15,14,
+ 12,12,15,14,14,13,13,14,15,15,22,20,15,15,15,20,
+ 20,15,14,14,21,20,15,15,15,20,21,15,14,14,20,20,
+ 14,15,15,20,20,
+};
+
+static const static_codebook _44p3_p4_1 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p3_p4_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p3_p4_1,
+ 0
+};
+
+static const long _vq_quantlist__44p3_p5_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p3_p5_0[] = {
+ 2, 6, 6,14,14, 6, 7, 7,14,14, 7, 7, 7,15,15, 0,
+ 12,12,15,15, 0,13,13,15,15, 7, 8, 8,15,15,10,10,
+ 10,16,16, 9, 8, 8,15,15, 0,13,13,18,17, 0,13,13,
+ 16,16, 8, 8, 8,15,15,12,11,11,16,16, 9, 8, 8,15,
+ 15, 0,13,13,18,18, 0,13,13,16,16, 0,14,14,17,17,
+ 0,20, 0,19,20, 0,12,12,16,16, 0,16,16,20,22, 0,
+ 14,14,16,16, 0,14,14,17,17, 0,20,22,20,19, 0,13,
+ 13,15,16, 0,17,18, 0,21, 0,15,15,16,16, 5, 7, 7,
+ 13,13, 8, 9, 9,14,14,10,10,10,14,14, 0,20,22,18,
+ 18, 0,22,21,18,17, 9,10,10,14,14,12,12,12,17,17,
+ 12,10,10,14,14, 0, 0,20,17,17, 0,22,21,17,18,11,
+ 10,10,14,14,14,13,13,18,18,12,11,11,14,14, 0,22,
+ 21,18,19, 0,20, 0,17,17, 0,22, 0,18,18, 0, 0, 0,
+ 0, 0, 0,20,20,17,17, 0,22, 0,22,21, 0,21, 0,19,
+ 18, 0,22,22,18,18, 0, 0, 0, 0, 0, 0,21, 0,17,17,
+ 0,22, 0,20,20, 0, 0, 0,19,18, 6, 6, 6,12,12, 8,
+ 6, 6,10,10, 8, 6, 6,13,12, 0,10,10,11,11, 0,11,
+ 11,13,13, 8, 7, 7,13,13,11, 9, 9,13,13,10, 6, 6,
+ 12,12, 0,10,10,14,14, 0,10,10,13,13, 9, 7, 7,13,
+ 13,12,10,10,13,13,10, 6, 6,12,12, 0,11,11,15,15,
+ 0,10,10,13,13, 0,12,12,15,14, 0,19,20,16,17, 0,
+ 9, 9,13,13, 0,14,14,20,21, 0,12,11,13,12, 0,12,
+ 12,15,14, 0,20,19,17,17, 0,10,10,12,13, 0,15,15,
+ 22,21, 0,12,12,12,13, 0,10,10,12,12, 0,11,11,15,
+ 15, 0,11,11,15,15, 0,15,15,22,22, 0,16,17, 0, 0,
+ 0,11,11,15,15, 0,14,14,18,18, 0,11,11,16,16, 0,
+ 16,15, 0,21, 0,16,16, 0, 0, 0,12,12,15,15, 0,14,
+ 14,19,19, 0,11,11,15,15, 0,15,15,22, 0, 0,16,16,
+ 22, 0, 0,16,16, 0,21, 0, 0, 0, 0, 0, 0,15,15,19,
+ 20, 0,18,18, 0, 0, 0,17,17, 0, 0, 0,17,17, 0, 0,
+ 0, 0, 0, 0, 0, 0,16,15,22,21, 0,20,20, 0, 0, 0,
+ 18,18, 0, 0, 0,10,10,12,12, 0,10,10,11,11, 0,11,
+ 11,12,12, 0,11,11, 9, 9, 0,13,12,12,12, 0,11,11,
+ 13,13, 0,13,13,12,12, 0,10,10,12,12, 0,13,12,13,
+ 13, 0,12,12,12,12, 0,11,11,13,13, 0,13,13,12,12,
+ 0,10,10,12,12, 0,13,13,14,13, 0,12,12,12,12, 0,
+ 14,13,13,14, 0,20,21,15,15, 0,11,11,12,12, 0,15,
+ 16,20,20, 0,12,13,10,10, 0,13,13,14,13, 0,20,20,
+ 15,15, 0,11,11,12,12, 0,16,17,21,21, 0,13,13,11,
+ 11, 6, 7, 7,16,15,11, 9, 9,14,15,12, 9, 9,16,16,
+ 0,13,13,15,15, 0,14,14,17,17,10, 9, 9,16,16,14,
+ 12,12,16,16,12, 9, 9,15,15, 0,13,13,17,18, 0,13,
+ 13,15,15,12,10,10,17,17,15,12,12,17,17,13, 9, 9,
+ 16,16, 0,13,13,18,19, 0,14,14,16,16, 0,15,15,18,
+ 18, 0, 0, 0,20,19, 0,12,12,17,16, 0,16,17, 0,21,
+ 0,14,15,16,16, 0,15,15,18,18, 0, 0,22,19,21, 0,
+ 13,13,16,16, 0,18,17,22,22, 0,15,15,16,16, 7, 7,
+ 7,13,13,11,10,10,15,15,12,10,10,14,14, 0,21, 0,
+ 18,17, 0,21,22,18,18,11,10,10,15,15,14,12,12,17,
+ 17,14,11,11,14,14, 0,21,20,18,18, 0,22,21,18,17,
+ 12,11,10,16,16,16,14,14,17,19,14,11,11,15,15, 0,
+ 0,22,19,19, 0,21,22,18,18, 0,21, 0,18,19, 0, 0,
+ 0,22, 0, 0,22,21,17,17, 0, 0, 0,20,22, 0, 0,21,
+ 18,18, 0, 0, 0,19,20, 0, 0, 0, 0, 0, 0, 0,21,17,
+ 17, 0, 0, 0,22,21, 0, 0, 0,19,19,10, 9, 9,14,13,
+ 13,10,10,12,12,13,10,10,14,14, 0,13,13,12,12, 0,
+ 15,14,16,15,13,10,10,14,14,15,12,12,14,14,15,10,
+ 10,14,14, 0,14,14,15,15, 0,14,13,14,14,13,10,10,
+ 15,15,17,13,13,15,15,14,10,10,14,14, 0,14,14,15,
+ 16, 0,14,14,15,15, 0,15,15,16,16, 0,21,22,17,18,
+ 0,12,12,14,14, 0,17,17,20,21, 0,14,14,14,14, 0,
+ 15,15,16,16, 0,21,22,18,18, 0,13,13,14,14, 0,18,
+ 18,22, 0, 0,15,15,14,14, 0,11,11,13,13, 0,12,12,
+ 16,15, 0,12,12,16,16, 0,16,16, 0, 0, 0,16,17, 0,
+ 22, 0,12,12,16,16, 0,14,14,17,18, 0,11,11,16,16,
+ 0,15,15, 0,21, 0,16,16,21,22, 0,12,12,16,16, 0,
+ 15,15,19,19, 0,12,12,17,16, 0,16,16,21,22, 0,16,
+ 16, 0, 0, 0,17,17, 0,22, 0, 0, 0, 0, 0, 0,15,15,
+ 19,20, 0,17,19, 0, 0, 0,17,17,22, 0, 0,17,17, 0,
+ 22, 0, 0, 0, 0, 0, 0,15,15,21, 0, 0,19,20, 0, 0,
+ 0,19,18,22, 0, 0,11,12,14,14, 0,11,11,14,14, 0,
+ 12,12,15,15, 0,13,13,13,13, 0,14,14,16,16, 0,12,
+ 12,15,15, 0,14,14,16,15, 0,11,11,15,15, 0,13,13,
+ 16,16, 0,13,13,15,15, 0,12,12,15,15, 0,15,14,16,
+ 16, 0,11,11,15,15, 0,14,14,17,17, 0,13,13,15,15,
+ 0,15,15,16,16, 0, 0, 0,18,18, 0,12,12,14,14, 0,
+ 16,16,22, 0, 0,14,14,15,15, 0,15,15,16,17, 0,21,
+ 22,18,18, 0,13,13,15,14, 0,18,17,22, 0, 0,14,14,
+ 15,15, 8, 8, 8,16,15,12,10,10,16,15,12,10,10,16,
+ 16, 0,14,14,16,17, 0,14,14,17,16,12,10,10,17,18,
+ 14,12,12,18,18,14,10,10,16,16, 0,14,14,18,18, 0,
+ 14,14,16,16,12, 9, 9,16,16,17,13,13,16,17,14, 9,
+ 9,15,15, 0,14,14,18,19, 0,13,13,15,15, 0,15,15,
+ 18,19, 0, 0, 0,22,21, 0,13,13,16,16, 0,16,16,22,
+ 0, 0,15,15,16,16, 0,14,14,18,17, 0, 0, 0,20, 0,
+ 0,13,13,16,16, 0,18,18, 0, 0, 0,15,15,16,16, 8,
+ 7, 7,13,13,12,10,10,15,15,12,10,10,14,14, 0,22,
+ 22,19,18, 0, 0, 0,18,18,12,10,10,15,15,14,13,13,
+ 17,17,14,11,11,15,15, 0,19,20,18,18, 0,22,21,17,
+ 18,13,11,11,15,15,16,13,13,18,18,14,11,11,14,15,
+ 0,22,21,20,19, 0,22,21,17,17, 0, 0,22,19,18, 0,
+ 0, 0, 0, 0, 0,22,20,17,17, 0, 0, 0,21,20, 0, 0,
+ 0,19,17, 0, 0,22,19,19, 0, 0, 0, 0, 0, 0,22,20,
+ 18,17, 0, 0, 0, 0, 0, 0, 0, 0,18,18, 0,10,10,14,
+ 14, 0,11,11,14,14, 0,11,11,15,15, 0,14,14,14,14,
+ 0,15,15,16,16, 0,11,11,16,16, 0,13,13,16,16, 0,
+ 11,11,15,15, 0,14,14,16,16, 0,14,14,15,15, 0,11,
+ 11,15,15, 0,13,13,15,15, 0,10,10,15,15, 0,15,15,
+ 17,17, 0,14,14,14,14, 0,16,16,16,16, 0, 0,22,19,
+ 19, 0,13,13,14,14, 0,17,17, 0, 0, 0,15,15,14,14,
+ 0,16,16,17,17, 0, 0,22,18,18, 0,13,13,14,14, 0,
+ 21,18, 0, 0, 0,15,15,14,14, 0,11,11,13,13, 0,12,
+ 12,15,15, 0,12,12,16,15, 0,16,16, 0, 0, 0,17,17,
+ 22,22, 0,12,12,16,16, 0,14,14,18,18, 0,11,12,16,
+ 16, 0,15,16, 0,21, 0,16,16,22,21, 0,12,12,16,16,
+ 0,15,15,19,20, 0,11,12,16,16, 0,15,15,20,22, 0,
+ 16,16, 0,22, 0,17,17,22, 0, 0, 0, 0, 0, 0, 0,15,
+ 15,21,22, 0,19,18, 0, 0, 0,17,17, 0, 0, 0,17,17,
+ 0,22, 0, 0, 0, 0, 0, 0,16,15,22, 0, 0,19,19, 0,
+ 0, 0,17,18, 0, 0, 0,12,12,15,15, 0,12,12,15,15,
+ 0,12,12,15,15, 0,13,13,14,14, 0,15,15,16,17, 0,
+ 12,12,16,16, 0,14,14,16,16, 0,12,11,15,16, 0,14,
+ 14,16,17, 0,14,14,16,16, 0,13,12,16,16, 0,15,15,
+ 16,16, 0,11,11,15,15, 0,14,14,16,16, 0,14,14,15,
+ 15, 0,15,15,18,17, 0, 0,22, 0,20, 0,13,13,15,15,
+ 0,16,17,22,22, 0,14,14,15,15, 0,15,15,17,18, 0,
+ 20, 0,19,19, 0,13,13,15,15, 0,18,18,22, 0, 0,14,
+ 14,15,15, 0,11,11,16,16, 0,14,14,17,16, 0,13,13,
+ 17,17, 0,16,16,17,17, 0,17,17,18,19, 0,12,12,16,
+ 17, 0,15,15,18,18, 0,12,12,16,16, 0,16,16,19,18,
+ 0,16,16,17,16, 0,12,13,17,17, 0,17,16,18,17, 0,
+ 13,12,16,16, 0,16,16,18,19, 0,16,16,16,17, 0,16,
+ 16,18,18, 0,22, 0,22,22, 0,13,13,16,16, 0,19,18,
+ 22,20, 0,16,15,16,16, 0,16,17,18,18, 0, 0, 0,22,
+ 20, 0,14,14,16,16, 0,19,19, 0, 0, 0,16,16,16,16,
+ 0, 9, 9,13,13, 0,13,13,15,15, 0,14,14,15,15, 0,
+ 0,22,17,18, 0,22, 0,18,19, 0,12,12,15,15, 0,15,
+ 16,17,17, 0,14,14,14,14, 0,22, 0,18,18, 0,21,22,
+ 17,17, 0,13,13,15,15, 0,17,17,17,18, 0,14,14,15,
+ 15, 0,22,21,21,19, 0,20,21,17,17, 0,21,21,19,18,
+ 0, 0, 0, 0, 0, 0,21,21,17,17, 0, 0, 0,22,22, 0,
+ 0,22,19,18, 0, 0,21,19,18, 0, 0, 0, 0,22, 0,19,
+ 20,17,17, 0, 0, 0, 0,22, 0, 0, 0,19,18, 0,19,19,
+ 15,16, 0,21,19,16,17, 0, 0,21,17,17, 0, 0,22,17,
+ 17, 0,22,22,18,19, 0,20,20,16,16, 0, 0,22,18,18,
+ 0,20,19,16,17, 0,22,21,20,19, 0, 0,21,17,17, 0,
+ 21,20,17,17, 0, 0, 0,18,18, 0,19,19,17,16, 0,22,
+ 0,19,19, 0,21,22,17,18, 0, 0,22,19,18, 0, 0, 0,
+ 19,20, 0,19,19,16,16, 0,22,22,22, 0, 0,20,22,16,
+ 16, 0,22,20,18,19, 0, 0, 0,20,19, 0,20,20,16,16,
+ 0, 0, 0, 0, 0, 0,22,20,17,16, 0,11,11,13,13, 0,
+ 14,13,15,15, 0,13,13,16,15, 0,18,17,21, 0, 0,18,
+ 18,21, 0, 0,12,12,15,15, 0,15,16,17,18, 0,12,12,
+ 15,15, 0,17,17,22,20, 0,17,18,22, 0, 0,12,12,17,
+ 16, 0,16,17,19,19, 0,13,13,16,16, 0,17,17, 0,22,
+ 0,17,17, 0,21, 0,18,18,20,22, 0, 0, 0, 0, 0, 0,
+ 15,15,21,20, 0,20,19, 0, 0, 0,18,18,22, 0, 0,17,
+ 17,22, 0, 0, 0, 0, 0, 0, 0,15,16,20,22, 0,20,21,
+ 0, 0, 0,19,18, 0, 0, 0,15,15,19,19, 0,17,16,20,
+ 20, 0,16,17,20,21, 0,18,17, 0, 0, 0,19,19, 0, 0,
+ 0,15,15,21,19, 0,19,19, 0, 0, 0,15,15,22,22, 0,
+ 18,18, 0,22, 0,17,18,22,21, 0,15,15,20,19, 0,19,
+ 19, 0, 0, 0,15,15,20,22, 0,18,19,20, 0, 0,18,17,
+ 21,21, 0,18,18,19,22, 0, 0, 0, 0, 0, 0,15,15,20,
+ 19, 0,19,19, 0, 0, 0,18,18,21,22, 0,18,18,22, 0,
+ 0, 0, 0, 0, 0, 0,15,15,19,20, 0,21,21, 0, 0, 0,
+ 17,17,20,20, 0,12,12,17,17, 0,14,14,16,17, 0,13,
+ 14,17,17, 0,16,16,17,17, 0,17,17,17,19, 0,13,13,
+ 17,17, 0,16,16,18,18, 0,13,13,16,16, 0,16,16,18,
+ 18, 0,16,16,17,17, 0,13,13,17,17, 0,17,17,18,17,
+ 0,12,12,15,16, 0,17,18,19,20, 0,16,16,16,16, 0,
+ 17,16,18,19, 0, 0,22,21,22, 0,14,14,16,16, 0,19,
+ 19, 0, 0, 0,16,16,16,16, 0,16,16,18,17, 0, 0,22,
+ 21,21, 0,14,14,16,16, 0,22,20,22, 0, 0,16,16,15,
+ 15, 0, 9, 9,13,13, 0,14,14,15,15, 0,14,14,14,14,
+ 0,22,22,18,18, 0, 0,22,18,18, 0,12,12,15,15, 0,
+ 16,16,18,17, 0,14,14,14,14, 0,20,21,18,18, 0,22,
+ 21,17,17, 0,13,13,15,15, 0,17,17,18,18, 0,14,14,
+ 14,14, 0, 0,21,18,19, 0, 0,22,17,17, 0,22,22,19,
+ 18, 0, 0, 0, 0, 0, 0,19,21,17,17, 0, 0, 0,22,20,
+ 0, 0,21,18,19, 0, 0,22,18,18, 0, 0, 0, 0,22, 0,
+ 20,22,17,17, 0, 0, 0,20,22, 0, 0, 0,18,18, 0,19,
+ 21,16,16, 0,20,22,16,17, 0,20, 0,17,17, 0,22, 0,
+ 18,17, 0,21, 0,18,19, 0,20,20,17,17, 0,22, 0,18,
+ 18, 0,21,20,17,17, 0, 0,20,20,19, 0, 0,21,18,17,
+ 0,21,21,17,17, 0,22, 0,18,17, 0,19,19,17,17, 0,
+ 0,22,20,21, 0, 0,21,17,17, 0,22, 0,18,18, 0, 0,
+ 0,20,22, 0,20,19,16,16, 0, 0, 0, 0, 0, 0,22,22,
+ 17,17, 0,22, 0,18,19, 0, 0, 0,21,20, 0,19,21,16,
+ 17, 0, 0, 0, 0, 0, 0,22,22,17,16, 0,11,11,13,13,
+ 0,13,13,15,15, 0,13,13,15,15, 0,17,17,22,21, 0,
+ 18,18,22, 0, 0,12,13,16,15, 0,15,16,18,18, 0,13,
+ 13,16,16, 0,17,17, 0,22, 0,17,17,22,22, 0,13,13,
+ 16,16, 0,16,16,19,18, 0,13,13,16,16, 0,18,17, 0,
+ 20, 0,18,17,20, 0, 0,17,17,21, 0, 0, 0, 0, 0, 0,
+ 0,15,15,21,22, 0,19,20, 0, 0, 0,18,18, 0, 0, 0,
+ 18,17, 0, 0, 0, 0, 0, 0, 0, 0,16,16,22,22, 0,20,
+ 20, 0, 0, 0,21,19, 0, 0, 0,15,15,20,19, 0,16,16,
+ 22,20, 0,17,17, 0,22, 0,18,18, 0,22, 0,19,17, 0,
+ 0, 0,15,16,22,20, 0,18,19, 0, 0, 0,16,16,22,20,
+ 0,18,18, 0,22, 0,18,18,22, 0, 0,16,16,21,20, 0,
+ 19,20, 0,22, 0,16,16, 0,22, 0,18,18, 0,22, 0,18,
+ 18, 0,21, 0,19,18, 0,22, 0, 0, 0, 0, 0, 0,16,16,
+ 21,20, 0,20, 0, 0, 0, 0,18,18,21, 0, 0,18,18, 0,
+ 0, 0, 0, 0, 0, 0, 0,16,16,21,19, 0, 0, 0, 0, 0,
+ 0,18,18, 0,21,
+};
+
+static const static_codebook _44p3_p5_0 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p3_p5_0,
+ 1, -528744448, 1616642048, 3, 0,
+ (long *)_vq_quantlist__44p3_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44p3_p5_1[] = {
+ 3,
+ 2,
+ 4,
+ 1,
+ 5,
+ 0,
+ 6,
+};
+
+static const long _vq_lengthlist__44p3_p5_1[] = {
+ 2, 3, 3, 3, 3, 3, 3,
+};
+
+static const static_codebook _44p3_p5_1 = {
+ 1, 7,
+ (long *)_vq_lengthlist__44p3_p5_1,
+ 1, -533200896, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p3_p5_1,
+ 0
+};
+
+static const long _vq_quantlist__44p3_p6_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p3_p6_0[] = {
+ 1, 6, 6, 7, 7, 7, 7, 8, 8, 7, 9, 9,11,11,11, 9,
+ 8, 8, 8, 9, 9,12,11,11, 9, 8, 8, 6, 7, 7,10,11,
+ 10,10,10,10,11,11,10,14,13,14,12,11,11,11,11,11,
+ 15,14,14,13,12,12, 5, 6, 6, 8, 5, 5, 8, 7, 7, 8,
+ 8, 8,12,10,10, 9, 7, 7, 9, 7, 8,12,10,10,10, 7,
+ 7, 7, 8, 8,12,10,10,12,10,10,11,10,10,15,13,13,
+ 13,10,10,11,10,10,16,13,14,14,10,10, 7, 7, 7,12,
+ 11,11,12,11,11,11,11,11,16,15,15,14,12,12,12,11,
+ 11,16,15,16,14,12,12,10, 9, 9,14,11,11,13,11,11,
+ 12,11,11,16,14,14,14,11,11,12,11,11,17,15,15,14,
+ 11,11, 7, 8, 8,12,11,11,12,10,10,12,10,10,16,14,
+ 13,14,10,10,12,10,10,17,14,14,14,10,10, 8, 7, 7,
+ 13,11,11,12,11,11,12,11,11,16,15,14,14,12,12,12,
+ 11,11,16,15,14,15,12,12,11,10,10,13,11,11,13,12,
+ 11,13,11,11,17,14,14,14,11,11,13,11,11,17,14,15,
+ 14,11,11,
+};
+
+static const static_codebook _44p3_p6_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p3_p6_0,
+ 1, -527106048, 1620377600, 2, 0,
+ (long *)_vq_quantlist__44p3_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44p3_p6_1[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p3_p6_1[] = {
+ 2, 6, 6, 7, 7, 7, 7, 7, 7, 7, 8, 8, 9, 9, 9, 9,
+ 7, 7, 8, 8, 8, 9, 9, 9, 9, 7, 8, 6, 7, 7, 8, 8,
+ 8, 8, 8, 8, 9, 8, 8,10, 9, 9,10, 8, 8,10, 8, 8,
+ 10, 9, 9,10, 8, 8, 6, 6, 6, 8, 6, 6, 8, 7, 7, 8,
+ 7, 7,10, 8, 8, 9, 7, 7, 9, 7, 7,10, 8, 9, 9, 7,
+ 7, 7, 7, 7,10, 8, 8,11, 8, 8,10, 8, 8,12, 9, 9,
+ 12, 8, 8,11, 9, 9,12, 9, 9,11, 8, 8, 7, 7, 7,10,
+ 9, 9,10, 9, 9,10, 9, 9,11,10,10,10, 9, 9,11, 9,
+ 9,11,10,10,11, 9, 9, 9, 8, 8,10, 9, 9,10, 9, 9,
+ 11, 9, 9,11,10,10,11, 9, 9,11, 9, 9,11,10,10,11,
+ 9, 9, 8, 8, 8,11, 9, 9,11, 9, 9,11, 9, 9,12, 9,
+ 9,12, 8, 8,12, 9, 9,12, 9, 9,12, 8, 8, 8, 7, 7,
+ 10, 9, 9,10, 9, 9,11, 9, 9,11,11,11,11, 9, 9,11,
+ 10,10,11,11,11,11, 9, 9,10, 9, 9,11, 9, 9,11, 9,
+ 10,11,10, 9,11,10,10,11, 9, 9,11, 9,10,11,10,10,
+ 11, 9, 9,
+};
+
+static const static_codebook _44p3_p6_1 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p3_p6_1,
+ 1, -530841600, 1616642048, 2, 0,
+ (long *)_vq_quantlist__44p3_p6_1,
+ 0
+};
+
+static const long _vq_quantlist__44p3_p7_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p3_p7_0[] = {
+ 1, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9,
+};
+
+static const static_codebook _44p3_p7_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p3_p7_0,
+ 1, -513979392, 1633504256, 2, 0,
+ (long *)_vq_quantlist__44p3_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44p3_p7_1[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p3_p7_1[] = {
+ 1, 9, 9, 6, 9, 9, 5, 9, 9, 8, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 8, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 8, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 7, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 8, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,
+};
+
+static const static_codebook _44p3_p7_1 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p3_p7_1,
+ 1, -516716544, 1630767104, 2, 0,
+ (long *)_vq_quantlist__44p3_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44p3_p7_2[] = {
+ 12,
+ 11,
+ 13,
+ 10,
+ 14,
+ 9,
+ 15,
+ 8,
+ 16,
+ 7,
+ 17,
+ 6,
+ 18,
+ 5,
+ 19,
+ 4,
+ 20,
+ 3,
+ 21,
+ 2,
+ 22,
+ 1,
+ 23,
+ 0,
+ 24,
+};
+
+static const long _vq_lengthlist__44p3_p7_2[] = {
+ 1, 3, 2, 5, 4, 7, 7, 8, 8, 9, 9,10,10,11,11,12,
+ 12,13,13,14,14,15,15,15,15,
+};
+
+static const static_codebook _44p3_p7_2 = {
+ 1, 25,
+ (long *)_vq_lengthlist__44p3_p7_2,
+ 1, -518864896, 1620639744, 5, 0,
+ (long *)_vq_quantlist__44p3_p7_2,
+ 0
+};
+
+static const long _vq_quantlist__44p3_p7_3[] = {
+ 12,
+ 11,
+ 13,
+ 10,
+ 14,
+ 9,
+ 15,
+ 8,
+ 16,
+ 7,
+ 17,
+ 6,
+ 18,
+ 5,
+ 19,
+ 4,
+ 20,
+ 3,
+ 21,
+ 2,
+ 22,
+ 1,
+ 23,
+ 0,
+ 24,
+};
+
+static const long _vq_lengthlist__44p3_p7_3[] = {
+ 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5,
+};
+
+static const static_codebook _44p3_p7_3 = {
+ 1, 25,
+ (long *)_vq_lengthlist__44p3_p7_3,
+ 1, -529006592, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44p3_p7_3,
+ 0
+};
+
+static const long _huff_lengthlist__44p3_short[] = {
+ 4, 5,16, 9, 9,12,17,18, 4, 2,18, 6, 5, 9,13,15,
+ 10, 7, 7, 6, 7, 9,13,13, 8, 5, 6, 5, 5, 7,11,12,
+ 8, 4, 7, 4, 3, 6,10,12,11, 8, 9, 7, 6, 8,11,12,
+ 15,13,13,11, 9, 7,10,12,16,12,16,12, 6, 5, 8,11,
+};
+
+static const static_codebook _huff_book__44p3_short = {
+ 2, 64,
+ (long *)_huff_lengthlist__44p3_short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44p4_l0_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44p4_l0_0[] = {
+ 1, 4, 4, 8, 8, 9, 8, 9, 9,10,10,10,10, 4, 6, 5,
+ 8, 7, 9, 9, 9, 9,10, 9,10,10, 4, 5, 6, 7, 8, 9,
+ 9, 9, 9, 9,10, 9,10, 8, 9, 8, 9, 8,10, 9,11, 9,
+ 12,10,11,10, 8, 8, 9, 8, 9, 9,10, 9,11,10,11,10,
+ 12, 9,10,10,11,10,11,11,12,11,12,12,12,12, 9,10,
+ 10,11,11,11,11,11,12,12,12,12,12,10,11,11,12,12,
+ 12,12,12,12,12,12,12,12,10,11,11,12,12,12,12,12,
+ 12,12,12,12,12,11,12,12,12,12,12,12,12,12,12,13,
+ 12,12,11,12,11,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,13,12,12,12,12,12,12,11,13,12,12,
+ 12,13,12,12,12,12,12,12,12,
+};
+
+static const static_codebook _44p4_l0_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44p4_l0_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44p4_l0_0,
+ 0
+};
+
+static const long _vq_quantlist__44p4_l0_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p4_l0_1[] = {
+ 3, 4, 4, 5, 5, 4, 4, 5, 5, 5, 4, 5, 4, 5, 5, 5,
+ 5, 6, 5, 6, 5, 6, 5, 6, 5,
+};
+
+static const static_codebook _44p4_l0_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44p4_l0_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p4_l0_1,
+ 0
+};
+
+static const long _vq_quantlist__44p4_l1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p4_l1_0[] = {
+ 1, 4, 4, 4, 4, 4, 4, 4, 4,
+};
+
+static const static_codebook _44p4_l1_0 = {
+ 2, 9,
+ (long *)_vq_lengthlist__44p4_l1_0,
+ 1, -516716544, 1630767104, 2, 0,
+ (long *)_vq_quantlist__44p4_l1_0,
+ 0
+};
+
+static const long _huff_lengthlist__44p4_lfe[] = {
+ 1, 3, 2, 3,
+};
+
+static const static_codebook _huff_book__44p4_lfe = {
+ 2, 4,
+ (long *)_huff_lengthlist__44p4_lfe,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44p4_long[] = {
+ 3, 5,13, 9, 9,12,16,18, 4, 2,20, 6, 7,10,15,20,
+ 10, 7, 5, 5, 6, 8,10,13, 8, 5, 5, 3, 5, 7,10,11,
+ 9, 7, 6, 5, 5, 7, 9, 9,11,10, 8, 7, 6, 6, 8, 8,
+ 15,15,10,10, 9, 7, 8, 9,17,19,13,12,10, 8, 9, 9,
+};
+
+static const static_codebook _huff_book__44p4_long = {
+ 2, 64,
+ (long *)_huff_lengthlist__44p4_long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44p4_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p4_p1_0[] = {
+ 1, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0,
+};
+
+static const static_codebook _44p4_p1_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p4_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44p4_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44p4_p2_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p4_p2_0[] = {
+ 3, 9, 9, 0, 0, 0, 8, 8, 0, 0, 0, 9, 9, 0, 0, 0,
+ 12,12, 0, 0, 0, 0, 0, 0, 0, 0,10,10, 0, 0, 0, 0,
+ 0, 0, 0, 0, 9, 9, 0, 0, 0,11,11, 0, 0, 0, 0, 0,
+ 0, 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0,
+ 0, 0,11,11, 0, 0, 0, 0, 0, 0, 0, 0,12,12, 0, 0,
+ 0, 0, 0, 0, 0, 0,11,11, 0, 0, 0,12,12, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7, 0, 0, 0,
+ 5, 5, 0, 0, 0, 7, 7, 0, 0, 0, 9, 9, 0, 0, 0, 0,
+ 0, 0, 0, 0, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5,
+ 0, 0, 0, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7, 0,
+ 0, 0, 0, 0, 0, 0, 0, 5, 5, 0, 0, 0, 7, 7, 0, 0,
+ 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0,
+ 7, 7, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,11,11, 0, 0, 0, 9, 9, 0,
+ 0, 0,10,10, 0, 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0,
+ 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0,
+ 10,10, 0, 0, 0, 0, 0, 0, 0, 0,10,10, 0, 0, 0, 0,
+ 0, 0, 0, 0, 9, 9, 0, 0, 0,10,10, 0, 0, 0, 0, 0,
+ 0, 0, 0,12,12, 0, 0, 0, 0, 0, 0, 0, 0,11,11, 0,
+ 0, 0,12,12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 9, 9, 0, 0, 0, 7, 7, 0, 0, 0, 8, 8, 0, 0,
+ 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 0, 0, 0,
+ 0, 0, 0, 0, 0, 7, 7, 0, 0, 0, 9, 9, 0, 0, 0, 0,
+ 0, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8,
+ 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0,10,10, 0,
+ 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0,11,11, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
+ 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,10,10, 0, 0, 0, 7, 7,
+ 0, 0, 0, 9, 9, 0, 0, 0,10,10, 0, 0, 0, 0, 0, 0,
+ 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 0, 0,
+ 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0,
+ 0, 0, 0, 0, 0, 8, 8, 0, 0, 0, 9, 9, 0, 0, 0, 0,
+ 0, 0, 0, 0,11,11, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9,
+ 0, 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 9, 9, 0, 0, 0, 7, 7, 0, 0, 0, 8, 8, 0,
+ 0, 0,10,11, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0,
+ 0, 0, 0, 0, 0, 0, 8, 8, 0, 0, 0, 9, 9, 0, 0, 0,
+ 0, 0, 0, 0, 0, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 7,
+ 7, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0,11,11,
+ 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0,10,10, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,10,10, 0, 0, 0, 7,
+ 7, 0, 0, 0, 9, 9, 0, 0, 0,10,10, 0, 0, 0, 0, 0,
+ 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 0,
+ 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0,
+ 0, 0, 0, 0, 0, 0, 8, 8, 0, 0, 0, 9, 9, 0, 0, 0,
+ 0, 0, 0, 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 9,
+ 9, 0, 0, 0,11,11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0,10,10, 0, 0, 0, 9, 9, 0, 0, 0,10,10,
+ 0, 0, 0,11,11, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0,
+ 0, 0, 0, 0, 0, 0, 0, 8, 8, 0, 0, 0,10,10, 0, 0,
+ 0, 0, 0, 0, 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0,
+ 9, 9, 0, 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0,11,
+ 11, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0,12,12,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,10,10, 0, 0, 0,
+ 9, 9, 0, 0, 0,10,10, 0, 0, 0,12,12, 0, 0, 0, 0,
+ 0, 0, 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9,
+ 0, 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0,10,10, 0,
+ 0, 0, 0, 0, 0, 0, 0, 8, 8, 0, 0, 0,10,10, 0, 0,
+ 0, 0, 0, 0, 0, 0,11,11, 0, 0, 0, 0, 0, 0, 0, 0,
+ 10,10, 0, 0, 0,11,11, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+};
+
+static const static_codebook _44p4_p2_0 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p4_p2_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p4_p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44p4_p3_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p4_p3_0[] = {
+ 1, 6, 6, 5, 7, 8, 0, 8, 8, 6, 9, 9, 7,10,10, 0,
+ 8, 8, 0, 9, 9, 0,12,12, 0, 8, 8, 4, 7, 7, 6,10,
+ 10, 0,12,12, 7,11,11, 8,12,12, 0,12,12, 0,13,12,
+ 0,15,15, 0,12,12, 0, 7, 7, 0, 7, 7, 0, 7, 7, 0,
+ 8, 8, 0,10,10, 0, 7, 7, 0, 8, 8, 0,11,11, 0, 7,
+ 7, 5, 7, 7, 8, 9, 9, 0,10,10, 8, 9, 9,11,11,11,
+ 0,10, 9, 0,11,11, 0,13,13, 0,10,10, 6, 7, 7, 8,
+ 10,10, 0,12,12, 9,10,10,10,12,12, 0,12,12, 0,12,
+ 12, 0,15,15, 0,12,12, 0,10,10, 0,11,11, 0,11,11,
+ 0,11,11, 0,13,13, 0,11,11, 0,11,11, 0,15,15, 0,
+ 10,10, 0, 8, 8, 0,10,10, 0,12,12, 0,11,11, 0,12,
+ 12, 0,12,12, 0,12,12, 0,15,15, 0,11,11, 0, 7, 7,
+ 0,10,10, 0,12,12, 0,10,10, 0,12,12, 0,12,12, 0,
+ 13,13, 0,14,14, 0,12,12, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0,
+};
+
+static const static_codebook _44p4_p3_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p4_p3_0,
+ 1, -533200896, 1614282752, 2, 0,
+ (long *)_vq_quantlist__44p4_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44p4_p3_1[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p4_p3_1[] = {
+ 3, 5, 5, 0, 8, 8, 0, 8, 8, 0, 9, 9, 0,10,10, 0,
+ 8, 8, 0, 8, 8, 0,10,10, 0, 8, 8, 0, 7, 7, 0, 8,
+ 8, 0, 7, 7, 0, 8, 8, 0, 8, 8, 0, 8, 8, 0, 8, 8,
+ 0, 8, 8, 0, 8, 8, 0, 7, 7, 0, 6, 6, 0, 7, 7, 0,
+ 7, 7, 0,10,10, 0, 6, 6, 0, 7, 7, 0,10,10, 0, 5,
+ 5, 0, 8, 8, 0, 7, 7, 0, 8, 8, 0, 8, 8, 0, 9, 9,
+ 0, 7, 7, 0, 8, 8, 0, 9, 9, 0, 7, 7, 0, 6, 6, 0,
+ 9,10, 0,10,10, 0,10,10, 0,11,11, 0, 9, 9, 0,10,
+ 10, 0,11,11, 0, 9, 9, 0, 8, 8, 0, 8, 8, 0, 8, 8,
+ 0, 9, 9, 0, 9, 9, 0, 7, 7, 0, 8, 8, 0, 9, 9, 0,
+ 7, 7, 0, 8, 8, 0, 7, 7, 0, 7, 7, 0, 8, 8, 0, 9,
+ 9, 0, 7, 7, 0, 7, 7, 0, 8, 8, 0, 6, 6, 0, 6, 6,
+ 0,10,10, 0,10,10, 0,10,10, 0,12,12, 0, 9, 9, 0,
+ 10,10, 0,12,12, 0, 9, 9, 0, 8, 8, 0, 7, 7, 0, 7,
+ 7, 0, 8, 8, 0, 9, 9, 0, 7, 7, 0, 8, 8, 0, 9, 9,
+ 0, 6, 6,
+};
+
+static const static_codebook _44p4_p3_1 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p4_p3_1,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44p4_p3_1,
+ 0
+};
+
+static const long _vq_quantlist__44p4_p4_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p4_p4_0[] = {
+ 1, 6, 6, 6, 7, 7, 7, 8, 8, 7, 8, 8,10,11,11, 9,
+ 8, 8, 8, 8, 8,11,11,12, 9, 8, 8, 5, 7, 7, 9,11,
+ 11,10,11,11,10,11,11,12,14,14,11,12,12,10,12,12,
+ 13,14,14,12,12,12, 5, 6, 6, 7, 6, 6, 8, 7, 7, 8,
+ 7, 7,11,10,10,10, 7, 7, 9, 8, 8,12,11,11,10, 7,
+ 7, 7, 7, 7,11,10,10,12,10,10,11,10,10,15,13,13,
+ 13,10,10,12,11,11,15,13,13,14,11,11, 7, 7, 7,11,
+ 11,11,12,11,11,12,11,11,14,14,14,13,12,12,12,12,
+ 12,16,15,15,14,12,12, 0,10,10, 0,11,11, 0,12,12,
+ 0,11,11, 0,14,14, 0,11,11, 0,12,12, 0,15,15, 0,
+ 11,11, 7, 8, 8,12,11,10,12,10,10,12,11,11,15,13,
+ 13,14,11,11,12,10,10,16,14,14,14,10,10, 8, 7, 7,
+ 12,11,11,12,11,11,12,11,11,15,14,14,14,12,12,13,
+ 12,12,15,14,14,15,13,13, 0,11,11, 0,12,12, 0,12,
+ 12, 0,12,12, 0,15,15, 0,12,12, 0,13,13, 0,15,14,
+ 0,12,12,
+};
+
+static const static_codebook _44p4_p4_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p4_p4_0,
+ 1, -531365888, 1616117760, 2, 0,
+ (long *)_vq_quantlist__44p4_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44p4_p4_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p4_p4_1[] = {
+ 4, 5, 5, 9, 9,12, 9, 9,12,12,12,10,10,13,13,13,
+ 11,11,12,12,13,13,13,12,12,13,10,10,13,13,13,13,
+ 13,13,13,13,10,10,13,12,13,11,11,13,13,13,14,14,
+ 13,12,13,10,10,13,13,12,13,13,13,13,13,10,10,12,
+ 12,13,11,11,13,13,13,14,14,12,12,13,12,12,13,13,
+ 13,13,13,13,13,13,11,11,12,12,13,11,11,13,13,13,
+ 14,14,12,12,13,14,14,13,13,14,13,13,14,14,14,14,
+ 14,12,12,13,14,14,13,13,14,14,14,12,12,12, 8, 8,
+ 12,12,13,12,12,11,11,13,11,11,11,11,14,12,12,11,
+ 11,14,12,12,10,11,14,12,12,12,12,14,12,12,12,12,
+ 13,13,13,11,11,14,12,12,11,11,14,12,12,12,12,14,
+ 12,12,12,12,14,12,12,12,12,14,13,13,11,11,14,12,
+ 12,11,11,14,12,12,12,12,14,13,13,12,12,14,12,12,
+ 12,12,14,13,13,11,11,14,12,12,11,11,14,13,13,11,
+ 11,15,13,13,12,12,14,12,12,12,12,15,13,13,12,12,
+ 14,12,12,11,11,15,13,13,11,11,12, 9, 9,11,11,13,
+ 7, 7,11,11,13, 8, 8,12,12,14,10,10,10,10,14,14,
+ 14,11,11,14, 8, 8,12,12,14,14,14,12,12,14, 7, 7,
+ 11,11,14, 9, 9,12,12,14,14,14,11,11,14, 8, 8,12,
+ 12,14,14,14,12,12,14, 7, 7,11,11,14, 9, 9,12,12,
+ 14,14,14,11,11,14,10,10,12,12,14,14,14,13,13,14,
+ 9, 9,11,11,14,10,10,12,11,15,14,14,11,11,14,15,
+ 15,12,12,15,14,14,14,14,15,14,14,11,11,15,14,14,
+ 12,12,15,14,14,11,11,14,11,11,10,10,15,10,10,10,
+ 10,15,10,10,10,10,15,11,11, 9, 9,15,12,13, 9, 9,
+ 15,11,11,11,11,15,13,13,11,11,15,10,10,10,10,15,
+ 11,11,10,10,15,13,13,11,11,15,11,11,11,11,15,13,
+ 13,11,11,15,10,10,10,10,15,11,11,10,10,15,13,13,
+ 10,11,15,12,12,11,11,15,13,13,11,10,15,11,11,10,
+ 10,15,11,12,10, 9,15,13,13,10,10,15,14,14,11,11,
+ 15,13,13,11,11,15,14,14,10,10,15,13,13,10,10,15,
+ 14,14,10,10,14,13,13,10,10,15,13,13,10,10,15,13,
+ 13,10,10,14,14,14, 8, 9,15,14,14, 9, 9,15,14,14,
+ 11,11,15,14,14,10,10,15,14,14,10,10,15,14,14,11,
+ 11,15,14,14,10,10,15,14,14,11,11,15,14,14,10,10,
+ 15,14,14,10,10,15,14,14,10,10,15,14,14, 9, 9,15,
+ 14,14,11,11,15,14,14,11,11,15,14,14,10,10,15,14,
+ 14,10,10,14,14,14, 9, 9,15,15,15,11,11,15,14,14,
+ 12,12,15,15,15,10,10,15,14,15,10,10,15,15,15, 9,
+ 9,15,10,10,13,13,17, 8, 8,12,12,17,10, 9,13,13,
+ 18,11,11,12,12,18,14,14,12,12,17, 9, 9,13,13,17,
+ 13,13,12,12,18, 8, 8,12,12,18,10,10,12,12,18,14,
+ 14,12,12,18,10,10,13,13,18,13,13,13,13,18, 9, 9,
+ 12,12,18,10,10,13,13,18,14,14,12,12,18,11,11,13,
+ 13,18,14,14,13,13,18,10,10,12,12,17,11,11,12,12,
+ 18,14,14,12,12,18,14,14,13,13,18,14,14,13,13,19,
+ 14,15,12,12,18,14,14,12,12,18,15,15,12,12,13, 7,
+ 7,11,11,14,15,15,11,11,14,16,15,11,11,14,15,15,
+ 11,11,14,15,15,11,11,14,15,15,11,12,14,15,15,12,
+ 12,13,15,15,11,11,14,15,15,11,11,15,15,15,12,12,
+ 14,15,15,12,12,14,16,16,12,12,14,15,15,11,11,14,
+ 15,15,11,11,15,15,15,12,12,15,15,15,12,12,14,15,
+ 15,12,12,14,15,15,11,11,14,15,15,11,11,15,14,15,
+ 12,12,15,15,15,12,12,15,16,16,12,12,15,15,15,12,
+ 12,14,15,15,12,12,15,15,15,12,12,13,13,13,11,11,
+ 14,14,15,11,11,14,14,14,12,12,14,15,15,10,10,15,
+ 15,15,11,11,14,15,15,12,12,14,14,14,11,11,14,15,
+ 15,11,11,14,15,15,12,12,15,15,15,11,11,14,15,15,
+ 12,12,14,14,15,11,11,14,15,15,11,11,14,15,15,12,
+ 12,15,15,15,11,11,15,15,15,12,12,14,15,15,12,12,
+ 14,15,15,10,10,14,15,15,11,11,15,15,15,10,10,15,
+ 15,15,12,12,15,15,15,14,14,15,15,15,11,11,15,15,
+ 15,11,11,15,15,15,11,11,14,10,10,10,10,15, 9, 9,
+ 12,11,15,10,10,12,12,15,11,11,11,11,15,13,13,12,
+ 12,16,10,10,12,12,15,13,13,12,12,15, 9, 9,11,11,
+ 15,10,10,13,12,15,13,13,11,11,15,10,10,12,12,15,
+ 13,13,12,12,15, 9, 9,11,11,15,10,10,12,12,15,13,
+ 13,11,11,15,11,11,12,12,15,13,13,13,13,15,10,10,
+ 11,11,15,11,11,12,12,15,13,14,11,11,15,14,14,13,
+ 13,16,14,14,20,19,15,14,14,11,11,15,13,14,12,12,
+ 15,14,14,11,11,14,13,13,10,10,14,14,13,11,11,15,
+ 13,14,12,12,15,14,14,12,12,15,14,14,11,11,15,14,
+ 14,12,12,15,15,14,13,13,15,14,14,11,11,15,14,14,
+ 11,11,15,14,14,13,13,15,14,14,12,12,15,14,14,13,
+ 13,15,14,14,11,11,15,14,14,11,11,15,14,14,13,13,
+ 15,14,14,12,12,15,14,14,12,12,15,14,14,12,12,15,
+ 14,14,11,11,15,15,15,12,12,15,15,15,13,13,16,14,
+ 14,12,12,15,15,15,13,13,15,15,15,12,12,15,15,15,
+ 12,12,14,10,10,13,13,17, 9, 9,12,12,17, 9, 9,13,
+ 13,17,11,11,12,12,18,14,14,12,12,18,10,10,13,13,
+ 18,14,13,12,12,18, 9, 9,12,12,18,10,10,12,13,18,
+ 14,14,12,12,17, 9, 9,12,12,17,13,14,12,12,17, 9,
+ 9,12,12,17,10,10,12,12,17,14,14,11,11,18,11,11,
+ 12,12,18,14,14,12,13,18,10,10,12,12,18,11,11,12,
+ 12,18,14,14,11,11,18,15,15,12,12,18,14,14,13,13,
+ 18,14,15,12,12,17,14,14,12,12,17,15,15,12,12,13,
+ 7, 7,11,11,14,15,15,11,11,14,15,15,11,11,14,15,
+ 15,11,11,14,15,15,11,11,14,15,15,11,11,14,15,15,
+ 12,12,14,15,15,11,11,14,15,15,11,11,15,15,15,12,
+ 12,14,15,15,11,11,14,15,15,12,12,14,15,15,11,11,
+ 15,15,15,11,11,15,15,15,12,12,14,15,15,12,12,14,
+ 15,16,12,12,14,15,15,11,11,14,15,15,11,11,15,15,
+ 15,12,12,15,15,15,12,12,15,16,16,12,12,15,15,15,
+ 12,12,15,15,15,12,12,15,15,15,12,12,13,13,13,12,
+ 12,14,14,14,11,11,14,14,14,12,12,14,14,14,10,10,
+ 15,15,15,11,11,14,15,15,12,12,14,14,14,11,11,14,
+ 15,15,11,11,14,14,14,12,12,15,15,14,11,11,14,15,
+ 15,12,12,14,14,14,11,11,14,15,15,11,11,14,14,14,
+ 11,11,15,14,14,10,10,14,15,15,12,12,14,14,14,12,
+ 12,14,15,15,10,10,14,15,15,11,11,15,15,15,10,10,
+ 15,15,15,12,12,15,14,14,13,13,15,15,15,10,10,15,
+ 14,14,11,11,15,15,15,10,10,14,10,10,10,10,14, 9,
+ 9,12,12,15,10,10,12,12,14,11,11,11,11,15,13,14,
+ 12,12,15,10,10,13,13,15,13,13,12,12,15, 9, 9,12,
+ 12,15,10,10,13,13,15,13,14,11,11,15,10,10,12,12,
+ 15,13,13,12,12,15, 9, 9,11,11,15,10,10,12,12,15,
+ 13,13,11,11,15,11,11,12,12,15,13,13,13,13,15,10,
+ 10,11,11,15,11,11,12,12,15,14,14,11,11,15,14,14,
+ 13,13,15,14,14,20,19,15,14,14,11,11,15,14,14,12,
+ 12,15,14,14,11,11,14,13,13,11,11,15,13,13,11,11,
+ 15,14,13,12,12,15,14,14,11,12,15,14,14,11,11,15,
+ 14,14,12,12,14,14,14,13,13,15,14,14,11,11,15,14,
+ 14,11,11,15,14,14,13,13,15,14,14,12,12,15,14,14,
+ 13,13,14,14,14,11,11,15,14,14,11,11,15,14,14,13,
+ 13,15,14,14,12,12,15,14,14,12,12,15,14,14,12,12,
+ 15,14,14,11,11,14,14,14,12,12,15,15,15,13,13,16,
+ 14,14,12,12,15,15,15,13,13,15,14,14,12,12,15,15,
+ 15,12,12,15,11,11,13,13,18,10,10,12,12,17,11,11,
+ 12,12,18,12,12,11,11,18,14,14,12,12,18,10,10,13,
+ 13,18,14,14,12,12,18,10,10,12,12,18,11,11,12,12,
+ 18,14,14,12,12,18,11,11,12,13,18,14,14,12,12,18,
+ 10,10,12,12,18,11,11,12,12,18,14,14,11,11,18,11,
+ 11,12,12,18,14,14,12,12,17,10,10,11,11,17,12,12,
+ 11,11,17,14,14,11,11,18,15,15,12,12,18,14,14,13,
+ 13,18,15,15,11,11,18,15,14,12,12,18,15,15,11,11,
+ 14, 8, 8,11,11,14,15,15,10,10,14,15,15,11,11,14,
+ 15,15,11,11,15,15,15,12,12,15,15,15,11,11,15,15,
+ 15,12,12,14,15,15,10,10,15,15,15,11,11,15,15,15,
+ 12,12,15,15,15,11,11,15,15,15,13,13,14,15,15,10,
+ 10,15,15,15,11,11,15,15,15,12,12,15,15,15,12,12,
+ 15,16,16,12,12,15,14,14,11,11,15,15,15,11,11,15,
+ 15,15,12,12,16,15,15,13,13,15,16,16,13,13,16,15,
+ 15,12,12,15,15,15,12,12,15,15,15,12,12,14,13,13,
+ 11,11,14,14,14,11,11,14,14,14,12,12,15,14,14,11,
+ 11,15,15,14,11,11,15,14,14,12,12,15,14,14,12,12,
+ 14,15,15,11,11,15,14,14,12,12,15,14,14,11,11,15,
+ 14,15,12,12,15,14,14,12,12,14,15,15,11,11,15,14,
+ 14,11,11,15,14,14,11,11,15,15,14,12,12,15,14,14,
+ 12,12,15,15,15,10,11,15,14,14,11,11,15,15,15,10,
+ 10,15,15,15,12,12,16,14,14,13,13,15,15,15,11,11,
+ 15,14,14,11,11,15,15,15,11,11,14,11,11, 9, 9,14,
+ 10,10,12,12,15,11,11,12,12,15,12,12,12,12,15,14,
+ 14,13,13,15,11,11,12,12,15,14,14,13,13,14,10,10,
+ 12,12,15,11,11,13,13,15,14,14,12,12,15,10,10,12,
+ 12,14,14,14,13,13,14,10,10,11,11,15,11,11,12,12,
+ 15,14,14,12,12,15,12,12,13,13,15,14,14,14,14,15,
+ 11,11,11,11,15,12,11,12,12,15,14,14,11,11,15,15,
+ 15,13,14,15,14,14,20,19,15,14,14,12,12,15,14,14,
+ 13,13,15,14,14,12,12,14,13,13,10,10,14,13,13,11,
+ 11,14,13,13,11,11,15,14,14,12,12,15,14,14,12,12,
+ 15,14,14,12,11,14,14,14,13,13,15,14,14,11,11,15,
+ 14,14,11,11,15,14,14,14,14,15,14,14,11,12,15,14,
+ 14,13,13,14,14,14,11,11,15,14,14,11,11,15,14,14,
+ 14,14,15,14,14,12,12,15,14,14,13,13,15,14,14,11,
+ 11,14,14,14,12,12,15,14,14,13,13,15,15,15,13,13,
+ 15,14,14,13,13,15,15,15,13,13,15,14,14,13,13,15,
+ 15,15,13,13,15,14,14,13,13,18,15,15,12,12,18,15,
+ 15,12,12,18,16,16,11,11,18,17,17,12,12,18,15,15,
+ 13,13,18,17,17,12,12,18,15,15,12,12,18,15,16,12,
+ 12,18,17,17,12,12,18,15,15,13,12,17,16,17,12,12,
+ 17,15,15,11,12,18,15,15,12,12,18,17,17,11,11,18,
+ 16,16,12,12,18,17,16,12,12,18,15,15,11,11,18,15,
+ 15,12,12,18,17,17,11,11,18,17,17,12,12,18,16,16,
+ 13,13,18,17,17,11,11,17,16,16,11,11,18,17,17,11,
+ 11,15,15,15,11,11,16,15,15,11,11,16,15,15,11,11,
+ 16,15,15,12,12,17,15,15,14,14,16,15,15,11,11,17,
+ 15,15,14,14,16,15,15,11,11,16,15,15,12,12,18,15,
+ 15,13,13,16,15,15,11,11,17,15,15,14,14,16,15,15,
+ 11,11,16,15,15,12,12,17,15,15,13,13,16,15,15,12,
+ 12,17,16,15,14,14,16,15,15,11,11,16,15,15,12,12,
+ 18,15,15,13,13,17,15,15,14,14,17,16,16,15,15,18,
+ 14,15,13,13,18,15,15,14,14,18,15,15,13,13,15,13,
+ 13,12,12,15,14,14,12,12,16,14,14,12,12,16,14,14,
+ 12,12,17,14,15,12,12,16,14,14,12,12,17,14,14,13,
+ 13,16,15,15,12,12,16,14,14,12,12,17,14,14,12,12,
+ 16,14,14,12,12,17,14,14,13,13,15,15,15,11,11,16,
+ 14,14,12,12,17,14,14,12,12,16,15,15,12,12,17,14,
+ 14,13,12,16,15,15,11,11,16,14,14,12,12,17,15,15,
+ 11,11,17,15,15,13,13,17,14,14,13,13,18,15,15,12,
+ 12,17,14,14,12,12,17,15,15,12,12,14,15,15, 9, 9,
+ 14,15,15,12,12,15,16,15,13,13,15,15,15,14,14,15,
+ 15,15,21,19,15,15,15,13,13,15,15,15,19,19,15,15,
+ 15,12,12,15,16,16,14,14,15,15,15,19,19,15,16,15,
+ 13,13,15,16,16,19,20,15,15,15,12,13,15,16,16,14,
+ 14,15,15,15,20,19,15,15,15,14,14,15,16,16,19,19,
+ 15,15,15,14,13,15,15,15,14,14,15,15,15,19,19,15,
+ 16,16,20,19,15,17,16,21,20,15,15,15,20,19,15,16,
+ 16,20,20,15,15,15,19,20,14,13,13,10,10,14,14,14,
+ 11,11,14,14,14,12,12,15,14,14,13,13,15,15,14,20,
+ 20,15,14,14,12,12,14,14,14,19,19,15,14,14,11,11,
+ 15,14,14,12,12,15,14,14,20,19,15,14,14,12,12,14,
+ 14,14,20,20,14,14,14,11,11,15,14,14,12,12,15,14,
+ 14,20,21,15,14,14,13,13,15,14,14,20,20,15,14,14,
+ 12,12,15,14,14,13,13,14,15,15,20,20,15,15,15,20,
+ 19,15,14,14,20,19,15,15,15,20,20,15,14,14,21,20,
+ 15,15,15,20,20,
+};
+
+static const static_codebook _44p4_p4_1 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p4_p4_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p4_p4_1,
+ 0
+};
+
+static const long _vq_quantlist__44p4_p5_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p4_p5_0[] = {
+ 1, 7, 6,15,15, 7, 8, 8,15,15, 8, 8, 8,15,15, 0,
+ 13,13,16,16, 0,14,14,16,16, 7, 9, 9,16,16,10,11,
+ 11,17,17,10, 8, 8,15,16, 0,14,14,18,18, 0,14,14,
+ 16,16, 9, 9, 9,16,16,12,11,11,17,17,10, 9, 9,15,
+ 15, 0,14,14,19,19, 0,14,14,16,16, 0,15,15,18,17,
+ 0, 0, 0,20,20, 0,13,13,16,16, 0,17,17,22,20, 0,
+ 15,15,17,17, 0,15,15,18,18, 0,22,21,20,21, 0,13,
+ 13,16,16, 0,18,18, 0,22, 0,15,15,17,17, 6, 7, 7,
+ 13,13, 9,10,10,15,15,11,10,10,15,15, 0,21,22,18,
+ 18, 0, 0, 0,18,18,10,10,10,15,15,12,13,13,17,17,
+ 12,11,11,15,15, 0,22,22,18,18, 0, 0,21,18,18,12,
+ 11,11,15,15,15,14,14,18,18,13,11,11,15,15, 0, 0,
+ 21,18,19, 0,21,22,18,19, 0,22, 0,18,19, 0, 0, 0,
+ 0, 0, 0,21,21,18,18, 0,22, 0, 0,21, 0, 0, 0,19,
+ 18, 0, 0, 0,18,19, 0, 0, 0, 0, 0, 0,20,20,18,17,
+ 0, 0,22, 0,21, 0, 0, 0,19,19, 6, 6, 6,13,13, 8,
+ 6, 6,11,11, 9, 7, 7,13,13, 0,10,10,11,11, 0,12,
+ 12,14,14, 9, 8, 8,14,14,12,10,10,13,13,10, 7, 7,
+ 13,13, 0,11,11,15,15, 0,11,11,13,13, 9, 8, 8,14,
+ 14,13,10,10,13,14,11, 7, 7,13,13, 0,11,11,15,15,
+ 0,11,11,13,13, 0,12,12,15,15, 0,21,21,17,17, 0,
+ 10,10,13,13, 0,14,14,20,20, 0,12,12,13,13, 0,12,
+ 12,15,15, 0,21,22,17,18, 0,10,10,13,13, 0,16,16,
+ 20,21, 0,12,12,13,13, 0,11,11,13,13, 0,12,12,16,
+ 16, 0,12,12,16,16, 0,16,16, 0,21, 0,17,18, 0, 0,
+ 0,12,12,15,15, 0,15,15,18,18, 0,12,12,16,16, 0,
+ 16,16,21,22, 0,17,17,22,21, 0,12,12,16,16, 0,15,
+ 15,19,19, 0,12,12,16,16, 0,16,16,22,22, 0,17,16,
+ 22, 0, 0,17,18, 0, 0, 0, 0, 0, 0, 0, 0,15,15,21,
+ 20, 0,19,20, 0,22, 0,18,18, 0, 0, 0,18,17, 0, 0,
+ 0, 0, 0, 0, 0, 0,16,16,22,21, 0,20,20, 0,22, 0,
+ 20,19, 0, 0, 0,11,11,12,12, 0,10,10,11,11, 0,11,
+ 11,12,12, 0,12,12,10,10, 0,13,13,12,12, 0,11,11,
+ 13,13, 0,13,13,12,12, 0,10,10,12,12, 0,13,13,14,
+ 13, 0,12,12,12,12, 0,12,12,13,13, 0,14,14,13,13,
+ 0,10,10,12,12, 0,13,13,14,14, 0,13,12,12,12, 0,
+ 14,14,14,14, 0,21,21,16,16, 0,12,12,12,12, 0,16,
+ 16,20,21, 0,13,13,11,11, 0,14,14,14,14, 0,20,20,
+ 16,15, 0,12,12,12,12, 0,17,17,20,20, 0,13,13,11,
+ 11, 7, 8, 8,16,16,11,10,10,15,15,12,10,10,17,17,
+ 0,14,14,16,15, 0,15,15,17,17,11, 9, 9,16,16,14,
+ 12,12,17,17,13, 9, 9,16,15, 0,14,14,19,18, 0,14,
+ 14,16,16,12,10,10,17,18,16,13,13,17,18,14,10,10,
+ 16,16, 0,14,14,19,19, 0,14,15,17,17, 0,15,15,18,
+ 19, 0, 0, 0,20,20, 0,13,13,17,17, 0,17,18, 0,22,
+ 0,15,15,16,17, 0,15,15,18,18, 0, 0, 0,20,21, 0,
+ 14,14,17,17, 0,19,18, 0, 0, 0,16,16,17,17, 8, 7,
+ 7,14,14,12,11,11,15,15,13,11,11,15,15, 0, 0, 0,
+ 18,19, 0,21,20,18,18,12,10,11,15,16,14,13,13,18,
+ 18,14,11,11,15,15, 0,20,20,19,18, 0,20, 0,18,18,
+ 13,11,11,16,16,17,15,15,19,19,14,12,12,15,15, 0,
+ 21, 0,18,20, 0,22,22,18,19, 0,22,22,19,19, 0, 0,
+ 0, 0, 0, 0,21,22,19,18, 0, 0, 0, 0,21, 0, 0, 0,
+ 19,19, 0, 0,22,20,20, 0, 0, 0, 0, 0, 0,22, 0,18,
+ 18, 0, 0, 0, 0,22, 0, 0, 0,19,20,11,10,10,14,14,
+ 14,11,11,13,13,14,11,11,15,15, 0,14,13,12,12, 0,
+ 15,15,16,16,13,11,11,15,15,16,13,13,15,15,15,10,
+ 10,14,15, 0,14,14,16,16, 0,14,14,15,15,13,11,11,
+ 15,15,18,14,14,15,15,15,10,10,15,14, 0,14,14,16,
+ 16, 0,14,14,15,15, 0,15,15,17,16, 0,21,22,18,18,
+ 0,13,13,14,14, 0,18,17,20,21, 0,15,15,14,14, 0,
+ 15,16,16,17, 0, 0, 0,19,18, 0,13,13,15,14, 0,19,
+ 19, 0, 0, 0,15,15,14,14, 0,12,12,14,13, 0,13,13,
+ 16,16, 0,12,12,16,16, 0,16,16,22, 0, 0,17,18, 0,
+ 22, 0,13,13,16,16, 0,15,15,18,18, 0,12,12,16,16,
+ 0,16,16,22,22, 0,17,17, 0, 0, 0,13,13,17,17, 0,
+ 16,16,19,20, 0,12,12,17,17, 0,17,17,22, 0, 0,17,
+ 17,22,21, 0,18,18, 0, 0, 0, 0, 0, 0, 0, 0,16,16,
+ 21,21, 0,19,19, 0, 0, 0,18,18, 0,22, 0,18,18, 0,
+ 22, 0, 0, 0, 0, 0, 0,16,16,22, 0, 0,20,20, 0, 0,
+ 0,19,18, 0, 0, 0,12,12,15,15, 0,12,12,15,14, 0,
+ 13,13,15,15, 0,14,14,14,14, 0,15,15,16,16, 0,13,
+ 13,15,16, 0,15,15,16,16, 0,12,12,15,15, 0,14,14,
+ 16,16, 0,14,14,15,15, 0,13,13,15,16, 0,15,15,16,
+ 16, 0,12,12,15,15, 0,15,15,17,17, 0,14,14,15,15,
+ 0,15,15,17,17, 0,21,21,19,19, 0,13,13,14,14, 0,
+ 17,17,22, 0, 0,14,14,15,15, 0,15,15,17,17, 0,22,
+ 0,18,20, 0,13,13,15,15, 0,18,18, 0,22, 0,15,15,
+ 14,15, 8, 8, 8,17,16,12,10,10,16,16,13,10,10,17,
+ 16, 0,15,15,17,17, 0,15,15,17,17,12,11,11,18,18,
+ 15,12,12,18,18,15,10,10,16,17, 0,14,14,18,18, 0,
+ 14,14,17,17,13,10,10,16,16,17,14,14,17,17,15,10,
+ 10,16,15, 0,15,15,19,20, 0,14,14,15,16, 0,16,16,
+ 19,19, 0, 0, 0,21,22, 0,13,13,17,17, 0,18,17, 0,
+ 21, 0,15,15,17,17, 0,15,15,18,19, 0, 0,22, 0,21,
+ 0,13,13,16,17, 0,19,19, 0,22, 0,16,15,16,16, 9,
+ 8, 8,14,14,12,11,11,15,15,13,11,11,15,15, 0,21,
+ 20,19,18, 0, 0, 0,19,18,12,11,11,16,15,15,13,13,
+ 17,18,14,11,11,15,15, 0,22,22,19,18, 0,22,21,18,
+ 18,14,11,11,15,15,17,14,14,18,18,15,12,12,15,15,
+ 0,22,22,20,19, 0, 0,21,18,18, 0, 0,22,20,20, 0,
+ 0, 0, 0, 0, 0,20,21,18,18, 0, 0, 0,21,21, 0, 0,
+ 0,20,19, 0,22,21,19,19, 0, 0, 0, 0, 0, 0, 0,22,
+ 17,18, 0, 0,22, 0,22, 0,22, 0,19,19, 0,11,11,15,
+ 15, 0,11,11,14,14, 0,12,12,15,15, 0,15,15,14,14,
+ 0,16,16,16,16, 0,12,12,16,16, 0,14,14,16,16, 0,
+ 11,11,15,15, 0,15,15,17,17, 0,15,15,15,15, 0,12,
+ 12,16,16, 0,14,14,15,15, 0,11,11,15,15, 0,15,15,
+ 17,17, 0,15,15,14,15, 0,16,16,17,17, 0, 0, 0,19,
+ 19, 0,14,14,15,15, 0,18,18,21, 0, 0,15,15,14,15,
+ 0,16,16,17,17, 0,21, 0,19,19, 0,14,14,15,15, 0,
+ 20,20,22, 0, 0,16,15,14,14, 0,12,12,13,13, 0,12,
+ 12,16,16, 0,12,12,16,16, 0,16,16,22,21, 0,18,17,
+ 21, 0, 0,13,13,16,16, 0,15,15,18,19, 0,12,12,16,
+ 16, 0,16,17,22, 0, 0,17,17, 0,22, 0,13,13,17,16,
+ 0,15,15,19,19, 0,12,12,16,16, 0,16,16,21,20, 0,
+ 17,16,22, 0, 0,18,18,22,21, 0, 0, 0, 0, 0, 0,15,
+ 16,21,21, 0,19,19, 0, 0, 0,18,17, 0, 0, 0,18,18,
+ 21, 0, 0, 0, 0, 0, 0, 0,16,16,22,22, 0,20,21, 0,
+ 0, 0,18,19, 0,22, 0,13,13,16,16, 0,12,12,15,15,
+ 0,13,13,16,16, 0,14,14,15,15, 0,15,15,17,17, 0,
+ 13,13,17,16, 0,15,15,17,17, 0,12,12,16,16, 0,15,
+ 15,17,17, 0,14,14,16,16, 0,13,13,16,17, 0,15,15,
+ 17,17, 0,12,12,16,16, 0,14,14,17,17, 0,14,14,16,
+ 16, 0,16,16,17,17, 0,21, 0,21,19, 0,13,13,16,16,
+ 0,17,17, 0, 0, 0,15,15,16,16, 0,16,15,18,18, 0,
+ 22, 0,20,20, 0,13,13,15,15, 0,18,18, 0, 0, 0,15,
+ 15,15,15, 0,12,12,17,17, 0,14,14,17,17, 0,14,14,
+ 17,17, 0,17,17,18,17, 0,17,17,19,18, 0,13,13,17,
+ 17, 0,16,16,18,18, 0,13,13,16,16, 0,17,17,19,19,
+ 0,16,16,17,17, 0,13,13,18,18, 0,17,17,18,18, 0,
+ 13,13,17,17, 0,17,17,19,19, 0,16,17,17,17, 0,17,
+ 17,19,19, 0,21, 0,21,19, 0,14,14,16,16, 0,20,19,
+ 0,21, 0,16,16,16,16, 0,17,18,19,19, 0, 0, 0, 0,
+ 21, 0,15,15,16,17, 0,21,20, 0, 0, 0,17,18,16,17,
+ 0, 9, 9,14,14, 0,14,14,15,16, 0,14,14,15,15, 0,
+ 0, 0,18,18, 0,21, 0,18,19, 0,12,12,15,15, 0,16,
+ 16,17,17, 0,14,14,14,14, 0,22, 0,19,18, 0,22, 0,
+ 17,18, 0,14,14,16,15, 0,18,18,19,18, 0,14,15,15,
+ 15, 0, 0,21,20,20, 0, 0, 0,18,18, 0,21,21,19,19,
+ 0, 0, 0, 0, 0, 0,21,21,18,18, 0,22, 0,20,20, 0,
+ 22, 0,19,19, 0,22, 0,19,20, 0, 0, 0, 0, 0, 0, 0,
+ 21,17,18, 0, 0, 0,22,22, 0, 0, 0,19,18, 0,18,20,
+ 16,16, 0,21,20,17,17, 0, 0,21,18,18, 0,22,21,18,
+ 18, 0, 0,22,19,19, 0,20,20,17,17, 0, 0, 0,18,18,
+ 0,19,20,17,17, 0,22, 0,19,21, 0,22,21,18,18, 0,
+ 20,19,17,18, 0, 0, 0,19,19, 0,20,20,17,17, 0,22,
+ 22,21,21, 0,20, 0,18,18, 0,22,22,18,18, 0, 0, 0,
+ 20,22, 0,20,20,16,16, 0, 0, 0,21, 0, 0,21,20,16,
+ 17, 0,22, 0,19,20, 0, 0, 0,21,20, 0,19,21,17,17,
+ 0, 0, 0, 0, 0, 0,21,21,17,17, 0,12,12,13,13, 0,
+ 14,14,16,16, 0,14,14,16,16, 0,18,18, 0, 0, 0,19,
+ 18,22, 0, 0,13,13,16,16, 0,16,16,18,18, 0,13,13,
+ 16,16, 0,17,18,21, 0, 0,18,18,21, 0, 0,13,13,16,
+ 16, 0,17,17,19,20, 0,13,13,16,17, 0,18,18,21, 0,
+ 0,18,18,21, 0, 0,18,19, 0,21, 0, 0, 0, 0, 0, 0,
+ 16,16,21,20, 0,20,20, 0, 0, 0,18,19, 0, 0, 0,18,
+ 18, 0, 0, 0, 0, 0, 0, 0, 0,16,16, 0,21, 0,22,22,
+ 0, 0, 0,19,19, 0, 0, 0,16,16,19,20, 0,17,16,22,
+ 21, 0,17,17,21,20, 0,19,18, 0,22, 0,19,19,22,22,
+ 0,16,15,22,22, 0,19,19, 0,21, 0,15,15,20,20, 0,
+ 18,19, 0,21, 0,18,18,22,22, 0,16,16,21,20, 0,20,
+ 19,21,22, 0,16,15,20,20, 0,19,19, 0,22, 0,18,18,
+ 21, 0, 0,19,18,21,22, 0, 0, 0, 0, 0, 0,16,16,19,
+ 21, 0,20,22, 0,22, 0,18,18,20,21, 0,19,18, 0,22,
+ 0, 0, 0,22, 0, 0,16,16,20,20, 0,21,21, 0, 0, 0,
+ 18,18,21, 0, 0,12,12,17,17, 0,15,14,17,17, 0,14,
+ 14,18,18, 0,17,17,17,18, 0,18,18,18,18, 0,13,13,
+ 18,18, 0,16,17,19,18, 0,13,13,16,17, 0,17,17,18,
+ 19, 0,17,17,17,17, 0,13,13,17,17, 0,17,18,18,18,
+ 0,13,13,16,16, 0,18,18,19,20, 0,16,17,17,16, 0,
+ 17,18,19,18, 0, 0, 0,22,21, 0,15,15,16,16, 0,20,
+ 20,21,22, 0,17,17,16,16, 0,16,17,18,18, 0, 0, 0,
+ 21,21, 0,15,15,16,16, 0,21,20, 0, 0, 0,17,17,16,
+ 16, 0,10,10,14,14, 0,14,14,15,15, 0,14,14,15,15,
+ 0,22, 0,18,18, 0, 0, 0,19,19, 0,13,13,15,16, 0,
+ 17,16,18,18, 0,14,14,15,15, 0,21,21,19,18, 0,22,
+ 21,18,17, 0,14,14,15,15, 0,18,18,19,18, 0,15,15,
+ 14,14, 0,22,21,19,19, 0,22,21,17,18, 0, 0, 0,19,
+ 19, 0, 0, 0, 0, 0, 0,20,22,17,17, 0, 0,22,22,20,
+ 0, 0, 0,19,18, 0,21,22,19,18, 0, 0, 0, 0, 0, 0,
+ 22,22,17,18, 0, 0, 0,21,22, 0, 0, 0,19,18, 0,20,
+ 20,17,17, 0,21,21,17,18, 0,21,22,18,18, 0,21, 0,
+ 18,18, 0,22, 0,19,19, 0,19,21,18,18, 0, 0,22,18,
+ 18, 0,22,21,17,17, 0,22, 0,20,20, 0, 0, 0,18,18,
+ 0,22,21,18,18, 0,21, 0,19,19, 0,20,21,17,17, 0,
+ 0,22,22,20, 0,21,22,17,17, 0, 0,21,19,18, 0, 0,
+ 0,21,21, 0,21,20,16,17, 0, 0, 0, 0, 0, 0,21, 0,
+ 17,17, 0,21, 0,19,20, 0, 0, 0,20,22, 0,20,20,17,
+ 17, 0, 0, 0, 0, 0, 0,21,21,17,17, 0,12,12,13,13,
+ 0,14,14,16,16, 0,14,14,16,16, 0,18,18,21, 0, 0,
+ 19,19,22, 0, 0,13,13,16,16, 0,16,16,18,18, 0,13,
+ 13,16,16, 0,18,18,21,22, 0,18,18, 0,22, 0,13,13,
+ 16,16, 0,17,17,20,18, 0,13,13,16,16, 0,19,18, 0,
+ 22, 0,18,18,22,21, 0,18,19, 0, 0, 0, 0, 0, 0, 0,
+ 0,16,16,21,21, 0,21,21, 0, 0, 0,18,19, 0, 0, 0,
+ 19,19,21, 0, 0, 0, 0, 0, 0, 0,16,16, 0,21, 0,20,
+ 20, 0, 0, 0,20,20, 0, 0, 0,16,16,21,20, 0,18,17,
+ 21,22, 0,17,18, 0,21, 0,18,19,22,22, 0,19,19, 0,
+ 22, 0,16,17,21,22, 0,20,19, 0, 0, 0,16,16,20,21,
+ 0,19,19, 0, 0, 0,19,19, 0,22, 0,17,17,21,21, 0,
+ 19,20, 0, 0, 0,16,16, 0,20, 0,19,20, 0,21, 0,18,
+ 18, 0,22, 0,19,20,22,22, 0, 0, 0, 0,22, 0,17,17,
+ 0,21, 0,21,21, 0, 0, 0,18,19,23,21, 0,20,19, 0,
+ 0, 0, 0, 0, 0, 0, 0,17,17, 0,20, 0, 0, 0, 0, 0,
+ 0,19,19,23,22,
+};
+
+static const static_codebook _44p4_p5_0 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p4_p5_0,
+ 1, -528744448, 1616642048, 3, 0,
+ (long *)_vq_quantlist__44p4_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44p4_p5_1[] = {
+ 3,
+ 2,
+ 4,
+ 1,
+ 5,
+ 0,
+ 6,
+};
+
+static const long _vq_lengthlist__44p4_p5_1[] = {
+ 2, 3, 3, 3, 3, 3, 3,
+};
+
+static const static_codebook _44p4_p5_1 = {
+ 1, 7,
+ (long *)_vq_lengthlist__44p4_p5_1,
+ 1, -533200896, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p4_p5_1,
+ 0
+};
+
+static const long _vq_quantlist__44p4_p6_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p4_p6_0[] = {
+ 1, 7, 7, 7, 8, 8, 7, 8, 8, 7, 9, 9,11,11,11, 9,
+ 8, 8, 8, 9, 9,12,11,12, 9, 8, 8, 6, 7, 7,10,11,
+ 11,10,10,10,11,11,11,14,14,14,12,11,12,11,11,11,
+ 15,15,14,13,12,12, 5, 6, 6, 8, 5, 5, 8, 7, 7, 8,
+ 7, 7,12,10,10,10, 7, 6, 9, 8, 8,12,10,10,10, 6,
+ 6, 7, 8, 8,12,10,10,12,10,10,11,10,10,16,14,14,
+ 13,10,10,12,10,10,15,14,14,14,10,10, 7, 7, 7,13,
+ 11,11,13,11,11,12,11,11,16,14,14,14,12,12,12,11,
+ 11,18,15,15,14,12,12,10, 9,10,14,11,11,13,11,11,
+ 12,11,11,17,14,14,14,11,11,13,11,11,16,15,15,14,
+ 11,11, 7, 8, 8,13,11,11,12,10,10,12,10,10,16,14,
+ 13,13,10,10,12,10,10,17,14,14,14,10,10, 8, 7, 7,
+ 12,11,11,13,11,11,12,11,11,16,15,14,14,12,12,12,
+ 11,11,16,15,15,14,12,12,11,10,10,14,11,11,13,11,
+ 11,13,11,11,17,14,14,14,11,11,13,11,11,18,14,15,
+ 15,11,10,
+};
+
+static const static_codebook _44p4_p6_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p4_p6_0,
+ 1, -527106048, 1620377600, 2, 0,
+ (long *)_vq_quantlist__44p4_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44p4_p6_1[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p4_p6_1[] = {
+ 2, 6, 6, 6, 7, 7, 7, 7, 7, 7, 8, 8, 9, 9, 9, 9,
+ 7, 7, 8, 8, 8, 9, 9, 9, 9, 8, 8, 6, 7, 7, 8, 8,
+ 8, 8, 8, 8, 9, 8, 8, 9, 8, 9, 9, 8, 8,10, 8, 8,
+ 10, 9, 9,10, 8, 8, 6, 6, 6, 8, 6, 6, 8, 7, 7, 8,
+ 7, 7,10, 8, 8, 9, 7, 7, 9, 7, 7,10, 8, 8, 9, 7,
+ 7, 7, 7, 7,10, 8, 8,11, 9, 9,10, 9, 9,11, 9, 9,
+ 11, 8, 8,11, 9, 9,12, 9, 9,12, 8, 8, 7, 7, 7,10,
+ 9, 9,10, 9, 9,10, 9, 9,11,10,10,10, 9, 9,11, 9,
+ 10,11,10,11,10, 9, 9, 9, 8, 8,10, 9, 9,10, 9, 9,
+ 11, 9, 9,11,10,10,11, 9, 9,11, 9, 9,11,10,10,11,
+ 9, 9, 8, 8, 8,11, 9, 9,11, 9, 9,11, 9, 9,12, 9,
+ 9,12, 8, 8,11, 9, 9,12, 9, 9,12, 8, 8, 8, 7, 7,
+ 10, 9, 9,10, 9, 9,10, 9, 9,11,11,11,11, 9, 9,11,
+ 10,10,11,11,11,11, 9, 9,10, 9, 9,11, 9, 9,11, 9,
+ 10,11,10,10,11,10,10,11, 9, 9,11,10,10,11,10,10,
+ 11, 9, 9,
+};
+
+static const static_codebook _44p4_p6_1 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p4_p6_1,
+ 1, -530841600, 1616642048, 2, 0,
+ (long *)_vq_quantlist__44p4_p6_1,
+ 0
+};
+
+static const long _vq_quantlist__44p4_p7_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p4_p7_0[] = {
+ 1, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9,
+};
+
+static const static_codebook _44p4_p7_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p4_p7_0,
+ 1, -513979392, 1633504256, 2, 0,
+ (long *)_vq_quantlist__44p4_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44p4_p7_1[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p4_p7_1[] = {
+ 1, 9, 9, 7, 9, 9, 8, 8, 9, 9, 9, 9, 9, 9, 9, 8,
+ 9, 9, 7, 9, 9, 9, 9, 9, 9, 9, 9, 7, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 6, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 5, 9, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 8, 9, 8, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 5,10, 9,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10, 8,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,
+};
+
+static const static_codebook _44p4_p7_1 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p4_p7_1,
+ 1, -516716544, 1630767104, 2, 0,
+ (long *)_vq_quantlist__44p4_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44p4_p7_2[] = {
+ 12,
+ 11,
+ 13,
+ 10,
+ 14,
+ 9,
+ 15,
+ 8,
+ 16,
+ 7,
+ 17,
+ 6,
+ 18,
+ 5,
+ 19,
+ 4,
+ 20,
+ 3,
+ 21,
+ 2,
+ 22,
+ 1,
+ 23,
+ 0,
+ 24,
+};
+
+static const long _vq_lengthlist__44p4_p7_2[] = {
+ 1, 3, 2, 5, 4, 7, 7, 8, 8, 9, 9,10,10,11,11,12,
+ 12,13,13,14,14,15,15,15,15,
+};
+
+static const static_codebook _44p4_p7_2 = {
+ 1, 25,
+ (long *)_vq_lengthlist__44p4_p7_2,
+ 1, -518864896, 1620639744, 5, 0,
+ (long *)_vq_quantlist__44p4_p7_2,
+ 0
+};
+
+static const long _vq_quantlist__44p4_p7_3[] = {
+ 12,
+ 11,
+ 13,
+ 10,
+ 14,
+ 9,
+ 15,
+ 8,
+ 16,
+ 7,
+ 17,
+ 6,
+ 18,
+ 5,
+ 19,
+ 4,
+ 20,
+ 3,
+ 21,
+ 2,
+ 22,
+ 1,
+ 23,
+ 0,
+ 24,
+};
+
+static const long _vq_lengthlist__44p4_p7_3[] = {
+ 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5,
+};
+
+static const static_codebook _44p4_p7_3 = {
+ 1, 25,
+ (long *)_vq_lengthlist__44p4_p7_3,
+ 1, -529006592, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44p4_p7_3,
+ 0
+};
+
+static const long _huff_lengthlist__44p4_short[] = {
+ 3, 5,16, 9, 9,13,18,21, 4, 2,21, 6, 6,10,15,21,
+ 16,19, 6, 5, 7,10,13,16, 8, 6, 5, 4, 4, 8,13,16,
+ 8, 5, 6, 4, 4, 7,12,15,13,10, 9, 7, 7, 9,13,16,
+ 18,15,13,12, 9, 7,10,14,21,18,13,13, 7, 5, 8,12,
+};
+
+static const static_codebook _huff_book__44p4_short = {
+ 2, 64,
+ (long *)_huff_lengthlist__44p4_short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44p5_l0_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44p5_l0_0[] = {
+ 1, 4, 4, 8, 8,10,10,10,10, 9, 8,11,11, 4, 6, 5,
+ 8, 6,10,10,10,10,10, 9,10, 9, 4, 5, 6, 6, 9,10,
+ 10,10,10, 9,10, 9,10, 8, 9, 8, 9, 8, 9, 9,10, 9,
+ 11,10,12,10, 8, 8, 9, 8, 9, 9, 9, 9,10,10,11,10,
+ 12, 9,10,10,11,10,11,10,12,11,12,11,13,11, 9,10,
+ 10,10,11,10,11,11,12,11,12,11,12,11,12,12,12,12,
+ 13,12,13,12,13,12,13,13,11,12,12,12,12,12,12,12,
+ 13,13,13,13,13,12,12,12,13,13,13,13,13,13,13,13,
+ 13,13,12,13,12,13,13,13,13,13,13,13,13,13,13,12,
+ 13,13,13,14,14,13,13,13,13,13,13,13,12,13,12,13,
+ 13,13,13,13,13,13,13,13,13,
+};
+
+static const static_codebook _44p5_l0_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44p5_l0_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44p5_l0_0,
+ 0
+};
+
+static const long _vq_quantlist__44p5_l0_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p5_l0_1[] = {
+ 4, 4, 4, 5, 5, 4, 5, 5, 5, 5, 4, 5, 4, 4, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5,
+};
+
+static const static_codebook _44p5_l0_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44p5_l0_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p5_l0_1,
+ 0
+};
+
+static const long _vq_quantlist__44p5_l1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p5_l1_0[] = {
+ 1, 4, 4, 4, 4, 4, 4, 4, 4,
+};
+
+static const static_codebook _44p5_l1_0 = {
+ 2, 9,
+ (long *)_vq_lengthlist__44p5_l1_0,
+ 1, -516716544, 1630767104, 2, 0,
+ (long *)_vq_quantlist__44p5_l1_0,
+ 0
+};
+
+static const long _huff_lengthlist__44p5_lfe[] = {
+ 1, 3, 2, 3,
+};
+
+static const static_codebook _huff_book__44p5_lfe = {
+ 2, 4,
+ (long *)_huff_lengthlist__44p5_lfe,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44p5_long[] = {
+ 3, 7,12,14,14,16,18,19, 6, 2, 4, 6, 8, 9,12,14,
+ 12, 3, 3, 5, 7, 8,11,13,13, 6, 4, 5, 7, 8,10,11,
+ 14, 8, 7, 7, 7, 7, 9,10,15, 9, 8, 7, 7, 6, 8, 9,
+ 17,11,11,10, 9, 8, 9, 9,19,14,13,11,10, 9, 9, 9,
+};
+
+static const static_codebook _huff_book__44p5_long = {
+ 2, 64,
+ (long *)_huff_lengthlist__44p5_long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44p5_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p5_p1_0[] = {
+ 2, 5, 5, 5, 7, 7, 5, 7, 7, 5, 7, 7, 7, 8, 9, 7,
+ 9, 9, 5, 7, 7, 7, 9, 9, 7, 9, 8, 5, 7, 8, 8, 9,
+ 10, 8, 9,10, 8, 9,10, 9,10,12,10,11,11, 8,10,10,
+ 10,11,11, 9,11,11, 5, 8, 7, 8, 9, 9, 8,10, 9, 8,
+ 10,10, 9,11,11,10,11,11, 8,10, 9,10,11,11, 9,12,
+ 10, 5, 8, 8, 7, 9,10, 8,10, 9, 7, 9, 9, 9,10,11,
+ 9,11,11, 8,10, 9,10,11,11,10,11,11, 7, 9, 9, 9,
+ 10,11, 9,11,11, 9, 9,11,10,10,13,11,11,12, 9,11,
+ 11,11,12,13,11,13,12, 7, 9, 9, 9,11,11, 9,11,10,
+ 9,11,10,10,11,12,11,13,12, 9,11,11,11,12,13,11,
+ 13,11, 5, 8, 8, 8, 9,10, 7,10, 9, 8, 9,10,10,11,
+ 11,10,11,11, 7, 9, 9, 9,11,11, 9,11,10, 7, 9, 9,
+ 9,10,11, 9,11,11, 9,11,11,11,11,13,11,13,12, 9,
+ 10,11,11,12,13,10,12,11, 7, 9, 9, 9,11,11, 9,11,
+ 10, 9,11,11,11,12,13,11,13,12, 9,11, 9,11,12,11,
+ 10,13,10,
+};
+
+static const static_codebook _44p5_p1_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p5_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44p5_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44p5_p2_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p5_p2_0[] = {
+ 4, 6, 6, 9, 9, 6, 7, 8,10,10, 6, 8, 7,10,10, 8,
+ 10,10,12,13, 8,10,10,13,12, 6, 7, 8,10,10, 7, 8,
+ 9,10,11, 8, 9, 9,11,11,10,10,11,12,14,10,11,11,
+ 14,13, 6, 8, 7,10,10, 8, 9, 9,11,11, 7, 9, 8,11,
+ 10,10,11,11,13,14,10,11,10,14,12, 9,10,10,12,12,
+ 10,10,11,12,13,10,11,11,13,13,12,12,13,12,15,13,
+ 14,13,15,14, 9,10,10,12,12,10,11,11,13,13,10,11,
+ 10,13,12,13,13,14,14,15,12,13,12,15,12, 6, 7, 8,
+ 10,11, 8, 9,10,11,12, 8, 9, 9,11,12,10,11,12,13,
+ 14,10,11,11,14,13, 8, 9,10,11,12, 9,10,11,12,13,
+ 9,10,11,12,13,11,12,13,13,15,12,12,13,15,14, 8,
+ 9, 9,12,12, 9,10,11,12,13, 9,10,10,13,12,12,12,
+ 13,14,15,11,12,12,14,14,11,11,12,13,14,11,12,13,
+ 13,15,12,13,13,14,15,14,13,15,14,16,14,15,15,16,
+ 16,11,12,11,14,13,12,13,13,15,14,11,13,12,14,13,
+ 14,15,15,15,16,13,14,14,16,14, 6, 8, 7,11,10, 8,
+ 9, 9,11,12, 8,10, 9,12,11,10,11,11,13,14,10,12,
+ 11,14,13, 8, 9, 9,12,12, 9,10,10,12,13, 9,11,10,
+ 13,12,11,12,12,13,14,12,13,12,15,14, 8,10, 9,12,
+ 11, 9,11,10,13,12, 9,11,10,13,12,12,13,12,14,15,
+ 11,13,12,15,13,11,11,12,13,14,11,12,13,13,15,12,
+ 13,13,14,15,13,14,14,14,16,14,15,15,16,16,11,12,
+ 11,14,13,12,13,13,15,14,11,13,12,15,13,14,15,15,
+ 16,16,13,15,13,16,14, 9,10,11,12,14,11,11,12,13,
+ 15,11,12,12,13,14,13,14,15,15,17,13,14,14,15,16,
+ 11,11,12,13,15,12,12,13,14,16,12,13,13,14,15,14,
+ 14,16,15,17,15,15,15,16,17,11,12,12,14,14,12,13,
+ 13,15,16,12,13,13,15,15,15,15,15,16,17,14,15,15,
+ 16,16,14,14,15,15,17,14,15,15,15,17,15,15,16,16,
+ 17,16,16,17,16,18,17,17,17,18,18,14,15,14,16,16,
+ 15,15,16,17,17,14,15,15,17,16,17,17,17,18,18,16,
+ 16,16,17,17, 9,11,10,14,12,11,12,12,14,13,11,12,
+ 11,15,13,13,14,14,16,15,13,15,14,17,15,11,12,12,
+ 15,14,12,13,13,15,15,12,13,13,15,15,14,15,15,16,
+ 16,15,15,15,17,16,11,12,11,15,13,12,13,13,15,14,
+ 12,13,12,16,14,15,15,15,17,16,14,15,14,17,15,14,
+ 14,15,16,16,14,15,15,16,16,15,16,15,17,17,16,16,
+ 16,17,17,17,17,17,18,17,14,15,14,16,15,15,15,15,
+ 17,16,15,15,15,17,15,17,17,17,18,18,16,17,16,18,
+ 16, 6, 8, 8,11,11, 8, 9, 9,11,12, 8, 9, 9,12,11,
+ 10,11,11,13,14,10,12,11,14,13, 7, 9, 9,11,12, 9,
+ 10,10,12,13, 9,10,10,13,13,11,11,12,13,15,11,12,
+ 12,15,14, 8, 9, 9,12,11, 9,11,10,13,13, 9,11,10,
+ 13,12,12,13,12,14,15,11,13,12,15,13,10,11,12,13,
+ 14,11,12,12,13,15,12,12,13,14,15,13,13,14,14,16,
+ 14,15,15,16,16,11,12,11,14,13,12,13,13,15,14,11,
+ 13,12,15,13,14,15,15,15,16,13,14,14,16,14, 7, 9,
+ 9,11,12, 9,10,11,12,13, 9,10,10,13,12,11,12,12,
+ 14,15,11,12,12,15,14, 9, 9,11,11,13,10,10,12,12,
+ 14,10,11,12,13,14,12,12,13,14,16,12,13,13,15,15,
+ 9,11,10,13,13,10,12,12,13,14,10,12,11,14,13,12,
+ 13,13,15,16,12,13,13,15,14,11,11,13,13,15,12,12,
+ 14,13,16,13,13,13,14,15,14,14,15,14,17,15,15,15,
+ 16,16,12,13,12,15,14,13,14,14,15,15,12,14,13,16,
+ 14,15,15,16,16,17,14,15,14,17,15, 7, 9, 9,12,11,
+ 9,10,10,12,13, 9,11,10,13,12,11,12,12,14,14,11,
+ 13,12,15,14, 9,10,10,13,12,10,10,11,12,13,10,12,
+ 11,14,13,12,12,13,13,15,12,14,13,16,15, 9,10,10,
+ 13,12,11,11,12,13,13,10,12,10,14,12,13,13,13,15,
+ 15,12,13,12,15,13,11,12,12,14,14,12,12,13,14,15,
+ 13,14,13,15,15,14,13,15,13,16,15,16,15,17,16,12,
+ 13,12,14,14,13,14,14,15,15,12,13,12,15,14,15,15,
+ 16,16,17,14,15,13,16,13,10,11,12,13,14,11,12,13,
+ 14,15,12,13,13,15,15,14,14,15,15,17,14,15,15,16,
+ 16,12,12,13,12,15,12,12,14,13,16,13,13,14,14,16,
+ 14,14,16,15,17,15,15,16,16,17,12,13,13,15,15,13,
+ 14,14,16,16,13,14,13,16,15,15,16,16,17,17,14,15,
+ 15,17,16,14,14,15,14,17,15,15,16,15,17,15,15,16,
+ 15,17,16,16,17,16,18,17,17,17,17,18,14,15,15,17,
+ 16,15,16,16,17,17,15,16,15,17,16,17,17,17,18,18,
+ 16,17,16,18,17,10,12,11,14,14,12,13,13,15,15,12,
+ 13,12,15,14,14,15,15,16,16,14,15,15,17,16,11,13,
+ 12,15,14,12,13,13,15,15,13,14,13,16,14,15,15,15,
+ 16,16,15,16,15,17,16,12,13,13,15,15,13,14,14,16,
+ 16,12,14,13,16,15,15,16,16,17,17,15,16,15,17,16,
+ 14,15,15,16,16,14,15,15,16,16,15,16,16,17,16,16,
+ 16,16,16,17,17,18,17,18,17,14,15,15,17,16,15,16,
+ 16,17,17,15,16,15,17,16,17,17,18,18,18,16,17,16,
+ 18,16, 6, 8, 8,11,11, 8, 9, 9,11,12, 8, 9, 9,12,
+ 11,10,11,12,13,14,10,11,11,14,13, 8, 9, 9,11,12,
+ 9,10,11,12,13, 9,10,11,13,13,11,12,13,13,15,12,
+ 12,12,15,14, 7, 9, 9,12,11, 9,10,10,13,13, 9,10,
+ 10,13,12,11,12,12,14,15,11,12,11,15,13,11,11,12,
+ 13,14,11,12,13,13,15,12,13,13,14,15,13,14,14,14,
+ 16,14,15,15,16,16,10,12,11,14,13,12,13,12,14,14,
+ 11,12,12,15,13,14,15,15,16,16,13,14,13,16,14, 7,
+ 9, 9,11,12, 9,10,11,12,13, 9,10,10,13,12,11,12,
+ 13,14,15,11,12,12,14,14, 9,10,10,12,13,10,10,12,
+ 12,14,11,12,11,13,13,12,12,14,13,15,13,13,13,15,
+ 15, 9,10,10,12,13,10,11,12,13,14,10,11,10,13,12,
+ 13,13,14,15,16,12,13,12,15,13,12,13,13,14,14,12,
+ 12,13,14,15,13,14,14,15,15,14,13,15,13,16,15,16,
+ 15,17,16,11,12,12,14,14,13,13,14,15,15,12,13,12,
+ 15,14,15,15,16,16,17,14,14,13,16,13, 7, 9, 9,12,
+ 11, 9,10,10,12,13, 9,11,10,13,12,11,12,12,14,15,
+ 11,12,12,15,14, 9,10,11,13,13,10,11,12,13,14,10,
+ 12,12,14,13,12,13,13,14,16,12,13,13,16,15, 9,11,
+ 9,13,11,10,12,11,13,13,10,12,10,14,12,12,13,13,
+ 15,15,12,13,12,16,14,12,12,13,14,15,12,13,14,14,
+ 15,13,14,14,15,15,14,14,15,15,17,15,16,15,17,16,
+ 11,13,11,15,13,13,14,13,15,14,12,14,12,16,13,15,
+ 15,15,16,16,14,15,14,17,14,10,11,12,14,14,12,12,
+ 13,14,15,12,13,13,15,15,14,15,15,16,17,14,15,15,
+ 16,16,12,12,13,15,15,13,13,14,15,16,13,14,14,16,
+ 16,15,15,16,16,17,15,16,16,17,17,11,12,13,14,15,
+ 13,13,14,15,16,12,13,13,15,15,15,15,16,16,17,15,
+ 15,15,16,16,14,15,15,16,17,15,15,16,16,17,15,16,
+ 16,17,17,16,16,17,16,18,17,17,17,18,18,14,15,15,
+ 16,16,15,16,16,16,17,15,15,15,16,16,17,17,17,18,
+ 18,16,16,16,17,16,10,12,11,14,13,12,13,13,15,15,
+ 11,13,12,15,14,14,15,15,16,16,14,15,14,17,15,12,
+ 13,13,15,15,13,13,14,16,16,13,14,14,16,16,15,15,
+ 15,16,17,15,16,16,17,17,12,13,12,15,12,13,14,13,
+ 16,14,12,14,12,16,13,15,16,15,17,16,14,16,14,17,
+ 15,14,15,15,16,17,15,15,16,17,17,15,16,16,17,17,
+ 16,16,17,17,18,17,18,17,18,18,14,15,14,17,14,15,
+ 16,15,17,15,15,16,15,17,15,17,17,17,18,17,16,17,
+ 16,18,16, 9,11,11,14,14,11,12,12,14,14,11,12,12,
+ 15,14,13,14,14,16,16,13,15,14,16,16,10,11,12,14,
+ 14,11,12,13,15,15,12,13,13,15,15,13,14,15,16,17,
+ 14,15,15,17,16,11,12,12,15,14,12,13,13,15,15,12,
+ 13,13,15,15,14,15,15,16,16,14,15,15,17,16,12,13,
+ 14,15,16,13,14,14,15,16,13,14,15,16,16,15,15,16,
+ 16,18,16,16,16,18,17,14,14,14,16,15,15,15,15,17,
+ 16,14,15,15,17,16,16,17,17,18,17,16,16,16,18,16,
+ 10,12,12,14,14,11,12,13,15,15,12,13,13,15,15,13,
+ 14,15,16,17,14,15,15,17,16,11,12,13,14,15,12,12,
+ 14,15,16,13,13,14,15,16,14,14,15,16,17,15,15,16,
+ 17,17,12,13,13,15,15,13,14,14,16,16,13,14,13,16,
+ 15,15,16,15,17,17,15,16,15,17,16,13,13,15,14,17,
+ 14,13,16,15,17,15,14,16,15,17,15,15,17,16,18,16,
+ 16,17,17,18,14,15,15,17,16,15,16,16,17,17,15,16,
+ 15,17,16,17,17,17,18,18,16,17,16,18,17,10,12,11,
+ 14,14,11,12,13,15,15,12,13,12,15,15,14,15,15,16,
+ 16,14,15,15,17,16,11,12,12,15,15,12,13,13,15,15,
+ 13,14,13,16,15,14,15,15,16,16,15,16,15,17,16,11,
+ 13,13,15,15,13,14,14,15,15,12,14,13,16,15,15,16,
+ 15,17,17,15,16,15,17,16,13,15,14,16,16,14,15,14,
+ 16,16,15,16,15,17,16,15,16,16,16,17,16,17,16,18,
+ 17,14,15,15,16,16,15,16,16,17,17,15,15,15,17,16,
+ 17,17,17,18,18,16,16,16,18,16,12,13,13,15,16,13,
+ 14,14,15,16,13,14,14,16,16,15,15,16,16,18,15,16,
+ 16,17,17,13,13,14,15,16,14,14,15,15,17,14,15,15,
+ 16,17,15,15,17,16,18,16,16,17,17,17,13,14,14,16,
+ 16,14,15,15,17,17,14,15,14,17,16,16,17,16,17,18,
+ 16,17,16,18,17,15,15,16,14,17,16,15,17,14,18,16,
+ 16,16,15,18,16,16,18,15,19,18,18,18,17,19,15,16,
+ 16,18,17,16,17,17,18,17,16,17,16,18,17,18,18,18,
+ 19,19,17,18,16,18,17,11,12,12,15,15,13,13,14,15,
+ 16,13,14,13,16,15,15,16,16,16,17,15,16,16,17,16,
+ 12,14,13,16,15,13,13,14,15,16,14,15,14,17,15,15,
+ 15,16,16,17,16,17,16,18,17,12,13,14,15,16,14,15,
+ 15,16,16,13,14,13,16,15,16,16,16,17,17,15,16,15,
+ 17,15,15,16,15,17,16,15,15,15,16,16,16,17,16,18,
+ 16,16,15,16,15,17,17,18,17,18,17,15,15,16,17,17,
+ 16,16,17,17,17,15,16,15,17,16,18,18,18,18,18,16,
+ 17,16,18,15, 9,11,11,14,14,11,12,12,14,15,10,12,
+ 12,15,14,13,14,15,16,16,13,14,14,16,16,11,12,12,
+ 14,15,12,12,13,15,15,12,13,13,15,15,14,15,15,16,
+ 17,14,15,15,16,16,10,12,12,14,14,12,13,13,15,15,
+ 11,13,12,15,15,14,15,15,16,17,13,15,14,16,16,14,
+ 14,14,15,16,14,15,15,16,17,14,15,15,16,17,16,16,
+ 17,16,18,16,17,17,17,17,12,14,13,16,15,13,15,14,
+ 16,16,13,14,14,16,15,16,16,16,17,17,15,16,15,17,
+ 16,10,11,11,14,14,12,12,13,14,15,11,13,12,15,14,
+ 14,15,15,16,17,14,15,15,16,16,12,13,13,15,15,12,
+ 13,14,15,16,13,14,14,15,15,15,15,16,16,17,15,15,
+ 16,17,17,11,12,12,15,15,13,13,14,15,16,12,13,13,
+ 15,15,15,15,16,16,17,14,15,15,16,16,14,15,15,16,
+ 16,15,15,15,16,17,15,16,16,17,17,16,16,17,16,18,
+ 17,17,17,17,18,13,14,15,16,16,15,15,16,16,17,14,
+ 14,14,16,16,16,16,17,17,18,16,16,16,17,16,10,12,
+ 12,14,14,12,13,13,15,15,11,13,12,15,15,14,15,15,
+ 16,17,13,15,14,17,16,12,13,13,15,15,13,13,14,15,
+ 16,13,14,14,16,16,15,15,16,16,17,15,15,16,17,17,
+ 11,13,12,15,14,13,14,13,16,15,12,14,12,16,15,15,
+ 16,15,17,17,14,15,14,17,16,14,15,15,16,17,15,15,
+ 16,16,17,15,16,16,17,17,16,16,17,17,18,17,17,17,
+ 18,18,13,15,13,17,14,14,16,14,17,16,14,15,13,17,
+ 15,16,17,16,18,17,15,17,15,18,16,11,12,12,15,15,
+ 13,13,14,15,16,13,14,13,16,15,15,16,16,16,17,15,
+ 16,16,17,16,12,14,13,16,15,13,13,14,15,16,14,15,
+ 15,16,16,16,15,16,16,17,16,16,16,17,17,12,13,14,
+ 15,16,14,14,15,15,17,13,14,13,16,15,16,16,17,17,
+ 18,15,16,15,17,15,15,16,15,17,17,15,15,16,16,17,
+ 16,17,16,17,17,16,15,17,15,18,17,18,17,18,18,15,
+ 15,16,16,17,16,16,17,16,18,15,15,15,16,16,17,17,
+ 18,17,18,16,16,15,17,15,12,13,13,15,15,13,14,14,
+ 16,16,13,14,14,16,16,15,16,16,17,18,15,16,15,18,
+ 16,13,14,14,16,16,14,14,15,16,17,14,15,15,17,17,
+ 16,16,17,17,18,16,16,17,18,17,13,14,13,16,14,14,
+ 15,15,17,16,14,15,14,17,15,16,17,17,18,17,15,17,
+ 15,18,16,15,16,16,17,17,16,16,17,17,18,16,17,17,
+ 18,18,17,16,18,17,19,18,18,18,18,18,15,16,15,17,
+ 14,16,16,16,18,15,16,17,15,18,14,18,18,18,18,17,
+ 17,18,16,19,15,
+};
+
+static const static_codebook _44p5_p2_0 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p5_p2_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p5_p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44p5_p3_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p5_p3_0[] = {
+ 1, 5, 6, 5, 7, 8, 5, 8, 7, 5, 7, 8, 7, 8,10, 8,
+ 10,10, 5, 8, 7, 8,10,10, 7,10, 8, 6, 8, 9, 8,10,
+ 11, 9,10,10, 9,10,11,10,11,12,11,12,12, 9,11,10,
+ 11,12,12,10,12,11, 6, 9, 8, 9,10,10, 8,11,10, 9,
+ 10,11,10,11,12,11,12,12, 9,11,10,11,12,12,10,12,
+ 11, 6, 9, 9, 8,10,11, 9,11,10, 8,10,10,10,10,12,
+ 11,12,12, 9,11,10,11,12,12,10,12,11, 8,10,10,10,
+ 11,12,10,12,11,10,10,12,11,11,13,12,13,13,10,12,
+ 11,12,13,13,11,13,11, 7,10,10,10,11,12,10,12,11,
+ 10,12,11,11,11,12,12,14,13,10,12,12,12,14,14,11,
+ 13,11, 6, 9, 9, 9,10,11, 8,11,10, 9,10,11,10,11,
+ 12,11,12,12, 8,11,10,11,12,12,10,12,10, 7,10,10,
+ 10,11,12,10,12,11,10,12,12,11,11,13,12,13,13,10,
+ 11,12,12,13,14,11,12,11, 8,10,10,10,11,12,10,12,
+ 11,10,11,12,11,11,13,12,13,13,10,12,10,12,13,13,
+ 11,13,11,
+};
+
+static const static_codebook _44p5_p3_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p5_p3_0,
+ 1, -533200896, 1614282752, 2, 0,
+ (long *)_vq_quantlist__44p5_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44p5_p3_1[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p5_p3_1[] = {
+ 5, 6, 6, 6, 7, 7, 6, 7, 7, 6, 7, 7, 7, 7, 8, 7,
+ 8, 8, 6, 7, 7, 7, 8, 8, 7, 8, 7, 7, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 8, 9, 9, 8, 8, 8,
+ 8, 9, 9, 8, 9, 9, 7, 8, 7, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 9, 9, 8, 9, 9, 8, 8, 8, 8, 9, 9, 8, 9,
+ 8, 6, 8, 8, 7, 8, 8, 7, 8, 8, 7, 8, 8, 8, 8, 9,
+ 8, 9, 9, 8, 8, 8, 8, 9, 9, 8, 9, 8, 7, 8, 8, 8,
+ 9, 9, 8, 9, 9, 8, 8, 9, 9, 9, 9, 9, 9, 9, 8, 9,
+ 9, 9, 9, 9, 9, 9, 9, 7, 8, 8, 8, 8, 9, 8, 9, 8,
+ 8, 8, 8, 8, 9, 9, 9, 9, 9, 8, 9, 8, 9, 9, 9, 8,
+ 9, 9, 6, 8, 8, 7, 8, 8, 7, 8, 8, 8, 8, 8, 8, 8,
+ 9, 8, 9, 9, 7, 8, 8, 8, 9, 9, 8, 9, 8, 7, 8, 8,
+ 8, 8, 9, 8, 9, 8, 8, 8, 9, 8, 9, 9, 9, 9, 9, 8,
+ 8, 8, 9, 9, 9, 8, 9, 9, 7, 8, 8, 8, 9, 9, 8, 9,
+ 9, 8, 9, 9, 9, 9, 9, 9, 9, 9, 8, 9, 8, 9, 9, 9,
+ 9, 9, 9,
+};
+
+static const static_codebook _44p5_p3_1 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p5_p3_1,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44p5_p3_1,
+ 0
+};
+
+static const long _vq_quantlist__44p5_p4_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p5_p4_0[] = {
+ 1, 5, 5, 5, 7, 9, 5, 9, 7, 5, 7, 8, 7, 7,10, 9,
+ 10,10, 5, 8, 7, 9,10,10, 7,10, 7, 6, 8, 9, 9,10,
+ 12, 9,11,11, 9,10,11,11,11,13,12,13,13, 9,11,11,
+ 11,12,13,11,13,11, 6, 9, 8, 9,11,11, 9,12,10, 9,
+ 11,11,11,11,13,11,13,12, 9,11,10,12,13,13,11,13,
+ 11, 6, 9, 9, 8,10,11, 9,12,11, 9,10,11,10,10,12,
+ 11,13,13, 9,11,11,11,13,12,11,13,11, 8,10,10, 9,
+ 10,12,10,12,11,10,10,12,10,10,13,12,13,13,10,12,
+ 11,12,13,13,10,13,10, 7,10,10,11,11,13,11,14,11,
+ 10,12,11,11,11,13,13,14,13,10,12,12,14,14,14,11,
+ 14,11, 6, 9, 9, 9,11,12, 8,11,10, 9,11,11,11,11,
+ 13,11,12,13, 8,11,10,11,13,13,10,12,10, 7,10,10,
+ 11,11,14,11,13,11,10,12,12,11,11,14,14,14,14,10,
+ 11,12,13,13,14,11,13,11, 8,10,10,10,11,12, 9,12,
+ 10,10,11,12,11,10,13,12,13,13,10,12,10,12,13,13,
+ 11,13,10,
+};
+
+static const static_codebook _44p5_p4_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p5_p4_0,
+ 1, -531365888, 1616117760, 2, 0,
+ (long *)_vq_quantlist__44p5_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44p5_p4_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p5_p4_1[] = {
+ 5, 7, 7,10,10, 7, 8, 9,10,11, 7, 9, 8,11,10, 9,
+ 10,10,11,11, 9,10,10,11,11, 7, 9, 9,10,10, 8, 9,
+ 10,10,11, 9,10,10,11,11,10,10,11,11,11,10,11,11,
+ 12,12, 7, 9, 9,10,10, 9,10,10,11,11, 8,10, 9,11,
+ 10,10,11,11,11,11,10,11,10,11,11,10,10,10,11,11,
+ 10,10,11,11,11,11,11,11,11,11,11,11,12,11,12,11,
+ 12,11,12,12,10,10,10,11,11,10,11,11,11,11,10,11,
+ 10,11,11,11,12,11,12,12,11,12,11,12,11, 8, 9, 9,
+ 11,11, 9,10,10,11,12, 9,10,10,11,11,10,11,11,12,
+ 12,10,11,11,12,12, 9,10,10,11,11,10,10,11,11,12,
+ 10,11,11,12,12,11,11,12,12,12,11,12,12,12,12, 9,
+ 10,10,11,11,10,11,11,12,12,10,11,10,12,12,11,12,
+ 12,12,12,11,12,12,12,12,11,11,11,12,12,11,11,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,11,11,11,12,12,11,12,12,12,12,11,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12, 8, 9, 9,11,11, 9,
+ 10,10,11,11, 9,10,10,11,11,10,11,11,12,12,10,11,
+ 11,12,12, 9,10,10,11,11,10,10,11,12,12,10,11,11,
+ 12,12,11,12,12,12,12,11,12,12,12,12, 9,10,10,11,
+ 11,10,11,11,12,12,10,11,10,12,11,11,12,12,12,12,
+ 11,12,11,12,12,11,11,11,12,12,11,12,12,12,12,11,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,11,11,
+ 11,12,12,11,12,12,12,12,11,12,11,12,12,12,12,12,
+ 12,12,12,12,12,12,12,10,11,11,12,12,11,12,12,12,
+ 12,11,12,12,12,12,12,12,13,13,13,12,12,12,13,13,
+ 11,12,12,12,12,12,12,12,12,13,12,12,12,13,13,12,
+ 12,13,13,13,12,13,13,13,13,11,12,12,12,12,12,12,
+ 12,13,13,12,12,12,13,13,12,13,13,13,13,12,13,13,
+ 13,13,12,12,12,12,13,12,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,12,12,12,13,12,
+ 13,13,13,13,13,12,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,10,11,11,12,12,11,12,12,12,12,11,12,
+ 11,12,12,12,12,12,13,12,12,12,12,13,13,11,12,12,
+ 12,12,12,12,12,13,13,12,12,12,13,13,12,13,13,13,
+ 13,12,13,13,13,13,11,12,12,12,12,12,12,12,13,13,
+ 12,12,12,13,12,12,13,13,13,13,12,13,12,13,13,12,
+ 12,12,12,13,12,13,13,13,13,12,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,12,12,12,13,12,13,13,13,
+ 13,13,12,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13, 8, 9, 9,11,11, 9,10,10,11,11, 9,10,10,12,11,
+ 10,11,11,12,12,10,11,11,12,12, 9,10,10,11,11,10,
+ 10,11,11,12,10,11,11,12,12,11,11,12,12,12,11,12,
+ 12,12,12, 9,10,10,11,11,10,11,11,12,12,10,11,10,
+ 12,12,11,12,12,12,12,11,12,12,12,12,11,11,11,12,
+ 12,11,11,12,12,12,11,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,11,11,11,12,12,11,12,12,12,12,11,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12, 9,10,
+ 10,11,11,10,10,11,12,12,10,11,11,12,12,11,11,12,
+ 12,12,11,12,12,12,12,10,10,11,11,12,11,11,12,12,
+ 12,11,11,12,12,12,11,11,12,12,13,12,12,12,12,12,
+ 10,11,11,12,12,11,12,11,12,12,11,12,11,12,12,12,
+ 12,12,12,12,12,12,12,12,12,11,11,12,12,12,12,12,
+ 12,12,12,12,12,12,12,13,12,12,13,12,13,12,12,13,
+ 13,13,11,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,13,12,12,12,12,13,12, 8,10,10,11,11,
+ 10,11,11,12,12,10,11,10,12,12,11,12,12,12,12,11,
+ 12,12,12,12,10,11,10,12,12,10,10,11,12,12,11,12,
+ 12,12,12,12,12,12,12,13,12,12,12,13,13,10,11,11,
+ 12,12,11,12,12,12,12,10,12,11,12,12,12,12,12,13,
+ 13,12,13,12,13,12,11,12,12,12,12,11,12,12,12,13,
+ 12,12,12,13,13,12,12,13,12,13,12,13,13,13,13,11,
+ 12,12,12,12,12,12,12,13,13,12,12,12,13,12,12,13,
+ 13,13,13,12,13,12,13,12,11,11,11,12,12,11,12,12,
+ 12,13,11,12,12,12,12,12,12,12,13,13,12,12,13,13,
+ 13,11,12,12,12,12,12,12,12,12,13,12,12,13,13,13,
+ 12,12,13,13,13,13,13,13,13,13,11,12,12,12,12,12,
+ 13,12,13,13,12,12,12,13,13,12,13,13,13,13,12,13,
+ 13,13,13,12,12,12,12,13,12,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,12,12,12,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,10,11,11,12,12,11,12,12,12,13,11,
+ 12,12,13,12,12,13,13,13,13,12,13,13,13,13,11,12,
+ 12,12,12,12,12,12,13,13,12,13,12,13,13,13,13,13,
+ 13,13,13,13,13,13,13,11,12,12,13,12,12,13,12,13,
+ 13,12,13,12,13,13,13,13,13,13,13,13,13,13,13,13,
+ 12,13,13,13,13,12,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,12,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13, 8, 9, 9,11,11, 9,10,10,11,12, 9,10,10,11,
+ 11,10,11,11,12,12,10,11,11,12,12, 9,10,10,11,11,
+ 10,10,11,12,12,10,11,11,12,12,11,11,12,12,12,11,
+ 12,12,12,12, 9,10,10,11,11,10,11,11,12,12,10,11,
+ 10,12,12,11,12,12,12,12,11,12,11,12,12,11,11,11,
+ 12,12,11,11,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,11,11,11,12,12,11,12,12,12,12,
+ 11,12,11,12,12,12,12,12,12,12,12,12,12,12,12, 8,
+ 10,10,11,11,10,10,11,12,12,10,11,11,12,12,11,12,
+ 12,12,12,11,12,12,12,12,10,11,11,12,12,10,11,12,
+ 12,12,11,12,12,12,12,12,12,12,12,13,12,12,12,13,
+ 13,10,10,11,12,12,11,12,12,12,12,10,11,10,12,12,
+ 12,12,12,13,13,12,12,12,13,12,11,12,12,12,12,11,
+ 12,12,12,13,12,12,12,13,13,12,12,13,12,13,12,13,
+ 13,13,13,11,12,12,12,12,12,12,12,13,13,11,12,12,
+ 13,12,12,13,13,13,13,12,13,12,13,12, 9,10,10,11,
+ 11,10,11,11,12,12,10,11,11,12,12,11,12,12,12,12,
+ 11,12,11,12,12,10,11,11,12,12,11,11,12,12,12,11,
+ 11,12,12,12,12,12,12,12,13,12,12,12,13,12,10,11,
+ 10,12,11,11,12,11,12,12,11,12,11,12,12,12,12,12,
+ 12,12,12,12,11,12,12,11,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,13,12,13,12,13,13,13,13,
+ 11,12,11,12,12,12,12,12,13,12,12,12,12,12,12,12,
+ 13,12,13,13,12,12,12,13,12,10,11,11,12,12,11,12,
+ 12,12,13,11,12,12,13,12,12,12,13,13,13,12,13,13,
+ 13,13,11,12,12,12,13,12,12,13,13,13,12,12,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,11,12,12,12,12,
+ 12,12,13,13,13,12,13,12,13,13,13,13,13,13,13,13,
+ 13,13,13,13,12,13,13,13,13,12,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,12,12,13,
+ 13,13,13,13,13,13,13,12,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,11,11,11,12,12,11,12,12,12,12,
+ 11,12,12,12,12,12,12,13,13,13,12,13,12,13,13,11,
+ 12,12,12,12,12,12,13,13,13,12,12,13,13,13,12,13,
+ 13,13,13,12,13,13,13,13,11,12,12,12,12,12,13,12,
+ 13,13,12,12,12,13,12,13,13,13,13,13,12,13,12,13,
+ 13,12,12,12,13,13,12,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,12,12,12,13,12,13,
+ 13,13,13,13,12,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,10,11,11,12,12,11,12,12,12,12,11,12,12,
+ 12,12,12,12,12,13,13,12,12,12,13,13,11,12,12,12,
+ 12,11,12,12,13,13,12,12,12,13,13,12,12,13,13,13,
+ 12,13,13,13,13,11,12,12,12,12,12,12,12,13,13,12,
+ 12,12,13,12,12,13,13,13,13,12,13,12,13,13,12,12,
+ 12,12,12,12,12,13,13,13,12,13,13,13,13,12,13,13,
+ 13,13,13,13,13,13,13,12,12,12,13,12,12,13,13,13,
+ 13,12,13,12,13,13,13,13,13,13,13,13,13,13,13,13,
+ 10,11,11,12,12,11,12,12,12,13,11,12,12,13,12,12,
+ 12,12,13,13,12,12,12,13,13,11,12,12,12,12,12,12,
+ 13,13,13,12,12,12,13,13,12,12,13,13,13,12,13,13,
+ 13,13,11,12,12,12,12,12,12,12,13,13,12,12,12,13,
+ 13,12,13,13,13,13,12,13,13,13,13,12,12,12,12,13,
+ 12,12,13,13,13,12,13,13,13,13,12,13,13,13,13,13,
+ 13,13,13,13,12,12,12,13,13,13,13,13,13,13,12,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,10,11,11,
+ 12,12,11,12,12,12,13,11,12,12,13,12,12,13,13,13,
+ 13,12,13,12,13,13,11,12,12,13,13,12,12,12,13,13,
+ 12,12,13,13,13,12,13,13,13,13,13,13,13,13,13,11,
+ 12,12,13,12,12,13,12,13,13,12,13,12,13,13,13,13,
+ 13,13,13,12,13,13,13,13,12,12,12,13,13,12,13,13,
+ 13,13,12,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,12,12,12,13,13,12,13,13,13,13,12,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,11,11,11,12,12,11,
+ 12,12,12,12,11,12,12,12,12,12,12,12,13,13,12,12,
+ 12,13,13,11,12,12,12,12,12,12,12,12,13,12,12,12,
+ 13,13,12,12,13,13,13,12,13,13,13,13,11,12,12,12,
+ 12,12,12,12,13,13,12,12,12,13,12,12,13,13,13,13,
+ 12,13,12,13,13,12,12,12,12,12,12,12,13,12,13,12,
+ 13,13,13,13,12,13,13,12,13,13,13,13,13,13,12,12,
+ 12,12,12,12,13,13,13,13,12,13,12,13,13,13,13,13,
+ 13,13,12,13,13,13,12,10,11,11,12,12,11,12,12,12,
+ 12,11,12,12,12,12,12,12,12,13,13,12,13,12,13,13,
+ 11,12,12,12,12,12,12,12,13,13,12,12,12,13,13,12,
+ 12,13,13,13,13,13,13,13,13,11,12,12,12,12,12,13,
+ 12,13,13,12,13,12,13,13,12,13,13,13,13,12,13,12,
+ 13,13,12,12,12,12,12,12,13,13,13,13,12,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,12,12,12,13,12,
+ 12,13,13,13,13,12,13,12,13,13,13,13,13,13,13,13,
+ 13,13,13,13,10,11,11,12,12,11,12,12,12,12,11,12,
+ 12,12,12,12,12,12,13,13,12,12,12,13,13,11,12,12,
+ 12,12,12,12,12,13,13,12,12,12,13,13,12,12,13,13,
+ 13,12,12,13,13,13,11,12,11,12,12,12,12,12,13,13,
+ 11,12,12,13,13,12,13,13,13,13,12,13,12,13,13,12,
+ 12,12,12,12,12,13,13,13,13,12,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,12,12,12,13,12,12,13,13,
+ 13,13,12,13,12,13,13,13,13,13,13,13,12,13,13,13,
+ 13,10,11,11,12,12,11,12,12,12,13,11,12,12,13,12,
+ 12,12,13,13,13,12,13,13,13,13,11,12,12,13,13,12,
+ 12,13,13,13,12,12,13,13,13,12,13,13,13,13,13,13,
+ 13,13,13,11,12,12,13,12,12,13,12,13,13,12,12,12,
+ 13,13,12,13,13,13,13,13,13,13,13,13,12,12,13,13,
+ 13,12,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,12,12,12,13,13,13,13,13,13,13,12,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,10,12,
+ 11,12,12,11,12,12,12,13,11,12,12,12,12,12,12,12,
+ 13,13,12,12,12,13,13,11,12,12,12,13,12,12,12,13,
+ 13,12,12,12,13,13,12,13,13,13,13,12,13,13,13,13,
+ 11,12,12,13,12,12,12,12,13,13,12,12,12,13,13,12,
+ 13,13,13,13,12,13,12,13,13,12,13,12,13,13,12,13,
+ 13,13,13,12,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,12,12,12,13,12,13,13,13,13,13,12,13,12,13,
+ 13,13,13,13,13,13,12,13,13,13,13,10,11,11,12,12,
+ 11,12,12,12,13,11,12,12,12,12,12,12,12,13,13,12,
+ 12,12,13,13,11,12,12,12,12,12,12,13,13,13,12,13,
+ 13,13,13,12,12,13,13,13,13,13,13,13,13,11,12,12,
+ 12,12,12,13,12,13,13,12,12,12,13,13,12,13,13,13,
+ 13,12,13,12,13,13,12,12,12,12,13,12,13,13,13,13,
+ 12,13,13,13,13,12,13,13,13,13,13,13,13,13,13,12,
+ 12,12,12,12,12,13,13,13,13,12,13,13,13,13,13,13,
+ 13,13,13,12,13,13,13,13,11,12,11,12,12,11,12,12,
+ 12,12,11,12,12,12,12,12,12,12,12,13,12,12,12,13,
+ 12,11,12,12,12,12,12,12,12,12,13,12,12,12,13,13,
+ 12,12,13,13,13,12,13,13,13,13,11,12,12,12,12,12,
+ 12,12,13,13,12,12,12,13,12,12,13,13,13,13,12,13,
+ 12,13,13,12,12,12,12,12,12,12,13,13,13,12,13,13,
+ 13,13,13,13,13,12,13,13,13,13,13,13,12,12,12,12,
+ 12,12,13,13,13,13,12,13,12,13,12,13,13,13,13,13,
+ 13,13,13,13,12,
+};
+
+static const static_codebook _44p5_p4_1 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p5_p4_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p5_p4_1,
+ 0
+};
+
+static const long _vq_quantlist__44p5_p5_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p5_p5_0[] = {
+ 1, 6, 6,10,10, 6, 7, 9,11,13, 5, 9, 7,13,11, 8,
+ 11,12,13,15, 8,12,11,15,13, 6, 7, 8,11,11, 7, 8,
+ 10,11,13, 9,10,10,13,13,11,11,13,12,16,12,13,13,
+ 16,15, 6, 8, 7,11,11, 9,10,10,13,13, 7,10, 7,13,
+ 11,12,13,13,15,16,11,13,11,16,12,10,11,11,11,13,
+ 11,11,13,12,15,13,13,13,14,15,13,12,15,12,17,15,
+ 16,16,16,16,10,11,11,14,11,13,13,13,15,14,11,13,
+ 11,15,12,15,15,16,16,16,13,15,12,17,12, 6, 8, 9,
+ 12,12, 9,10,12,13,15, 9,11,11,15,14,12,13,15,16,
+ 18,13,14,14,17,16, 9,10,11,13,14,11,10,13,14,16,
+ 11,12,12,15,15,14,13,16,15,18,14,15,15,17,17, 9,
+ 11,11,14,14,11,12,13,15,16,11,13,11,15,14,15,15,
+ 15,17,18,14,15,14,17,15,13,14,14,15,16,14,14,15,
+ 15,17,15,16,15,17,17,16,16,17,15,19,17,18,18,19,
+ 18,13,14,14,16,15,15,15,16,17,17,14,15,14,18,15,
+ 17,17,17,19,19,16,17,15,19,16, 6, 9, 8,13,12, 9,
+ 11,11,14,15, 9,12,10,15,13,13,14,14,16,17,12,15,
+ 13,18,16, 9,11,11,14,14,11,11,13,14,15,11,13,12,
+ 16,15,14,14,15,15,18,14,15,15,18,17, 9,11,10,14,
+ 13,11,12,12,15,15,11,13,10,16,14,14,15,15,16,18,
+ 14,16,13,18,15,13,14,14,16,16,14,14,15,15,17,15,
+ 16,15,17,17,16,16,17,16,19,17,18,17,18,19,13,14,
+ 14,16,15,15,15,15,17,17,14,15,14,17,15,17,17,17,
+ 18,19,16,17,15,19,15,11,13,13,15,16,13,14,15,16,
+ 18,14,15,15,17,17,16,16,18,18,20,17,18,17,19,20,
+ 13,14,14,16,17,15,15,16,17,18,15,16,16,17,17,18,
+ 17,19,18,19,18,18,18,19,21,14,14,15,16,17,15,15,
+ 16,18,18,15,16,16,17,18,18,18,19,19,21,18,19,19,
+ 22,20,16,16,17,17,19,17,17,17,18,20,17,18,18,20,
+ 19,19,19,20,19, 0,19,19,20,20,21,17,17,17,19,18,
+ 18,18,20,19,19,18,18,18,20,20,19,19,20,20,20,20,
+ 21,20,21,19,11,13,13,16,15,14,15,15,17,17,14,15,
+ 14,18,16,16,18,18,20,19,16,19,17,21,18,13,14,15,
+ 16,17,15,15,16,18,18,15,16,15,19,18,18,18,18,19,
+ 19,18,18,18,22,20,13,14,14,16,16,15,16,16,18,17,
+ 15,16,15,18,17,18,18,18,19,19,17,18,17,21,18,16,
+ 17,17,18,18,17,18,19,19,19,18,20,18,19,19,19,20,
+ 21,19,21,20,20,20, 0,21,16,17,17,19,19,18,18,18,
+ 19,21,17,18,18,19,18,20,19,21,20,21,19,20,20,22,
+ 19, 7, 9, 9,13,13, 8,10,11,14,15, 9,12,11,15,14,
+ 11,13,14,16,17,13,15,14,17,16, 8,10,11,14,14,10,
+ 10,12,14,16,11,12,12,16,15,13,12,15,15,18,14,15,
+ 15,19,17, 9,11,11,14,14,11,12,12,15,15,11,13,11,
+ 16,14,14,15,14,17,17,14,16,14,18,15,12,13,14,15,
+ 16,13,13,15,14,17,15,15,15,17,17,15,14,17,14,19,
+ 17,18,18,19,18,13,14,14,16,16,15,15,15,17,17,14,
+ 15,14,18,15,17,18,17,18,17,16,18,16,19,15, 7,10,
+ 10,13,13, 9,10,12,14,15,10,12,11,15,14,12,13,14,
+ 16,17,13,15,14,18,16,10,10,12,13,14,10,10,13,13,
+ 16,12,12,13,15,15,13,12,15,15,18,15,15,16,18,17,
+ 10,11,11,14,14,12,13,13,15,16,10,13,10,16,14,14,
+ 15,15,17,17,14,15,13,17,15,13,13,14,15,16,14,13,
+ 15,14,18,15,15,16,16,17,16,15,18,15,18,17,18,18,
+ 18,18,13,15,14,17,16,15,16,16,17,17,14,15,13,17,
+ 15,17,17,18,18,18,16,17,14,20,14, 8,10,10,14,14,
+ 11,11,13,14,16,11,13,11,16,14,14,15,16,16,18,14,
+ 16,15,18,16,10,12,11,15,14,11,11,13,14,16,13,14,
+ 13,16,15,15,14,16,15,19,16,17,16,20,18,10,11,12,
+ 14,15,13,13,14,16,16,11,14,11,16,14,16,16,17,18,
+ 19,15,17,14,20,15,14,15,14,17,16,13,14,15,15,18,
+ 16,17,16,19,18,16,15,18,15,19,18,19,18,21,21,14,
+ 14,15,16,17,16,16,17,18,18,13,15,14,17,15,18,18,
+ 19,18,22,16,18,15,21,15,12,13,14,16,16,14,14,16,
+ 16,18,14,15,15,17,18,16,16,18,18,20,18,18,17,20,
+ 20,13,14,15,15,17,15,14,16,16,18,16,16,16,17,19,
+ 17,15,18,17,21,18,18,18,19,19,14,15,15,18,17,15,
+ 16,16,18,19,15,16,15,18,18,17,18,18,20,21,17,19,
+ 17,20,19,16,16,17,16,19,17,17,18,17,20,18,18,18,
+ 18,19,19,18,20,17,22,20,20,19,20,20,17,17,18,18,
+ 19,18,18,20,21,20,17,18,17,20,20,21,21,21,21,21,
+ 19,21,18,22,20,11,13,13,17,16,14,14,16,16,18,14,
+ 16,14,18,16,17,18,19,19,20,18,19,18,21,19,14,15,
+ 14,17,16,14,14,16,18,18,16,17,16,18,17,18,17,19,
+ 18,20,19,19,18,20,20,13,14,15,16,17,16,16,17,18,
+ 19,14,16,14,19,17,18,19,18,20,20,18,20,17,21,18,
+ 17,17,17,19,18,16,17,18,18,19,18,19,18,21,21,18,
+ 18,20,17,21,19,20,20,22,21,16,17,18,18,19,18,18,
+ 19,21,20,16,17,17,20,18,21,21,22,21,22,18,21,18,
+ 0,18, 7, 9, 9,13,13, 9,11,12,14,15, 8,11,10,15,
+ 14,13,14,15,16,18,11,14,13,17,15, 9,11,11,14,14,
+ 11,11,13,14,16,11,12,12,15,15,14,14,16,15,18,14,
+ 14,15,17,17, 8,11,10,14,14,11,12,12,15,15,10,12,
+ 10,16,14,14,15,15,17,18,13,15,12,18,15,13,14,14,
+ 16,16,14,14,15,15,17,15,15,15,16,17,16,15,17,15,
+ 19,17,17,17,18,18,12,14,13,16,15,15,15,15,17,17,
+ 13,15,13,17,14,17,18,18,18,19,15,17,14,19,14, 8,
+ 10,10,14,14,11,11,13,14,16,11,13,11,16,14,14,15,
+ 16,17,19,14,16,15,18,17,10,12,11,15,14,11,11,14,
+ 14,17,13,14,13,17,15,15,14,17,15,19,16,17,16,19,
+ 17,10,11,12,14,15,13,13,14,15,17,11,13,11,17,14,
+ 16,16,17,18,19,15,16,14,18,15,14,15,14,16,16,13,
+ 14,15,15,18,16,16,16,18,18,16,15,18,15,20,18,19,
+ 18,21,18,14,14,15,16,17,16,16,17,17,18,13,15,14,
+ 17,16,19,19,19,19,19,15,18,15,20,15, 7,10,10,13,
+ 13,10,11,12,14,15, 9,12,10,15,14,13,14,15,16,17,
+ 12,15,13,17,16,10,11,11,14,14,10,10,13,14,16,12,
+ 13,13,16,15,14,13,16,15,18,15,15,16,17,17,10,12,
+ 10,14,13,12,13,12,15,15,10,13,10,16,13,15,16,15,
+ 17,18,13,16,12,18,15,13,14,14,16,17,14,13,15,15,
+ 18,15,16,15,17,17,16,14,17,15,19,17,18,18,19,19,
+ 13,15,13,17,14,15,15,15,18,17,14,15,13,17,14,18,
+ 17,18,18,19,15,17,15,19,15,11,13,13,16,17,14,14,
+ 16,16,18,14,16,15,18,17,17,18,19,18,21,18,18,17,
+ 20,18,13,15,14,17,16,14,14,16,17,18,16,17,16,19,
+ 17,18,17,19,18,22,18,19,19,21,21,13,14,15,16,18,
+ 16,16,17,17,20,14,16,14,18,17,18,18,19,19,21,17,
+ 18,17,21,18,17,18,17,19,18,16,17,17,18,19,18,18,
+ 18,22,22,18,17,19,17, 0,20,21,19,21,20,17,17,18,
+ 18,21,18,18,18,19,21,17,17,17,19,19,20,20,22,21,
+ 21,19,20,18,20,17,12,14,13,17,16,14,15,15,17,18,
+ 14,16,14,18,16,17,18,18,21,20,16,18,16,21,18,14,
+ 15,15,17,17,15,15,16,18,18,15,17,16,18,18,17,17,
+ 19,19,20,18,19,18,20,19,14,15,14,17,15,15,16,16,
+ 18,17,15,16,14,19,15,18,18,18,19,20,17,20,15,21,
+ 17,16,17,18,18,19,17,17,18,18,20,18,19,18,19,21,
+ 19,18,19,19,21,20, 0,19,21,20,16,17,16,19,16,18,
+ 18,18,19,19,17,18,17,20,17,19,20,20,22, 0,19,20,
+ 17,21,17,11,13,14,16,17,14,15,15,17,18,14,15,15,
+ 18,18,16,17,17,19,20,16,18,17,19,21,13,14,15,17,
+ 17,14,15,16,17,19,15,16,16,18,19,16,17,18,19,21,
+ 17,18,20,21,21,13,15,15,17,17,15,16,16,18,19,15,
+ 16,16,18,19,17,17,18,19,22,17,19,18,22,19,15,16,
+ 17,19,19,16,17,18,18,20,17,18,18,19,20,19,18,20,
+ 18,22,20,19,19,22,21,16,17,17,18,19,18,18,18,19,
+ 20,17,18,18,20,19,20,19,20,22,20,19,20,21,21,20,
+ 12,14,14,16,16,13,14,16,17,18,14,16,15,18,18,15,
+ 17,17,19,19,17,18,18,19,19,13,14,15,16,17,14,14,
+ 16,16,20,15,16,16,17,19,16,15,18,17,20,18,17,19,
+ 19,19,14,15,15,17,17,16,16,16,18,18,15,16,15,19,
+ 18,17,18,18,20,21,17,18,17,21,18,16,15,17,17,19,
+ 17,15,18,17,20,19,17,18,19,20,18,16,19,17,22,20,
+ 19,20,19,20,17,17,18,19,19,18,18,19,20,20,17,18,
+ 17,18,18,21,21,20,20,21,18,20,17,21,19,11,14,14,
+ 16,17,15,14,16,17,19,14,16,14,18,17,18,18,19,19,
+ 21,17,19,18,20,20,13,15,14,17,17,14,14,16,17,18,
+ 16,17,16,19,18,18,17,19,18,20,18,21,18,20,20,13,
+ 15,15,16,17,16,16,17,18,19,14,16,15,19,18,19,19,
+ 19,21,20,18,19,17,20,18,16,17,16,19,18,16,17,17,
+ 19,20,17,19,18,20,19,18,17,21,18, 0,21,20,20, 0,
+ 20,17,17,18,18,19,18,19,19,20,22,16,17,17,20,18,
+ 21,22,20,20,22,18,22,18,22,18,12,14,14,17,17,14,
+ 15,16,17,19,14,16,15,17,17,17,17,18,18,21,17,19,
+ 17,20,19,14,15,15,16,18,15,14,16,16,19,16,17,16,
+ 19,18,17,16,20,17,20,18,20,19,19,20,14,15,15,18,
+ 17,16,16,17,18,19,14,16,15,19,17,18,21,18,19,21,
+ 17,18,17,19,18,17,17,18,17,20,17,16,18,17,21,18,
+ 19,19,19,19,18,17,19,17,20,20,21,20,21,20,17,17,
+ 17,19,19,19,18,18,20,21,16,18,16,19,18,20,20,21,
+ 21,20,18,19,16, 0,17,12,14,14,17,17,15,15,18,17,
+ 19,15,18,15,20,16,20,19,21,18,22,20,20,20,22,19,
+ 14,16,14,20,17,14,15,17,17,20,18,18,17,20,18,18,
+ 17,19,17,21,20,21,20, 0,21,14,15,16,17,19,18,17,
+ 19,18,21,14,18,15,21,17,21,20,21,20, 0,18,21,17,
+ 21,17,18,19,17,20,18,16,17,17,19,19,19,21,20, 0,
+ 20,18,17,21,17, 0,22, 0,21, 0,22,17,17,19,18,20,
+ 20,20,21,19,22,16,17,18,20,18,22,22, 0,22, 0,17,
+ 21,17,22,17,11,14,13,16,16,14,15,15,17,18,14,15,
+ 14,18,17,17,18,18,19,20,16,17,17,21,19,13,14,15,
+ 17,17,15,16,16,18,18,15,16,16,19,18,18,18,18,19,
+ 20,17,18,18,20,19,13,15,14,17,17,15,16,16,17,18,
+ 14,16,15,19,17,17,18,19,21,21,17,18,17,20,18,16,
+ 17,17,19,19,17,18,19,19,20,18,19,18,21,21,21,20,
+ 19,21,22,20,20,19,21,20,15,17,16,19,19,17,18,18,
+ 20,21,16,18,17,20,18,19,19,21,21,21,19,19,19,20,
+ 18,11,14,13,17,16,14,14,16,16,19,14,16,15,19,16,
+ 18,18,18,19,22,17,18,17,20,19,13,15,14,17,17,15,
+ 15,16,17,19,16,17,16,20,18,18,17,19,18,21,19,19,
+ 18,22, 0,13,14,15,17,18,16,16,17,17,19,14,16,15,
+ 19,18,18,19,19,20,21,18,18,17,20,18,17,18,17,20,
+ 18,16,17,17,18,20,18,19,18,20,20,18,18,21,17,21,
+ 20,21,21, 0,19,16,16,18,18,19,19,18,20,19,20,16,
+ 17,17,20,18,21,20,21,22,22,18,20,17,21,17,12,14,
+ 14,17,16,14,15,16,18,18,13,15,14,18,17,17,18,18,
+ 19,19,15,17,16,19,19,14,15,15,17,17,15,15,16,18,
+ 19,15,16,16,19,18,17,17,18,18,20,18,18,18,21,20,
+ 13,15,14,17,16,15,16,15,18,18,14,16,14,18,17,18,
+ 18,18,19,21,16,18,16,20,17,17,18,17,18,19,17,17,
+ 18,18,19,18,19,19,21,19,19,18,20,18,21,21,20,20,
+ 21,20,16,17,15,20,17,17,19,17,19,19,17,18,15,20,
+ 17,19,20,19,21,22,17,20,16, 0,17,12,14,14,17,18,
+ 16,15,18,16,20,16,18,15,21,17,20,18,21,19,22,19,
+ 21,19, 0,19,14,16,15,19,17,14,15,17,16,21,18,19,
+ 18,21,17,19,17,21,17,22,20,21,21, 0,21,14,15,16,
+ 17,19,18,17,19,18,21,14,17,15,20,17,21,22,21,20,
+ 22,18,21,17,21,17,17,19,17,21,18,16,17,17,19,20,
+ 19,21,20,21,20,17,18,20,17,21, 0,22,20,21,22,17,
+ 17,20,18,21,21,20,22,20,21,16,17,17,21,19, 0,22,
+ 0,21,21,18,22,17,21,17,12,14,14,17,16,14,15,16,
+ 17,18,14,16,15,18,17,17,17,20,19,20,16,18,17,21,
+ 18,14,15,15,17,17,14,15,16,17,19,16,17,16,18,18,
+ 17,16,19,18,19,18,19,18,21,20,14,15,15,18,17,16,
+ 16,16,19,18,15,16,14,20,16,18,18,19,19,20,16,19,
+ 16,21,17,17,17,18,19,19,16,16,18,18,19,19,19,18,
+ 20,20,18,16,19,18,20,22,21,20,19,20,16,18,17,20,
+ 16,18,19,18,19,18,16,18,16,20,17,21,20,21,20,20,
+ 18,19,17,21,16,
+};
+
+static const static_codebook _44p5_p5_0 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p5_p5_0,
+ 1, -528744448, 1616642048, 3, 0,
+ (long *)_vq_quantlist__44p5_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44p5_p5_1[] = {
+ 3,
+ 2,
+ 4,
+ 1,
+ 5,
+ 0,
+ 6,
+};
+
+static const long _vq_lengthlist__44p5_p5_1[] = {
+ 2, 3, 3, 3, 3, 3, 3,
+};
+
+static const static_codebook _44p5_p5_1 = {
+ 1, 7,
+ (long *)_vq_lengthlist__44p5_p5_1,
+ 1, -533200896, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p5_p5_1,
+ 0
+};
+
+static const long _vq_quantlist__44p5_p6_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p5_p6_0[] = {
+ 1, 5, 5, 5, 7, 9, 5, 9, 7, 5, 7, 8, 7, 7,10, 9,
+ 9,10, 5, 8, 7, 9,10, 9, 7,10, 7, 6, 9, 9, 9,10,
+ 12,10,12,11, 9,10,11,11,10,13,12,12,13,10,11,11,
+ 12,13,13,11,13,11, 6, 9, 9,10,11,12, 9,12,11,10,
+ 11,11,11,11,13,12,13,13, 9,11,10,12,13,13,11,13,
+ 10, 6, 9,10, 9,11,12,10,12,11, 9,10,11,10,10,13,
+ 11,13,13,10,11,11,12,13,12,11,13,11, 7, 9,10, 9,
+ 10,12,10,11,11,10,10,11,10,10,12,12,11,12,10,11,
+ 10,12,12,12,10,12,10, 7,10,10,11,11,13,11,13,11,
+ 10,12,11,11,10,13,13,14,13,10,11,12,13,13,14,11,
+ 13,10, 6,10, 9,10,11,12, 9,12,11, 9,11,11,11,11,
+ 13,12,12,13, 9,11,10,12,13,13,10,13,10, 7,10,10,
+ 11,11,14,11,13,11,10,12,11,11,10,14,13,14,13,10,
+ 11,12,13,13,14,11,13,10, 7,10, 9,10,10,12, 9,12,
+ 10,10,11,11,10,10,12,12,12,12, 9,11,10,11,12,12,
+ 10,12, 9,
+};
+
+static const static_codebook _44p5_p6_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p5_p6_0,
+ 1, -527106048, 1620377600, 2, 0,
+ (long *)_vq_quantlist__44p5_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44p5_p6_1[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p5_p6_1[] = {
+ 2, 6, 6, 5, 7, 8, 5, 8, 7, 6, 7, 7, 7, 7, 8, 8,
+ 8, 8, 6, 7, 7, 7, 8, 8, 7, 8, 7, 6, 8, 8, 8, 9,
+ 10, 8, 9, 9, 8, 9, 9, 9, 9,10,10,10,10, 8, 9, 9,
+ 10,10,10, 9,10,10, 6, 8, 8, 8, 9, 9, 8,10, 9, 9,
+ 9, 9, 9, 9,10,10,10,10, 8, 9, 9,10,10,10, 9,10,
+ 9, 6, 8, 9, 8, 9, 9, 8, 9, 9, 8, 9, 9, 9, 9,10,
+ 9,10,10, 8, 9, 9, 9,10,10, 9,10, 9, 7, 8, 9, 8,
+ 9, 9, 9, 9, 9, 8, 9, 9, 9, 9, 9, 9, 9, 9, 8, 9,
+ 9, 9, 9, 9, 9, 9, 9, 7, 9, 9, 9,10,10, 9,10,10,
+ 9,10, 9, 9, 9,10,10,10,10, 9,10, 9,10,10,10, 9,
+ 10, 9, 6, 8, 8, 8, 9, 9, 8, 9, 9, 8, 9, 9, 9, 9,
+ 10, 9,10,10, 8, 9, 9, 9,10,10, 9,10, 9, 7, 9, 9,
+ 9,10,10, 9,10, 9, 9, 9,10,10, 9,10,10,10,10, 9,
+ 9, 9,10,10,10, 9,10, 9, 7, 9, 8, 8, 9, 9, 8, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 8, 9, 8, 9, 9, 9,
+ 9, 9, 9,
+};
+
+static const static_codebook _44p5_p6_1 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p5_p6_1,
+ 1, -530841600, 1616642048, 2, 0,
+ (long *)_vq_quantlist__44p5_p6_1,
+ 0
+};
+
+static const long _vq_quantlist__44p5_p7_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p5_p7_0[] = {
+ 1, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9,
+};
+
+static const static_codebook _44p5_p7_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p5_p7_0,
+ 1, -513979392, 1633504256, 2, 0,
+ (long *)_vq_quantlist__44p5_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44p5_p7_1[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p5_p7_1[] = {
+ 1, 7, 7, 6, 9, 9, 7, 9, 9, 6, 9, 9, 9, 9, 9, 9,
+ 9, 9, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 7, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 7, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,
+};
+
+static const static_codebook _44p5_p7_1 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p5_p7_1,
+ 1, -516716544, 1630767104, 2, 0,
+ (long *)_vq_quantlist__44p5_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44p5_p7_2[] = {
+ 12,
+ 11,
+ 13,
+ 10,
+ 14,
+ 9,
+ 15,
+ 8,
+ 16,
+ 7,
+ 17,
+ 6,
+ 18,
+ 5,
+ 19,
+ 4,
+ 20,
+ 3,
+ 21,
+ 2,
+ 22,
+ 1,
+ 23,
+ 0,
+ 24,
+};
+
+static const long _vq_lengthlist__44p5_p7_2[] = {
+ 1, 2, 3, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9,10,10,11,
+ 11,12,12,13,13,14,14,14,14,
+};
+
+static const static_codebook _44p5_p7_2 = {
+ 1, 25,
+ (long *)_vq_lengthlist__44p5_p7_2,
+ 1, -518864896, 1620639744, 5, 0,
+ (long *)_vq_quantlist__44p5_p7_2,
+ 0
+};
+
+static const long _vq_quantlist__44p5_p7_3[] = {
+ 12,
+ 11,
+ 13,
+ 10,
+ 14,
+ 9,
+ 15,
+ 8,
+ 16,
+ 7,
+ 17,
+ 6,
+ 18,
+ 5,
+ 19,
+ 4,
+ 20,
+ 3,
+ 21,
+ 2,
+ 22,
+ 1,
+ 23,
+ 0,
+ 24,
+};
+
+static const long _vq_lengthlist__44p5_p7_3[] = {
+ 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5,
+};
+
+static const static_codebook _44p5_p7_3 = {
+ 1, 25,
+ (long *)_vq_lengthlist__44p5_p7_3,
+ 1, -529006592, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44p5_p7_3,
+ 0
+};
+
+static const long _huff_lengthlist__44p5_short[] = {
+ 4, 7,12,14,15,18,20,20, 5, 3, 4, 6, 9,11,15,19,
+ 9, 4, 3, 4, 7, 9,13,18,11, 6, 3, 3, 5, 8,13,19,
+ 14, 9, 6, 5, 7,10,16,20,16,11, 9, 8,10,10,14,16,
+ 21,14,13,11, 8, 7,11,14,21,14,13, 9, 6, 5,10,12,
+};
+
+static const static_codebook _huff_book__44p5_short = {
+ 2, 64,
+ (long *)_huff_lengthlist__44p5_short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44p6_l0_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44p6_l0_0[] = {
+ 1, 4, 4, 7, 7,10,10,12,12,12,12,13,12, 5, 5, 5,
+ 8, 6,11, 9,12,12,13,12,12,12, 4, 5, 5, 6, 8, 9,
+ 11,12,12,13,12,12,12, 7, 7, 8, 9, 9,11, 8,12, 9,
+ 12,12,12,12, 7, 8, 8, 9, 9, 8,11, 9,12,12,12,11,
+ 12,10,10,10,11,11,11,11,11,10,11,11,12,11,10,10,
+ 10,11,11,11,11,10,11,11,11,11,12,11,11,11,12,11,
+ 12,11,12,11,13,11,13,11,11,11,11,11,12,11,12,10,
+ 13,11,12,11,13,12,12,12,13,12,13,13,13,12,14,12,
+ 14,13,12,12,12,12,13,13,13,12,14,12,14,13,14,13,
+ 14,14,14,14,14,14,14,14,15,14,15,14,13,14,13,14,
+ 14,14,14,14,15,14,14,14,15,
+};
+
+static const static_codebook _44p6_l0_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44p6_l0_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44p6_l0_0,
+ 0
+};
+
+static const long _vq_quantlist__44p6_l0_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p6_l0_1[] = {
+ 4, 4, 4, 5, 5, 4, 5, 5, 5, 5, 4, 5, 5, 5, 5, 5,
+ 5, 5, 4, 5, 5, 5, 5, 5, 4,
+};
+
+static const static_codebook _44p6_l0_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44p6_l0_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p6_l0_1,
+ 0
+};
+
+static const long _vq_quantlist__44p6_l1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p6_l1_0[] = {
+ 1, 3, 2, 5, 5, 6, 6, 6, 6,
+};
+
+static const static_codebook _44p6_l1_0 = {
+ 2, 9,
+ (long *)_vq_lengthlist__44p6_l1_0,
+ 1, -516716544, 1630767104, 2, 0,
+ (long *)_vq_quantlist__44p6_l1_0,
+ 0
+};
+
+static const long _huff_lengthlist__44p6_lfe[] = {
+ 2, 3, 1, 3,
+};
+
+static const static_codebook _huff_book__44p6_lfe = {
+ 2, 4,
+ (long *)_huff_lengthlist__44p6_lfe,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44p6_long[] = {
+ 2, 7,13,15,16,17,19,20, 6, 3, 4, 7, 9,10,12,15,
+ 13, 4, 3, 4, 7, 8,11,13,14, 7, 4, 4, 6, 7,10,11,
+ 16, 9, 7, 6, 7, 8, 9,10,16, 9, 8, 7, 7, 6, 8, 8,
+ 18,12,10,10, 9, 8, 8, 9,20,14,13,12,11, 8, 9, 9,
+};
+
+static const static_codebook _huff_book__44p6_long = {
+ 2, 64,
+ (long *)_huff_lengthlist__44p6_long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44p6_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p6_p1_0[] = {
+ 2, 5, 5, 5, 7, 7, 5, 7, 7, 5, 7, 7, 7, 8, 9, 7,
+ 9, 9, 5, 7, 7, 7, 9, 9, 7, 9, 8, 5, 7, 8, 8, 9,
+ 10, 8, 9, 9, 8, 9,10, 9,10,12,10,11,11, 8, 9,10,
+ 10,11,11, 9,11,11, 5, 8, 7, 8, 9, 9, 8,10, 9, 8,
+ 10, 9, 9,11,11,10,11,11, 8,10, 9,10,11,11, 9,12,
+ 10, 5, 8, 8, 7, 9,10, 8,10, 9, 7, 9, 9, 9,10,11,
+ 9,11,11, 8,10,10,10,11,11,10,12,11, 7, 9, 9, 9,
+ 10,11, 9,11,11, 9, 9,11,10,10,13,11,11,12, 9,11,
+ 11,11,12,13,11,13,12, 7, 9, 9, 9,11,11, 9,12,10,
+ 9,11,10,10,11,12,11,13,12, 9,11,11,11,13,13,11,
+ 13,11, 5, 8, 8, 8, 9,10, 7,10, 9, 8,10,10,10,11,
+ 11,10,11,11, 7, 9, 9, 9,11,11, 9,11,10, 7, 9, 9,
+ 9,10,12, 9,11,11, 9,11,11,11,11,13,11,13,13, 9,
+ 10,11,11,12,13,10,12,11, 7, 9, 9, 9,11,11, 9,11,
+ 10, 9,11,11,11,12,13,11,13,12, 9,11, 9,11,12,11,
+ 10,13,10,
+};
+
+static const static_codebook _44p6_p1_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p6_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44p6_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44p6_p2_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p6_p2_0[] = {
+ 4, 6, 6, 9, 9, 6, 7, 8,10,10, 6, 8, 7,10,10, 8,
+ 10,10,12,13, 8,10,10,13,12, 6, 8, 8,10,10, 7, 8,
+ 9,10,11, 8, 9, 9,11,11,10,10,11,12,13,10,11,11,
+ 14,13, 6, 8, 8,10,10, 8, 9, 9,11,11, 7, 9, 8,11,
+ 10,10,11,11,13,14,10,11,10,13,12, 9,10,10,12,12,
+ 10,10,11,12,13,10,11,11,13,13,12,12,13,12,15,13,
+ 14,13,15,14, 9,10,10,13,12,10,11,11,13,13,10,11,
+ 10,13,12,13,13,14,14,15,12,13,12,15,12, 6, 8, 8,
+ 10,11, 8, 9,10,11,12, 8, 9, 9,11,11,10,11,12,13,
+ 14,10,11,11,14,13, 8, 9, 9,11,12, 9,10,11,12,13,
+ 9,10,11,12,13,11,11,13,13,15,11,12,12,14,14, 8,
+ 9, 9,12,12, 9,10,11,12,13, 9,10,10,13,12,11,12,
+ 13,14,15,11,12,12,14,14,11,11,12,13,14,11,12,13,
+ 13,15,12,13,13,14,15,13,13,14,14,16,14,15,15,16,
+ 16,11,12,11,14,13,12,13,13,14,14,11,13,12,14,13,
+ 14,15,15,16,16,13,14,14,16,14, 6, 8, 8,11,10, 8,
+ 9, 9,12,11, 8,10, 9,12,11,10,11,11,13,13,10,12,
+ 11,14,13, 8, 9, 9,12,12, 9,10,10,12,13, 9,11,10,
+ 13,12,11,12,12,14,14,11,13,12,15,14, 8, 9, 9,12,
+ 11, 9,10,10,13,12, 9,11,10,13,12,12,12,12,14,14,
+ 11,13,12,15,13,11,11,12,13,14,11,12,13,13,14,12,
+ 13,13,14,15,13,13,14,14,16,14,15,15,16,16,11,12,
+ 11,14,13,12,13,13,15,14,11,13,12,15,13,14,15,15,
+ 16,16,13,15,13,16,14, 9,10,11,12,13,11,11,12,13,
+ 14,11,12,12,13,14,13,13,14,14,16,13,14,14,15,16,
+ 11,11,12,13,14,12,12,13,14,15,12,13,13,14,15,14,
+ 14,15,15,17,14,15,15,16,17,11,12,12,14,14,12,13,
+ 13,14,15,12,13,12,15,15,14,15,15,16,17,14,15,15,
+ 16,16,13,14,14,15,16,14,14,15,15,17,15,15,15,16,
+ 17,16,16,17,16,18,16,17,17,18,18,13,14,14,16,15,
+ 14,15,15,17,16,14,15,15,16,16,16,17,17,18,18,16,
+ 16,16,17,16, 9,11,10,13,12,11,12,12,14,13,11,12,
+ 11,15,13,13,14,14,16,15,13,14,13,17,14,11,12,12,
+ 14,14,12,12,13,15,15,12,13,13,15,14,14,14,15,16,
+ 16,14,15,15,17,16,11,12,11,14,13,12,13,13,15,14,
+ 12,13,12,15,13,14,15,15,16,16,14,15,14,17,15,13,
+ 14,14,15,16,14,15,15,16,17,14,15,15,16,17,16,16,
+ 16,17,17,16,17,17,18,18,13,15,14,16,15,15,15,15,
+ 17,16,14,15,14,17,15,16,17,17,18,18,16,17,16,18,
+ 16, 6, 8, 8,11,11, 8, 9, 9,11,12, 8, 9, 9,12,11,
+ 10,11,11,13,14,10,12,11,14,13, 7, 9, 9,11,12, 9,
+ 10,10,12,13, 9,10,10,13,12,11,11,12,13,15,11,12,
+ 12,15,14, 8, 9, 9,12,11, 9,10,10,13,13, 9,11,10,
+ 13,12,12,12,12,14,15,11,13,12,15,13,10,11,11,13,
+ 14,11,12,12,13,15,11,12,12,14,14,13,13,14,14,16,
+ 14,15,14,16,16,11,12,11,14,13,12,13,13,15,14,11,
+ 13,12,15,13,14,15,15,16,16,13,14,14,16,14, 8, 9,
+ 9,11,12, 9,10,11,12,13, 9,10,10,13,12,11,12,13,
+ 14,15,11,12,12,15,14, 9, 9,11,11,13,10,10,12,12,
+ 14,10,10,11,13,14,12,12,13,14,16,12,13,13,15,15,
+ 9,11,10,13,12,10,11,11,13,14,10,12,11,14,13,12,
+ 13,13,15,16,12,13,13,15,15,11,11,13,13,15,12,12,
+ 14,13,15,13,13,14,14,15,14,14,15,14,17,15,15,15,
+ 16,16,12,13,12,15,14,13,14,14,15,15,12,14,13,15,
+ 14,15,15,15,17,17,14,15,14,17,15, 7, 9, 9,12,11,
+ 9,10,10,12,12, 9,11,10,13,12,11,12,12,14,14,11,
+ 13,12,15,14, 9,10,10,12,12,10,10,11,12,13,10,11,
+ 11,14,13,12,12,13,14,15,12,13,13,16,15, 9,10,10,
+ 13,12,10,11,11,13,13,10,11,10,14,12,13,13,13,15,
+ 15,12,13,12,15,14,11,12,12,14,14,12,12,13,14,15,
+ 13,14,13,15,15,14,13,15,14,16,15,16,15,17,16,12,
+ 12,12,14,14,13,13,14,15,15,12,13,12,15,14,15,15,
+ 16,16,17,14,15,14,17,14,10,11,12,13,14,11,12,13,
+ 14,15,11,12,13,14,15,13,14,15,15,17,14,15,15,16,
+ 16,11,12,13,12,15,12,12,14,13,16,13,13,14,13,16,
+ 14,14,16,14,18,15,15,16,16,17,12,13,12,15,15,13,
+ 14,14,15,16,13,14,13,16,15,15,15,16,17,18,15,15,
+ 15,17,16,14,14,15,14,17,15,14,16,14,17,15,15,16,
+ 15,18,16,16,17,16,19,17,17,17,17,18,14,15,15,17,
+ 16,15,16,16,17,17,15,16,15,18,16,17,17,18,18,18,
+ 16,17,16,18,17,10,11,11,14,13,11,12,12,15,14,11,
+ 13,12,15,14,14,15,15,16,16,14,15,15,17,16,11,12,
+ 12,15,14,12,13,13,15,14,13,14,13,16,14,14,15,15,
+ 16,16,15,16,15,18,16,11,13,12,15,15,13,14,14,15,
+ 15,12,14,13,16,15,15,16,16,17,17,15,16,15,17,16,
+ 14,15,14,16,16,14,15,15,16,16,15,16,15,17,16,16,
+ 16,17,16,17,17,18,17,19,18,14,15,15,17,16,15,16,
+ 16,17,17,15,15,15,18,16,17,18,18,18,18,16,17,16,
+ 19,16, 6, 8, 8,11,11, 8, 9, 9,11,12, 8, 9, 9,12,
+ 11,10,11,12,13,14,10,11,11,14,13, 8, 9, 9,11,12,
+ 9,10,11,12,13, 9,10,10,13,13,11,12,13,13,15,11,
+ 12,12,15,14, 7, 9, 9,12,11, 9,10,10,12,13, 9,10,
+ 10,13,12,11,12,12,14,15,11,12,11,14,13,11,11,12,
+ 13,14,11,12,13,13,15,12,13,13,14,15,13,14,14,14,
+ 16,14,15,15,16,16,10,11,11,14,13,11,12,12,14,14,
+ 11,12,12,15,13,14,14,14,16,16,13,14,13,16,14, 7,
+ 9, 9,11,12, 9,10,10,12,13, 9,10,10,12,12,11,12,
+ 13,14,15,11,12,12,14,14, 9,10,10,12,13,10,10,11,
+ 12,14,10,11,11,13,13,12,12,13,14,15,13,13,13,15,
+ 15, 9,10,10,12,12,10,11,11,13,14,10,11,10,13,12,
+ 12,13,13,15,16,12,13,12,15,14,11,12,13,14,14,12,
+ 12,13,14,15,13,14,13,15,15,14,14,15,14,17,15,16,
+ 15,17,16,11,12,12,14,14,13,13,13,15,15,12,13,12,
+ 15,14,15,15,15,16,17,14,15,14,16,14, 8, 9, 9,12,
+ 11, 9,10,10,12,13, 9,11,10,13,12,11,12,12,14,15,
+ 11,12,12,15,14, 9,10,11,13,13,10,11,12,13,14,10,
+ 11,11,14,13,12,13,13,15,15,12,13,13,16,15, 9,11,
+ 9,13,11,10,11,10,14,13,10,12,10,14,12,12,13,13,
+ 15,15,12,13,12,16,14,12,12,13,14,15,12,13,14,14,
+ 16,13,14,14,15,15,14,14,15,15,17,15,16,15,17,16,
+ 11,13,11,15,13,13,14,13,15,14,12,14,12,16,13,15,
+ 15,15,16,16,14,15,14,17,14,10,11,11,13,14,11,12,
+ 13,14,15,11,12,12,14,15,14,14,15,16,17,14,15,15,
+ 16,16,11,12,13,14,15,12,13,14,15,16,13,14,14,15,
+ 16,15,15,16,16,18,15,16,16,17,17,11,12,12,14,15,
+ 13,13,14,14,16,12,13,13,15,15,15,15,16,16,18,14,
+ 15,15,16,16,14,15,15,16,17,15,15,16,16,17,15,16,
+ 16,17,17,16,16,17,16,19,17,18,17,18,18,14,14,15,
+ 16,16,15,15,16,16,17,14,15,15,16,16,17,17,18,18,
+ 19,16,17,16,17,16,10,12,11,14,13,11,13,12,15,14,
+ 11,13,12,15,14,14,15,15,16,16,13,15,14,17,15,12,
+ 13,13,15,15,13,13,14,15,16,13,14,14,16,16,14,15,
+ 15,17,17,15,16,16,17,17,11,13,12,15,12,13,14,13,
+ 16,13,12,14,12,16,13,15,16,15,17,16,14,16,14,18,
+ 14,14,15,15,16,17,15,15,16,16,17,15,16,16,17,17,
+ 16,16,17,17,18,17,18,17,18,18,14,15,14,17,14,15,
+ 16,15,18,15,15,16,15,18,14,17,17,17,18,17,16,17,
+ 16,19,16, 9,11,11,13,13,10,12,12,14,14,11,12,12,
+ 15,14,13,14,14,16,16,13,14,14,16,16,10,11,12,14,
+ 14,11,12,13,14,15,12,13,13,15,15,13,14,15,16,16,
+ 14,15,15,17,16,11,12,12,15,14,12,13,13,15,15,12,
+ 13,12,15,15,14,15,15,16,17,14,15,14,17,16,12,13,
+ 14,15,16,13,13,14,15,16,13,14,15,16,16,14,15,16,
+ 16,18,15,16,16,18,18,13,14,14,16,15,14,15,15,17,
+ 16,14,15,15,17,16,16,17,17,18,18,16,17,16,18,17,
+ 10,12,12,14,14,11,12,13,15,15,12,13,13,15,15,13,
+ 14,15,16,17,14,15,15,17,16,11,11,13,14,15,12,12,
+ 14,15,16,13,13,14,15,16,14,14,15,16,17,15,15,16,
+ 17,17,12,13,12,15,15,13,14,14,16,16,13,14,13,16,
+ 15,15,16,15,17,17,15,16,15,18,16,13,12,15,14,17,
+ 14,13,16,14,17,14,14,16,15,18,15,14,17,16,18,16,
+ 16,17,17,18,14,15,15,17,16,15,16,16,17,17,15,16,
+ 15,18,16,17,17,17,18,18,16,17,16,19,17,10,11,11,
+ 14,14,11,12,12,15,15,11,13,12,15,15,14,15,14,16,
+ 16,14,15,15,17,16,11,12,12,15,14,12,12,13,15,15,
+ 13,14,13,16,15,14,15,15,16,16,15,16,15,18,17,11,
+ 13,12,15,15,13,14,13,15,15,12,14,13,16,15,15,16,
+ 15,17,17,15,16,15,18,16,13,14,13,16,16,14,15,14,
+ 16,16,14,15,15,17,16,16,16,16,16,18,16,18,17,19,
+ 18,14,15,15,17,16,15,16,16,17,17,15,15,15,17,16,
+ 17,17,18,18,19,16,17,16,18,16,12,13,13,15,16,13,
+ 14,14,16,17,13,14,14,16,16,15,15,16,17,18,15,16,
+ 16,18,17,13,13,14,14,17,14,14,15,15,17,14,14,15,
+ 16,17,15,15,17,16,18,16,17,17,18,18,13,14,14,17,
+ 16,14,15,15,17,17,14,15,14,17,16,16,17,17,18,18,
+ 16,17,16,18,17,15,14,16,13,18,16,15,17,14,19,16,
+ 16,17,15,18,17,16,18,15,19,18,18,18,17,19,15,16,
+ 16,18,17,16,17,17,18,18,16,17,16,19,17,18,19,18,
+ 19,19,17,18,17,20,18,11,12,12,15,15,13,13,14,15,
+ 16,13,14,13,16,15,15,16,16,17,17,15,16,16,18,17,
+ 12,14,13,16,15,13,13,14,15,16,14,15,14,17,16,16,
+ 16,16,16,17,16,17,17,19,17,12,13,14,16,16,14,15,
+ 15,16,17,13,15,13,17,15,16,17,17,18,18,16,17,16,
+ 18,16,15,16,15,17,16,15,15,15,17,17,16,17,16,18,
+ 17,17,16,17,16,18,18,19,18,20,18,15,16,16,17,17,
+ 16,17,17,18,18,15,16,15,18,17,18,18,19,19,19,17,
+ 18,16,19,16, 9,11,11,13,13,11,12,12,14,15,10,12,
+ 12,14,14,13,14,14,16,16,13,14,14,16,16,11,12,12,
+ 14,14,12,12,13,15,15,12,13,13,15,15,14,15,15,16,
+ 17,14,15,15,16,16,10,12,11,14,14,12,13,13,15,15,
+ 11,13,12,15,14,14,15,15,16,17,13,15,14,17,16,13,
+ 14,14,15,16,14,15,15,16,17,14,15,15,16,17,16,16,
+ 17,17,18,16,17,17,18,18,12,14,13,16,15,13,15,14,
+ 17,16,13,14,13,17,15,15,16,16,18,18,15,16,15,18,
+ 16,10,11,11,14,14,11,12,13,14,15,11,12,12,15,15,
+ 14,15,15,16,17,14,15,15,16,16,11,12,13,15,15,12,
+ 13,14,15,16,13,14,14,15,16,15,15,16,16,18,15,15,
+ 16,17,17,11,12,12,14,15,13,13,14,15,16,12,13,13,
+ 15,15,15,15,16,17,18,14,15,15,17,16,14,15,15,16,
+ 17,15,15,16,16,17,15,16,16,17,17,16,16,17,16,19,
+ 17,17,18,19,18,13,13,14,16,16,14,15,16,17,17,14,
+ 14,15,16,16,16,16,17,18,18,16,16,16,18,16,10,12,
+ 12,14,14,12,13,13,15,15,11,13,12,15,15,14,15,15,
+ 16,17,13,15,14,17,16,12,13,13,15,15,13,13,14,15,
+ 16,13,14,14,16,16,15,15,16,17,18,15,15,16,17,17,
+ 11,13,12,15,14,13,14,13,16,15,12,14,12,16,14,15,
+ 16,15,17,17,14,16,14,17,16,14,15,15,16,17,15,15,
+ 16,16,18,15,16,16,17,17,16,17,17,17,19,17,17,17,
+ 18,18,13,15,12,17,14,14,16,14,17,15,14,15,13,17,
+ 14,16,17,16,18,17,15,17,14,19,15,11,12,12,15,15,
+ 13,13,14,15,16,13,14,13,16,15,15,16,16,17,18,15,
+ 16,16,17,17,12,14,13,16,16,13,13,15,15,17,14,15,
+ 15,17,16,16,16,17,16,19,16,17,17,18,18,12,13,14,
+ 15,16,14,14,15,16,17,13,14,13,16,15,16,17,17,18,
+ 19,15,16,16,17,16,15,16,16,18,17,15,15,16,17,18,
+ 16,17,17,18,18,16,16,18,16,19,18,19,19,20,19,15,
+ 15,16,16,17,16,16,17,17,18,15,15,15,17,16,18,18,
+ 19,18,20,17,17,16,18,16,12,13,13,16,15,13,14,14,
+ 16,16,13,14,14,16,16,15,16,16,17,18,15,16,15,18,
+ 17,13,14,14,16,16,14,15,15,16,17,14,15,15,17,17,
+ 16,17,17,18,18,16,17,17,18,18,13,14,13,17,14,14,
+ 15,14,17,16,14,15,14,17,15,16,17,17,18,18,15,17,
+ 15,19,15,16,16,16,17,18,16,16,17,17,19,16,17,17,
+ 18,19,17,17,18,18,20,18,18,18,19,19,15,16,14,18,
+ 13,16,17,16,19,15,16,17,15,19,14,18,18,18,19,17,
+ 17,18,16,20,15,
+};
+
+static const static_codebook _44p6_p2_0 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p6_p2_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p6_p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44p6_p3_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p6_p3_0[] = {
+ 1, 5, 5, 5, 7, 8, 5, 8, 7, 5, 7, 8, 8, 8,10, 8,
+ 10,10, 5, 8, 7, 8,10,10, 8,10, 8, 6, 8, 9, 8,10,
+ 12, 9,11,11, 9,10,11,11,11,13,12,13,13, 9,11,11,
+ 11,13,13,11,13,12, 6, 9, 8, 9,11,11, 8,12,10, 9,
+ 11,11,11,12,13,11,13,13, 9,11,10,11,13,13,11,13,
+ 11, 5, 9, 9, 8,11,11, 9,12,11, 8,10,11,10,11,13,
+ 11,13,13, 9,11,11,11,13,13,11,13,12, 8,10,11,10,
+ 12,13,10,13,12,10,10,13,11,11,14,12,13,14,11,13,
+ 12,13,14,14,12,14,12, 8,11,10,11,12,13,11,14,12,
+ 10,13,12,12,12,13,13,15,14,11,12,13,13,14,15,12,
+ 14,12, 5, 9, 9, 9,11,12, 8,11,11, 9,11,11,11,12,
+ 13,11,13,13, 8,11,10,11,13,13,10,13,11, 8,10,11,
+ 11,12,14,11,13,12,11,13,12,12,12,14,13,15,14,10,
+ 12,13,13,14,15,12,13,12, 8,11,10,10,12,13,10,13,
+ 12,11,12,13,12,12,14,13,14,14,10,13,10,12,14,13,
+ 11,14,11,
+};
+
+static const static_codebook _44p6_p3_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p6_p3_0,
+ 1, -533200896, 1614282752, 2, 0,
+ (long *)_vq_quantlist__44p6_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44p6_p3_1[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p6_p3_1[] = {
+ 5, 7, 7, 6, 7, 7, 6, 7, 7, 6, 7, 7, 7, 8, 8, 7,
+ 8, 8, 6, 7, 7, 7, 8, 8, 7, 8, 8, 7, 7, 8, 7, 8,
+ 8, 7, 8, 8, 8, 8, 8, 8, 8, 9, 8, 9, 9, 8, 8, 8,
+ 8, 9, 9, 8, 9, 8, 7, 8, 7, 7, 8, 8, 7, 8, 8, 8,
+ 8, 8, 8, 8, 9, 8, 9, 9, 8, 8, 8, 8, 9, 9, 8, 9,
+ 8, 6, 8, 8, 7, 8, 8, 7, 8, 8, 7, 8, 8, 8, 8, 9,
+ 8, 9, 9, 8, 8, 8, 8, 9, 9, 8, 9, 8, 7, 8, 8, 8,
+ 8, 9, 8, 9, 9, 8, 8, 9, 8, 9, 9, 9, 9, 9, 8, 9,
+ 9, 9, 9, 9, 9, 9, 9, 7, 8, 8, 8, 9, 9, 8, 9, 8,
+ 8, 8, 8, 8, 9, 9, 9, 9, 9, 8, 9, 8, 9, 9, 9, 9,
+ 9, 9, 6, 8, 8, 7, 8, 8, 7, 8, 8, 8, 8, 8, 8, 8,
+ 9, 8, 9, 9, 7, 8, 8, 8, 9, 9, 8, 9, 8, 7, 8, 8,
+ 8, 8, 9, 8, 9, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 8,
+ 8, 8, 9, 9, 9, 8, 9, 9, 7, 8, 8, 8, 9, 9, 8, 9,
+ 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 8, 9, 8, 9, 9, 9,
+ 9, 9, 9,
+};
+
+static const static_codebook _44p6_p3_1 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p6_p3_1,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44p6_p3_1,
+ 0
+};
+
+static const long _vq_quantlist__44p6_p4_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p6_p4_0[] = {
+ 2, 5, 5, 5, 7, 8, 5, 8, 7, 5, 7, 7, 7, 7, 9, 7,
+ 9, 9, 5, 7, 7, 8, 9, 9, 7, 9, 7, 6, 8, 8, 8, 9,
+ 10, 8, 9, 9, 8, 9,10, 9, 9,11,10,11,11, 8, 9, 9,
+ 10,11,11, 9,11,10, 6, 8, 8, 8, 9, 9, 8,10, 9, 8,
+ 9, 9, 9,10,11,10,11,10, 8,10, 9,10,11,11, 9,11,
+ 9, 6, 8, 8, 7, 9, 9, 8,10, 9, 7, 9, 9, 9, 9,10,
+ 9,10,10, 8, 9, 9, 9,10,10, 9,11,10, 7, 9, 9, 8,
+ 10,10, 9,10,10, 9, 9,10,10,10,11,10,11,11, 9,10,
+ 10,10,11,11,10,11,10, 7, 9, 9, 9, 9,10, 9,10, 9,
+ 8,10, 9, 9, 9,11,10,11,11, 9,10,10,10,11,11, 9,
+ 11, 9, 6, 8, 8, 8, 9,10, 7, 9, 9, 8, 9, 9, 9,10,
+ 10, 9,10,10, 7, 9, 9, 9,10,10, 9,10, 9, 7, 9, 9,
+ 9, 9,10, 9,10, 9, 9,10,10, 9, 9,11,10,11,11, 8,
+ 9,10,10,11,11, 9,11, 9, 7, 9, 9, 9,10,10, 8,10,
+ 10, 9,10,10,10,10,11,10,11,11, 9,10, 9,10,11,11,
+ 10,11,10,
+};
+
+static const static_codebook _44p6_p4_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p6_p4_0,
+ 1, -531365888, 1616117760, 2, 0,
+ (long *)_vq_quantlist__44p6_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44p6_p4_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p6_p4_1[] = {
+ 6, 8, 8,10,10, 8, 9, 9,10,11, 8,10, 9,11,10, 9,
+ 10,10,11,11, 9,10,10,11,11, 8, 9, 9,10,10, 9, 9,
+ 10,11,11,10,10,10,11,11,10,11,11,11,11,10,11,11,
+ 11,11, 8, 9, 9,11,10,10,10,10,11,11, 9,10, 9,11,
+ 11,10,11,11,11,11,10,11,10,11,11,10,10,11,11,11,
+ 10,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,10,11,10,11,11,11,11,11,11,11,10,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11, 8, 9,10,
+ 11,11,10,10,11,11,11,10,10,10,11,11,10,11,11,12,
+ 12,10,11,11,12,12,10,10,11,11,11,10,10,11,11,12,
+ 11,11,11,12,12,11,11,12,12,12,11,11,12,12,12,10,
+ 10,10,11,11,11,11,11,12,12,10,11,11,12,12,11,12,
+ 12,12,12,11,12,11,12,12,11,11,11,11,12,11,11,12,
+ 12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,11,11,11,12,11,11,12,12,12,12,11,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12, 8,10, 9,11,11,10,
+ 10,10,11,11,10,11,10,11,11,10,11,11,12,12,10,11,
+ 11,12,12,10,10,10,11,11,10,11,11,12,12,11,11,11,
+ 12,12,11,11,12,12,12,11,12,12,12,12,10,11,10,11,
+ 11,11,11,11,12,12,10,11,10,12,11,11,12,11,12,12,
+ 11,12,11,12,12,11,11,11,12,12,11,11,12,12,12,11,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,11,11,
+ 11,12,11,11,12,12,12,12,11,12,11,12,12,12,12,12,
+ 12,12,12,12,12,12,12,10,11,11,11,12,11,11,12,12,
+ 12,11,11,11,12,12,11,12,12,12,12,11,12,12,12,12,
+ 11,11,12,12,12,11,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,13,11,12,11,12,12,12,12,
+ 12,12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,13,12,13,12,12,12,12,13,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,13,13,13,13,12,
+ 12,12,13,12,10,11,11,12,11,11,11,12,12,12,11,12,
+ 11,12,12,11,12,12,12,12,11,12,12,12,12,11,11,12,
+ 12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,11,12,11,12,12,12,12,12,12,12,
+ 11,12,12,12,12,12,12,12,12,12,12,12,12,13,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,13,12,12,12,12,13,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,13,13,12,13,12,13,
+ 12, 8,10,10,11,11,10,10,11,11,11,10,11,10,11,11,
+ 10,11,11,12,12,10,11,11,12,12, 9,10,11,11,11,10,
+ 10,11,12,12,10,11,11,12,12,11,11,12,12,12,11,12,
+ 12,12,12,10,11,10,11,11,11,11,11,12,12,10,11,11,
+ 12,12,11,12,12,12,12,11,12,11,12,12,11,11,11,12,
+ 12,11,11,12,12,12,11,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,11,11,11,12,12,11,12,12,12,12,11,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12, 9,10,
+ 10,11,11,10,11,11,12,12,10,11,11,12,12,11,11,12,
+ 12,12,11,12,12,12,12,10,11,11,12,12,11,11,12,12,
+ 12,11,11,12,12,12,11,11,12,12,12,12,12,12,12,12,
+ 10,11,11,12,12,11,12,12,12,12,11,12,11,12,12,12,
+ 12,12,12,12,12,12,12,12,12,11,11,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12, 9,10,10,11,11,
+ 10,11,11,12,12,10,11,11,12,11,11,12,12,12,12,11,
+ 12,12,12,12,10,11,11,12,12,11,11,11,12,12,11,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,10,11,11,
+ 12,12,11,12,12,12,12,11,12,11,12,12,12,12,12,12,
+ 12,12,12,12,12,12,11,12,12,12,12,11,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,11,
+ 12,12,12,12,12,12,12,12,12,11,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,11,11,11,12,12,11,12,12,
+ 12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 13,11,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,13,12,13,12,12,13,13,13,11,12,12,12,12,12,
+ 12,12,13,13,12,12,12,13,12,12,12,12,13,13,12,13,
+ 12,13,13,12,12,12,12,12,12,12,12,12,13,12,13,13,
+ 13,13,12,13,13,13,13,13,13,13,13,13,12,12,12,12,
+ 12,12,12,13,13,13,12,13,12,13,13,12,13,13,13,13,
+ 12,13,13,13,13,11,11,11,12,12,11,12,12,12,12,11,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,11,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,13,
+ 12,13,12,12,12,13,13,11,12,12,12,12,12,12,12,12,
+ 13,12,12,12,13,12,12,13,12,13,13,12,13,12,13,13,
+ 12,12,12,12,12,12,12,13,13,13,12,12,13,13,13,12,
+ 13,13,12,13,13,13,13,13,13,12,12,12,12,12,12,13,
+ 12,13,13,12,13,12,13,12,12,13,13,13,13,12,13,13,
+ 13,13, 8,10,10,11,11,10,10,11,11,11, 9,11,10,11,
+ 11,10,11,11,12,12,10,11,11,12,12,10,10,11,11,11,
+ 10,11,11,12,12,11,11,11,12,12,11,11,12,12,12,11,
+ 12,12,12,12, 9,11,10,11,11,10,11,11,12,12,10,11,
+ 10,12,12,11,12,12,12,12,11,12,11,12,12,11,11,11,
+ 12,12,11,12,12,12,12,11,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,11,11,11,12,12,11,12,12,12,12,
+ 11,12,11,12,12,12,12,12,12,12,12,12,12,12,12, 9,
+ 10,10,11,11,10,11,11,12,12,10,11,11,12,12,11,12,
+ 12,12,12,11,12,12,12,12,10,11,11,12,12,11,11,12,
+ 12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,10,11,11,12,12,11,11,12,12,12,11,11,11,12,12,
+ 12,12,12,12,12,11,12,12,12,12,11,12,12,12,12,11,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,11,12,12,12,12,12,12,12,12,12,11,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12, 9,10,10,11,
+ 11,10,11,11,12,12,10,11,11,12,12,11,12,12,12,12,
+ 11,12,11,12,12,10,11,11,12,12,11,11,12,12,12,11,
+ 11,12,12,12,12,12,12,12,12,12,12,12,12,12,10,11,
+ 11,12,12,11,12,11,12,12,11,12,11,12,12,12,12,12,
+ 12,12,11,12,11,12,12,11,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 11,12,11,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,11,11,11,12,12,11,12,
+ 12,12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,13,
+ 13,12,12,12,13,13,12,12,13,13,13,11,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,13,12,13,13,12,
+ 12,12,13,12,12,12,12,12,12,12,12,13,13,13,12,12,
+ 13,13,13,12,13,13,12,13,12,13,13,13,13,12,12,12,
+ 12,12,12,12,13,13,13,12,12,12,13,12,12,13,13,13,
+ 13,12,13,13,13,13,11,11,11,12,12,11,12,12,12,12,
+ 11,12,12,12,12,12,12,12,12,12,12,12,12,12,12,11,
+ 12,12,12,12,12,12,12,12,12,12,12,12,13,12,12,12,
+ 13,13,13,12,12,12,13,13,11,12,12,12,12,12,12,12,
+ 13,12,12,12,12,13,12,12,13,12,13,13,12,13,12,13,
+ 12,12,12,12,12,12,12,12,13,13,13,12,13,13,13,13,
+ 12,13,13,13,13,13,13,13,13,13,12,12,12,12,12,12,
+ 13,12,13,12,12,13,12,13,12,13,13,13,13,13,12,13,
+ 13,13,13,10,11,11,12,12,11,12,12,12,12,11,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,11,11,12,12,
+ 12,11,12,12,12,12,12,12,12,12,12,12,12,12,13,13,
+ 12,12,12,13,13,11,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,13,13,12,12,12,13,12,12,12,
+ 12,12,12,12,12,12,12,13,12,12,12,12,13,12,12,13,
+ 12,13,12,13,13,13,13,12,12,12,12,12,12,12,12,13,
+ 12,12,12,12,13,12,12,13,13,13,13,12,13,12,13,13,
+ 11,11,11,12,12,11,12,12,12,12,11,12,12,12,12,12,
+ 12,12,12,13,12,12,12,13,12,11,12,12,12,12,12,12,
+ 12,12,13,12,12,12,12,13,12,12,13,13,13,12,12,13,
+ 13,13,11,12,12,12,12,12,12,12,12,13,12,12,12,13,
+ 12,12,13,12,13,13,12,13,12,13,13,12,12,12,12,12,
+ 12,12,13,12,13,12,12,13,13,13,12,12,13,13,13,13,
+ 13,13,13,13,12,12,12,12,12,12,13,13,13,13,12,13,
+ 12,13,12,12,13,13,13,13,12,13,13,13,13,11,11,11,
+ 12,12,11,12,12,12,12,11,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,13,11,12,12,12,12,12,12,12,12,13,
+ 12,12,12,13,13,12,12,13,13,13,12,12,13,13,13,11,
+ 12,12,12,12,12,12,12,13,13,12,12,12,13,12,12,13,
+ 12,13,13,12,13,12,13,13,12,12,12,12,12,12,12,12,
+ 12,13,12,13,12,13,13,12,13,13,13,13,12,13,13,13,
+ 13,12,12,12,12,12,12,13,12,13,13,12,12,12,13,13,
+ 12,13,13,13,13,12,13,12,13,13,11,12,12,12,12,11,
+ 12,12,12,12,11,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,13,12,13,12,12,12,13,13,11,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,13,13,
+ 12,13,12,13,13,12,12,12,12,12,12,12,13,12,13,12,
+ 12,13,12,13,12,12,13,12,13,12,13,13,13,13,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,13,12,12,13,13,
+ 13,13,12,13,12,13,12,11,11,11,12,12,11,12,12,12,
+ 12,11,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 11,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,13,13,11,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,13,13,12,12,12,
+ 13,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,13,12,12,12,13,12,12,12,12,12,12,12,12,
+ 12,12,12,13,12,12,12,12,13,12,12,13,12,13,12,12,
+ 13,12,13,12,10,11,11,12,12,11,12,12,12,12,11,12,
+ 11,12,12,11,12,12,12,12,11,12,12,12,12,11,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 13,12,12,12,13,13,11,12,11,12,12,12,12,12,12,12,
+ 11,12,12,12,12,12,12,12,13,13,12,12,12,13,12,12,
+ 12,12,12,12,12,12,12,12,13,12,12,12,12,13,12,13,
+ 13,12,13,12,13,13,13,13,12,12,12,12,12,12,12,12,
+ 13,13,12,12,12,13,12,12,13,13,13,13,12,13,12,13,
+ 12,11,11,11,12,12,11,12,12,12,12,11,12,12,12,12,
+ 12,12,12,13,13,12,12,12,13,12,11,12,12,12,12,12,
+ 12,12,12,13,12,12,12,13,13,12,12,13,13,13,12,12,
+ 13,13,13,11,12,12,12,12,12,12,12,13,13,12,12,12,
+ 13,12,12,13,12,13,13,12,12,12,13,13,12,12,12,12,
+ 12,12,12,13,13,13,12,12,13,13,13,12,12,13,13,13,
+ 12,13,13,13,13,12,12,12,12,12,12,12,13,13,13,12,
+ 12,12,13,12,12,13,13,13,13,12,13,13,13,13,11,11,
+ 11,12,12,11,12,12,12,12,11,12,12,12,12,12,12,12,
+ 12,13,12,12,12,13,13,11,12,12,12,12,12,12,12,12,
+ 13,12,12,12,13,13,12,12,13,13,13,12,12,13,13,13,
+ 11,12,12,12,12,12,12,12,13,12,12,12,12,13,12,12,
+ 13,12,13,13,12,13,12,13,13,12,12,12,12,12,12,12,
+ 12,13,13,12,13,12,13,13,12,13,13,13,13,13,13,13,
+ 13,13,12,12,12,12,12,12,13,12,13,13,12,13,12,13,
+ 12,12,13,13,13,13,12,13,12,13,13,11,11,11,12,12,
+ 11,12,12,12,12,11,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,11,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,13,12,12,12,13,13,11,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,13,
+ 13,12,12,12,12,12,12,12,12,12,12,12,12,12,12,13,
+ 12,12,12,12,13,12,12,12,12,13,12,12,13,12,13,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 13,12,12,12,13,12,12,12,11,12,11,12,12,11,12,12,
+ 12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,11,12,12,12,12,12,12,12,12,13,12,12,12,12,12,
+ 12,12,12,13,13,12,12,12,13,13,11,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,13,12,13,13,12,12,
+ 12,13,12,12,12,12,12,12,12,12,12,12,13,12,12,12,
+ 13,13,12,12,13,12,13,12,13,13,13,13,12,12,12,12,
+ 12,12,12,12,13,12,12,12,12,13,12,12,13,12,13,13,
+ 12,13,12,13,12,
+};
+
+static const static_codebook _44p6_p4_1 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p6_p4_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p6_p4_1,
+ 0
+};
+
+static const long _vq_quantlist__44p6_p5_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p6_p5_0[] = {
+ 2, 6, 6,10,10, 5, 7, 8,11,12, 5, 8, 7,12,11, 9,
+ 11,11,13,15, 9,11,11,15,13, 6, 7, 8,11,11, 7, 7,
+ 9,11,13, 8, 9, 9,13,12,11,11,12,12,15,11,12,12,
+ 15,14, 6, 8, 7,11,11, 8, 9, 9,12,13, 7, 9, 7,13,
+ 11,11,12,12,14,15,11,12,11,15,12,10,11,11,12,14,
+ 10,11,12,12,15,12,13,13,14,15,13,12,14,12,16,15,
+ 15,15,16,16,10,11,11,14,12,12,13,13,15,14,10,12,
+ 11,15,12,15,15,15,16,17,13,14,12,17,12, 6, 8, 8,
+ 12,12, 8, 9,10,13,13, 8, 9, 9,13,13,12,12,13,15,
+ 16,12,13,13,16,15, 8, 9,10,12,13, 9, 9,11,13,14,
+ 10,11,11,14,14,13,13,14,15,16,13,14,14,16,16, 8,
+ 10, 9,13,13,10,11,11,14,14, 9,10,10,14,13,13,14,
+ 14,16,17,13,13,13,16,15,12,13,13,14,16,13,13,14,
+ 14,16,14,14,14,16,16,15,15,16,15,18,16,17,17,18,
+ 18,12,13,13,15,15,14,14,14,16,16,13,14,13,16,15,
+ 16,16,17,18,18,15,16,15,18,15, 6, 8, 8,12,12, 8,
+ 9, 9,13,13, 8,10, 9,13,13,12,13,13,15,16,12,13,
+ 12,16,15, 8, 9,10,13,13, 9,10,10,13,14,10,11,11,
+ 14,14,13,13,13,15,16,13,14,14,17,16, 8,10, 9,13,
+ 13,10,11,11,14,14, 9,11, 9,14,13,13,14,14,16,16,
+ 13,14,13,16,14,12,13,13,15,16,13,13,14,15,16,14,
+ 14,14,16,16,15,15,16,15,18,17,17,17,18,18,12,13,
+ 13,16,14,14,14,14,16,16,13,14,13,16,14,16,17,17,
+ 18,18,15,16,15,18,15,11,12,13,14,16,13,13,14,15,
+ 17,13,14,14,16,17,16,16,17,17,19,16,17,17,18,19,
+ 13,13,14,16,16,14,14,15,16,17,14,15,15,17,17,17,
+ 16,17,17,19,17,17,18,19,19,13,14,14,16,16,14,14,
+ 15,17,18,14,15,14,17,17,17,17,18,18,19,17,17,17,
+ 18,19,16,16,16,17,18,17,17,17,18,19,17,17,17,18,
+ 19,18,18,19,18,20,19,20,19,21,20,16,17,17,18,18,
+ 17,17,18,19,19,17,17,17,19,18,19,19,19,19,20,19,
+ 19,19,20,19,11,13,12,16,14,13,14,14,17,16,13,14,
+ 13,17,15,16,17,17,18,18,16,17,16,19,17,13,14,14,
+ 16,16,14,14,14,17,17,14,15,15,17,16,17,17,17,19,
+ 19,17,18,17,19,18,13,14,13,17,16,14,15,15,17,17,
+ 14,15,14,18,16,17,17,17,19,19,17,17,16,19,17,16,
+ 17,17,18,19,17,17,17,18,18,17,18,17,19,18,18,19,
+ 18,19,19,19,20,19,20,20,16,17,16,18,17,17,17,17,
+ 18,18,17,18,17,19,17,19,19,19,19,20,18,19,19,20,
+ 18, 6, 8, 8,12,12, 8, 9, 9,13,13, 8,10, 9,13,13,
+ 11,13,13,15,16,12,13,13,16,15, 8, 9, 9,13,13, 9,
+ 9,10,13,14,10,11,11,14,14,12,12,13,14,16,13,14,
+ 14,17,16, 8,10, 9,13,13,10,11,11,14,14, 9,11,10,
+ 14,13,13,14,14,16,16,13,14,13,16,15,12,13,13,14,
+ 16,12,13,14,14,16,13,14,14,16,16,15,14,16,15,18,
+ 16,17,17,18,17,12,13,13,16,15,14,14,14,16,16,13,
+ 14,13,16,15,16,16,17,17,17,15,16,15,18,15, 7, 9,
+ 9,13,13, 9, 9,11,13,14, 9,10,10,14,13,12,13,14,
+ 15,16,12,14,13,17,15, 9, 9,10,13,14,10, 9,11,13,
+ 15,11,11,11,14,14,13,12,14,14,17,14,14,14,17,16,
+ 9,10,10,14,13,11,11,11,14,14,10,11,10,15,13,14,
+ 14,14,16,17,13,14,13,17,14,13,13,14,14,16,13,13,
+ 14,14,17,14,14,14,16,16,15,14,16,15,18,17,17,17,
+ 18,18,13,14,13,16,15,14,14,15,17,16,13,14,13,17,
+ 15,17,16,17,17,17,15,16,14,18,14, 7, 9, 9,13,13,
+ 9,10,10,13,14, 9,11,10,14,13,13,14,14,16,16,13,
+ 14,14,17,15, 9,10,10,14,13, 9,10,11,13,14,11,12,
+ 11,15,14,13,13,14,14,16,14,15,15,17,17, 9,10,10,
+ 14,14,11,12,12,14,15,10,11,10,15,13,14,15,15,17,
+ 17,14,15,13,17,14,13,14,13,16,16,13,13,14,15,16,
+ 14,15,15,17,17,15,14,16,15,18,17,18,17,20,18,13,
+ 14,14,16,16,15,15,15,17,17,13,14,13,17,15,17,17,
+ 18,18,18,15,16,14,19,14,12,13,13,15,16,13,13,15,
+ 16,17,13,14,14,16,16,15,15,17,17,19,16,17,17,19,
+ 18,13,13,14,15,17,14,13,15,15,17,14,15,15,16,17,
+ 16,15,18,16,19,17,17,17,18,19,13,14,14,17,16,14,
+ 15,15,17,17,14,15,14,17,16,17,17,17,18,19,16,17,
+ 16,19,17,16,16,17,16,18,16,16,17,16,19,17,17,18,
+ 18,19,18,17,18,17,21,19,19,19,20,19,16,17,17,18,
+ 18,17,17,18,18,19,16,17,16,18,18,19,19,19,19,20,
+ 18,18,17,20,18,11,13,13,16,15,13,14,14,16,17,13,
+ 15,14,17,16,16,17,17,18,18,17,17,17,19,18,13,14,
+ 13,17,16,14,13,14,16,17,15,16,15,18,16,17,16,17,
+ 17,19,18,18,18,20,18,13,14,14,16,17,15,15,15,17,
+ 18,14,15,14,18,16,18,18,18,19,20,17,18,16,20,17,
+ 16,17,16,18,18,16,16,17,18,18,17,18,18,19,18,18,
+ 17,19,17,20,19,20,19,22,20,16,16,17,18,18,18,17,
+ 17,19,19,16,17,16,18,17,19,20,19,22,21,18,19,18,
+ 21,17, 6, 8, 8,12,12, 8, 9,10,13,13, 8, 9, 9,13,
+ 13,12,13,13,15,16,11,13,13,16,15, 8, 9,10,13,13,
+ 9,10,11,13,14,10,11,11,14,14,13,13,14,15,16,13,
+ 14,14,16,16, 8, 9, 9,13,13,10,11,11,14,14, 9,10,
+ 9,14,13,13,14,14,16,17,12,14,12,16,14,12,13,13,
+ 15,16,13,13,14,15,16,13,14,14,15,17,15,15,16,15,
+ 18,16,16,17,17,17,12,13,13,16,14,13,14,14,16,16,
+ 12,14,13,16,14,16,17,17,18,18,15,15,14,18,14, 7,
+ 9, 9,13,13, 9,10,11,13,14, 9,10,10,14,13,13,14,
+ 14,15,17,13,14,14,16,15, 9,10,10,14,14,10,10,11,
+ 13,15,11,12,12,15,14,14,13,15,14,17,14,15,15,17,
+ 17, 9,10,10,13,14,11,11,12,14,15, 9,11,10,14,13,
+ 14,15,15,16,18,13,14,13,16,14,13,14,14,16,16,13,
+ 13,14,15,17,15,15,15,16,17,15,14,16,15,18,17,17,
+ 18,19,18,13,14,14,16,16,14,15,15,17,17,13,14,13,
+ 16,15,17,17,18,18,18,15,16,14,18,15, 7, 9, 9,13,
+ 13, 9,10,10,13,14, 9,11,10,14,13,12,13,14,15,16,
+ 12,14,13,16,15, 9,10,10,13,14,10,10,11,13,14,11,
+ 11,11,15,14,13,13,14,14,16,14,14,14,17,16, 9,10,
+ 9,14,13,11,11,11,14,14,10,11, 9,15,13,14,14,14,
+ 16,16,13,14,12,17,14,13,13,14,15,16,13,13,14,15,
+ 16,14,15,14,16,17,15,14,16,14,18,16,17,17,18,18,
+ 13,14,13,16,14,14,14,14,16,16,13,14,13,17,14,17,
+ 17,17,18,18,15,16,14,18,15,11,13,13,16,16,13,14,
+ 15,16,17,13,14,14,17,16,16,17,17,18,19,17,17,17,
+ 19,18,13,14,14,17,17,13,13,15,16,18,15,15,15,17,
+ 17,17,16,18,17,20,18,17,18,19,19,13,14,14,16,17,
+ 15,15,16,16,18,14,15,14,16,16,17,17,18,18,20,17,
+ 18,16,18,17,16,17,16,19,18,16,16,17,18,19,18,18,
+ 18,19,19,18,17,18,17,21,20,19,19,21,21,16,16,17,
+ 18,18,17,17,18,19,19,16,17,16,19,18,20,20,20,19,
+ 21,18,18,17,20,18,12,13,13,16,15,13,14,14,16,16,
+ 13,14,13,17,16,16,17,17,18,18,15,17,15,19,17,13,
+ 14,14,16,17,14,14,15,16,17,14,15,15,17,17,16,16,
+ 17,17,18,17,17,17,19,19,13,14,13,17,15,14,15,15,
+ 17,16,14,15,13,17,15,17,18,17,19,18,16,17,15,20,
+ 16,16,17,17,18,18,16,16,17,18,18,17,18,17,19,18,
+ 17,17,18,18,20,19,20,19,20,19,16,16,16,19,16,17,
+ 17,17,19,18,16,17,16,19,16,19,19,19,19,19,18,19,
+ 17,19,17,11,13,13,16,16,13,14,14,17,17,13,14,14,
+ 17,17,15,17,17,19,19,16,18,17,20,19,12,14,14,17,
+ 17,13,14,15,17,18,14,15,15,17,18,16,16,17,18,20,
+ 17,18,18,20,18,13,14,14,17,17,14,15,15,17,18,14,
+ 15,15,17,17,17,18,17,19,19,17,18,17,19,19,15,16,
+ 16,18,18,15,16,17,18,19,16,17,17,19,19,17,17,18,
+ 18,21,18,19,19,21,19,16,17,17,18,18,17,17,18,19,
+ 19,17,18,17,19,19,19,19,19,20,20,18,19,18,21,19,
+ 12,13,13,16,16,13,14,14,16,17,13,15,14,17,16,15,
+ 16,17,17,19,16,17,17,19,18,13,13,14,16,17,14,13,
+ 15,16,17,14,15,15,17,17,15,15,17,17,20,17,17,18,
+ 19,18,13,14,14,17,16,15,15,15,17,18,14,15,14,17,
+ 16,17,17,17,18,18,16,17,16,19,17,16,15,17,17,19,
+ 16,15,17,16,19,17,16,17,18,19,17,16,19,16,20,19,
+ 18,19,19,19,16,17,17,18,18,17,17,17,18,19,16,17,
+ 16,19,18,20,19,19,20,19,18,18,17,20,17,11,13,13,
+ 16,16,13,14,15,16,17,14,15,14,18,16,17,17,17,18,
+ 21,17,18,17,20,19,13,14,14,17,16,13,14,15,16,18,
+ 15,16,15,18,17,17,16,17,17,19,17,18,18,20,19,13,
+ 14,14,16,17,15,15,16,17,18,14,15,14,18,17,17,18,
+ 18,19,20,17,18,16,19,17,16,17,15,19,18,16,16,16,
+ 18,18,17,18,17,20,19,18,17,18,17,20,20,20,19,22,
+ 20,16,17,17,18,19,18,18,18,19,20,16,17,16,19,18,
+ 20,19,19,20,20,18,19,17,20,17,13,14,14,16,17,14,
+ 14,16,16,18,14,16,15,17,16,16,16,17,17,18,17,17,
+ 16,19,18,14,14,15,16,17,14,14,16,16,18,16,16,16,
+ 17,17,16,15,17,16,19,18,18,18,19,19,14,15,15,17,
+ 17,15,16,16,17,18,14,16,14,18,16,17,17,18,18,19,
+ 16,17,16,19,17,16,16,17,16,18,16,16,17,16,19,18,
+ 18,18,17,18,17,16,18,16,20,19,19,19,19,19,16,17,
+ 17,18,18,17,17,18,19,19,16,17,16,19,17,18,19,19,
+ 19,20,17,18,16,20,16,11,14,13,17,17,14,14,16,16,
+ 18,14,16,14,19,16,18,18,19,18,19,18,19,18,21,18,
+ 13,15,14,18,16,14,14,16,16,18,16,17,16,19,17,18,
+ 16,19,17,20,19,19,19,21,19,13,14,15,17,18,17,16,
+ 17,17,19,14,16,14,18,16,20,19,19,20,21,18,19,16,
+ 21,17,17,18,16,19,17,16,16,17,18,18,19,19,18,21,
+ 18,17,17,18,17,20,20,20,20,22,20,17,17,18,18,20,
+ 19,19,19,18,20,16,17,17,19,19,21,21,21,20,21,17,
+ 19,17,23,17,11,13,13,16,16,13,14,14,17,17,13,14,
+ 14,17,17,16,17,17,19,20,15,16,16,19,19,13,14,14,
+ 16,17,14,15,15,17,18,14,15,15,17,17,17,17,18,19,
+ 19,17,17,18,19,19,13,14,14,17,16,14,15,15,17,17,
+ 13,15,14,18,17,17,18,18,19,20,16,17,16,19,18,16,
+ 16,17,18,18,17,17,17,18,19,17,18,17,19,19,19,19,
+ 19,19,20,19,20,19,20,20,15,16,16,18,17,16,17,17,
+ 20,18,15,16,16,19,17,19,19,19,20,20,17,18,17,21,
+ 17,11,13,13,16,16,13,14,15,16,17,13,15,14,17,16,
+ 17,17,18,18,20,17,17,17,19,19,13,14,14,17,17,14,
+ 14,15,17,18,15,15,15,18,17,17,17,18,17,20,18,18,
+ 17,20,18,13,14,14,16,17,15,15,16,17,18,14,15,13,
+ 17,17,17,18,18,19,20,17,17,16,19,17,16,17,17,18,
+ 18,16,16,17,18,18,18,18,18,19,19,18,17,19,18,21,
+ 19,20,20,20,20,16,15,17,18,18,17,17,18,18,20,16,
+ 16,16,18,17,20,19,20,21,22,17,18,17,20,17,12,13,
+ 13,16,16,13,14,15,16,17,13,14,14,17,16,16,17,18,
+ 18,19,15,16,16,19,18,13,14,14,16,17,14,14,15,16,
+ 17,14,15,15,17,17,16,16,17,17,19,17,17,17,19,18,
+ 13,14,13,17,16,14,15,15,17,17,13,15,13,17,16,17,
+ 17,17,19,19,15,17,15,19,17,16,17,17,18,18,16,16,
+ 17,17,19,17,18,17,19,19,18,17,19,17,19,19,19,19,
+ 20,19,15,17,15,19,16,17,17,16,19,18,16,17,15,18,
+ 16,19,19,19,20,19,17,19,16,19,16,11,14,14,17,17,
+ 15,14,16,16,18,15,16,14,18,16,18,18,19,18,21,18,
+ 19,18,20,18,13,15,14,18,17,14,14,16,16,18,16,17,
+ 16,19,17,17,17,19,17,22,19,19,19,21,19,13,14,15,
+ 17,18,17,16,17,17,19,14,16,14,18,16,19,19,19,20,
+ 21,18,18,16,20,17,17,18,16,19,18,15,17,17,19,19,
+ 19,19,18,21,19,18,17,20,17,21,22,21,20,21,21,17,
+ 16,19,18,20,19,18,19,18,20,16,17,16,19,18,21,20,
+ 21,19,23,18,19,16,20,17,13,14,14,17,16,14,14,15,
+ 16,18,14,16,14,17,16,16,16,17,17,19,16,17,16,19,
+ 17,14,15,15,17,17,14,14,16,16,17,15,16,16,18,17,
+ 16,16,17,17,19,17,18,17,19,18,14,15,14,17,16,16,
+ 16,16,17,17,14,16,14,17,16,18,18,18,18,19,16,17,
+ 15,19,16,17,17,17,18,18,16,15,17,17,18,18,18,18,
+ 19,19,17,16,18,16,19,19,19,19,19,19,16,17,16,19,
+ 16,18,18,17,19,18,16,17,16,19,16,19,19,20,19,19,
+ 17,18,16,20,16,
+};
+
+static const static_codebook _44p6_p5_0 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p6_p5_0,
+ 1, -528744448, 1616642048, 3, 0,
+ (long *)_vq_quantlist__44p6_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44p6_p5_1[] = {
+ 3,
+ 2,
+ 4,
+ 1,
+ 5,
+ 0,
+ 6,
+};
+
+static const long _vq_lengthlist__44p6_p5_1[] = {
+ 2, 3, 3, 3, 3, 3, 3,
+};
+
+static const static_codebook _44p6_p5_1 = {
+ 1, 7,
+ (long *)_vq_lengthlist__44p6_p5_1,
+ 1, -533200896, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p6_p5_1,
+ 0
+};
+
+static const long _vq_quantlist__44p6_p6_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p6_p6_0[] = {
+ 1, 5, 5, 5, 7, 9, 5, 9, 7, 5, 7, 8, 7, 7,10, 9,
+ 10,10, 5, 8, 7, 9,10,10, 7,10, 7, 6, 9, 9, 9,10,
+ 12, 9,11,11, 9,10,11,11,11,13,12,13,13, 9,11,11,
+ 12,13,13,11,13,11, 6, 9, 9, 9,11,11, 9,12,10, 9,
+ 11,11,11,11,13,12,13,13, 9,11,10,12,13,13,11,13,
+ 11, 6, 9, 9, 9,11,12, 9,12,11, 9,10,11,10,10,13,
+ 12,13,13, 9,11,11,12,13,12,11,13,11, 7, 9,10, 9,
+ 10,12,10,12,11,10,10,12,10,10,12,12,12,13,10,11,
+ 11,12,12,13,10,12,10, 7,10,10,11,11,14,11,14,11,
+ 10,12,11,11,11,14,14,14,14,10,11,12,14,14,14,11,
+ 14,11, 6, 9, 9, 9,11,12, 9,12,11, 9,11,11,11,11,
+ 13,12,12,13, 9,11,10,12,13,13,10,13,10, 7,10,10,
+ 11,11,14,11,14,11,10,12,11,11,11,14,14,15,14,10,
+ 11,12,13,14,15,11,14,11, 7,10, 9,10,11,12, 9,12,
+ 10,10,11,11,10,10,12,12,13,12, 9,12,10,12,13,12,
+ 10,12,10,
+};
+
+static const static_codebook _44p6_p6_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p6_p6_0,
+ 1, -527106048, 1620377600, 2, 0,
+ (long *)_vq_quantlist__44p6_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44p6_p6_1[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p6_p6_1[] = {
+ 2, 6, 6, 6, 7, 8, 6, 8, 7, 6, 7, 7, 7, 7, 8, 7,
+ 8, 8, 6, 7, 7, 7, 8, 8, 7, 8, 7, 6, 8, 8, 8, 9,
+ 9, 8, 9, 9, 8, 9, 9, 9, 9,10, 9,10,10, 8, 9, 9,
+ 9,10,10, 9,10, 9, 6, 8, 8, 8, 9, 9, 8, 9, 9, 8,
+ 9, 9, 9, 9,10, 9,10,10, 8, 9, 9, 9,10, 9, 9,10,
+ 9, 6, 8, 8, 8, 9, 9, 8, 9, 9, 8, 9, 9, 9, 9,10,
+ 9, 9,10, 8, 9, 9, 9,10, 9, 9,10, 9, 7, 8, 8, 8,
+ 9, 9, 8, 9, 9, 8, 8, 9, 9, 9, 9, 9, 9, 9, 8, 9,
+ 9, 9,10, 9, 9, 9, 9, 7, 9, 9, 9, 9,10, 9,10, 9,
+ 9, 9, 9, 9, 9,10,10,10,10, 9, 9, 9,10,10,10, 9,
+ 10, 9, 6, 8, 8, 8, 9, 9, 8, 9, 9, 8, 9, 9, 9, 9,
+ 10, 9,10,10, 8, 9, 9, 9,10, 9, 9,10, 9, 7, 9, 9,
+ 9, 9,10, 9,10, 9, 9, 9, 9, 9, 9,10,10,10,10, 9,
+ 9, 9,10,10,10, 9,10, 9, 7, 8, 8, 8, 9, 9, 8, 9,
+ 9, 8, 9, 9, 9, 9,10, 9, 9,10, 8, 9, 8, 9, 9, 9,
+ 9,10, 9,
+};
+
+static const static_codebook _44p6_p6_1 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p6_p6_1,
+ 1, -530841600, 1616642048, 2, 0,
+ (long *)_vq_quantlist__44p6_p6_1,
+ 0
+};
+
+static const long _vq_quantlist__44p6_p7_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p6_p7_0[] = {
+ 1, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9,
+};
+
+static const static_codebook _44p6_p7_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p6_p7_0,
+ 1, -513979392, 1633504256, 2, 0,
+ (long *)_vq_quantlist__44p6_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44p6_p7_1[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p6_p7_1[] = {
+ 1, 4, 5, 5,10,10, 5,10,10, 5,10,10,10,10,10,10,
+ 10,10, 5,10,10,10,10,10,10,10,10, 7,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10, 6,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10, 6,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10, 9,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10, 9,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10, 6,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10, 9,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10, 9,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,11,11,11,11,11,
+ 11,11,11,
+};
+
+static const static_codebook _44p6_p7_1 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p6_p7_1,
+ 1, -516716544, 1630767104, 2, 0,
+ (long *)_vq_quantlist__44p6_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44p6_p7_2[] = {
+ 12,
+ 11,
+ 13,
+ 10,
+ 14,
+ 9,
+ 15,
+ 8,
+ 16,
+ 7,
+ 17,
+ 6,
+ 18,
+ 5,
+ 19,
+ 4,
+ 20,
+ 3,
+ 21,
+ 2,
+ 22,
+ 1,
+ 23,
+ 0,
+ 24,
+};
+
+static const long _vq_lengthlist__44p6_p7_2[] = {
+ 1, 2, 3, 4, 5, 7, 7, 8, 8, 9, 9,10,10,11,11,12,
+ 12,13,13,14,14,15,15,15,15,
+};
+
+static const static_codebook _44p6_p7_2 = {
+ 1, 25,
+ (long *)_vq_lengthlist__44p6_p7_2,
+ 1, -518864896, 1620639744, 5, 0,
+ (long *)_vq_quantlist__44p6_p7_2,
+ 0
+};
+
+static const long _vq_quantlist__44p6_p7_3[] = {
+ 12,
+ 11,
+ 13,
+ 10,
+ 14,
+ 9,
+ 15,
+ 8,
+ 16,
+ 7,
+ 17,
+ 6,
+ 18,
+ 5,
+ 19,
+ 4,
+ 20,
+ 3,
+ 21,
+ 2,
+ 22,
+ 1,
+ 23,
+ 0,
+ 24,
+};
+
+static const long _vq_lengthlist__44p6_p7_3[] = {
+ 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5,
+};
+
+static const static_codebook _44p6_p7_3 = {
+ 1, 25,
+ (long *)_vq_lengthlist__44p6_p7_3,
+ 1, -529006592, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44p6_p7_3,
+ 0
+};
+
+static const long _huff_lengthlist__44p6_short[] = {
+ 2, 8,13,15,16,18,21,22, 5, 4, 6, 8,10,12,17,21,
+ 9, 5, 5, 6, 8,11,15,19,11, 6, 5, 5, 6, 7,12,14,
+ 14, 8, 7, 5, 4, 4, 9,11,16,11, 9, 7, 4, 3, 7,10,
+ 22,15,14,12, 8, 7, 9,11,21,16,15,12, 9, 5, 6, 8,
+};
+
+static const static_codebook _huff_book__44p6_short = {
+ 2, 64,
+ (long *)_huff_lengthlist__44p6_short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44p7_l0_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44p7_l0_0[] = {
+ 2, 4, 4, 7, 7, 8, 8,10,10,11,11,12,12, 4, 5, 5,
+ 7, 7, 9, 9,11, 9,12,11,12,12, 4, 5, 5, 7, 7, 9,
+ 9, 9,10,10,11,12,12, 7, 7, 7, 7, 8, 9, 8,11, 5,
+ 12, 6,12,10, 7, 7, 7, 8, 7, 8, 9, 5,11, 6,12,10,
+ 12, 8, 9, 9, 9, 9,10,10,11, 7,11, 7,12, 9, 8, 9,
+ 8, 9, 9,10,10, 7,11, 7,11, 9,11,10,10,10,10,10,
+ 10,10,11,10,11, 8,11, 9,10,10,10,10,10,10,10,10,
+ 11, 8,10, 9,11,10,11,11,11,11,11,10,11,10,12,10,
+ 12,11,10,11,11,11,11,10,11,10,11,10,12,11,12,11,
+ 12,12,12,12,12,12,12,12,12,12,13,12,11,12,11,12,
+ 12,12,12,12,11,12,11,12,13,
+};
+
+static const static_codebook _44p7_l0_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44p7_l0_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44p7_l0_0,
+ 0
+};
+
+static const long _vq_quantlist__44p7_l0_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p7_l0_1[] = {
+ 4, 4, 4, 5, 5, 4, 4, 5, 5, 5, 4, 5, 4, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5,
+};
+
+static const static_codebook _44p7_l0_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44p7_l0_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p7_l0_1,
+ 0
+};
+
+static const long _vq_quantlist__44p7_l1_0[] = {
+ 54,
+ 29,
+ 79,
+ 0,
+ 108,
+};
+
+static const long _vq_lengthlist__44p7_l1_0[] = {
+ 1, 2, 3, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8,
+};
+
+static const static_codebook _44p7_l1_0 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44p7_l1_0,
+ 1, -514516992, 1620639744, 7, 0,
+ (long *)_vq_quantlist__44p7_l1_0,
+ 0
+};
+
+static const long _huff_lengthlist__44p7_lfe[] = {
+ 2, 3, 1, 3,
+};
+
+static const static_codebook _huff_book__44p7_lfe = {
+ 2, 4,
+ (long *)_huff_lengthlist__44p7_lfe,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44p7_long[] = {
+ 2, 7,14,16,17,17,18,20, 6, 3, 5, 8,10,11,13,15,
+ 13, 5, 3, 5, 8, 9,11,12,15, 7, 4, 3, 5, 7, 9,11,
+ 16,10, 7, 5, 6, 7, 9,10,17,11, 8, 7, 7, 6, 8, 8,
+ 19,13,11, 9, 9, 8, 8, 9,20,14,13,11,10, 8, 9, 9,
+};
+
+static const static_codebook _huff_book__44p7_long = {
+ 2, 64,
+ (long *)_huff_lengthlist__44p7_long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44p7_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p7_p1_0[] = {
+ 2, 5, 5, 4, 7, 7, 4, 7, 7, 5, 7, 7, 7, 8, 9, 7,
+ 9, 9, 5, 7, 7, 7, 9, 9, 7, 9, 8, 6, 7, 8, 8, 9,
+ 10, 8, 9,10, 8, 9,10,10,10,12,10,11,11, 8,10,10,
+ 10,11,12,10,11,11, 6, 8, 7, 8,10, 9, 8,10, 9, 8,
+ 10,10,10,11,11,10,12,11, 8,10, 9,10,11,11,10,12,
+ 10, 5, 8, 8, 8,10,10, 8,10,10, 7, 9,10, 9,10,11,
+ 9,11,11, 8,10,10,10,11,12,10,12,11, 7, 9, 9, 9,
+ 10,11, 9,11,11, 9, 9,11,10,11,12,11,11,12, 9,11,
+ 11,11,12,12,11,12,12, 7, 9, 9,10,11,11,10,12,11,
+ 9,11,10,11,11,12,11,13,12,10,11,11,12,13,13,11,
+ 13,11, 5, 8, 8, 8,10,10, 8,10,10, 8,10,10,10,11,
+ 12,10,12,11, 7,10, 9, 9,11,11, 9,11,10, 7, 9, 9,
+ 10,11,12,10,11,11,10,11,11,11,11,13,12,13,13, 9,
+ 10,11,11,12,13,11,12,11, 7, 9, 9, 9,11,11, 9,11,
+ 10, 9,11,11,11,12,12,11,12,12, 9,11, 9,11,12,11,
+ 10,12,11,
+};
+
+static const static_codebook _44p7_p1_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p7_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44p7_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44p7_p2_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p7_p2_0[] = {
+ 4, 6, 6, 9, 9, 6, 8, 8,10,10, 6, 8, 8,10,10, 8,
+ 10,10,12,13, 8,10,10,13,12, 6, 8, 8,10,10, 8, 8,
+ 9,10,11, 8, 9, 9,11,11,10,10,11,12,13,10,11,11,
+ 13,13, 6, 8, 8,10,10, 8, 9, 9,11,11, 8, 9, 8,11,
+ 10,10,11,11,13,13,10,11,10,13,12, 9,10,10,12,12,
+ 10,10,11,12,13,10,11,11,13,13,12,12,13,12,15,13,
+ 13,13,15,14, 9,10,10,12,12,10,11,11,13,13,10,11,
+ 10,13,12,12,13,13,14,15,12,13,12,15,12, 6, 8, 8,
+ 10,11, 8, 9,10,11,12, 8, 9, 9,11,11,10,11,12,13,
+ 14,10,11,11,13,13, 8, 9, 9,11,12, 9,10,11,12,13,
+ 9,10,10,12,13,11,12,13,13,15,11,12,12,14,14, 8,
+ 9, 9,11,12, 9,10,11,12,13, 9,10,10,13,12,11,12,
+ 13,14,15,11,12,12,14,13,10,11,12,13,14,11,12,13,
+ 13,15,12,13,13,14,14,13,13,14,14,16,14,15,14,16,
+ 15,10,12,11,14,13,12,12,13,14,14,11,12,12,14,14,
+ 14,14,15,15,16,13,14,14,16,14, 6, 8, 8,11,10, 8,
+ 9, 9,11,11, 8,10, 9,12,11,10,11,11,13,13,10,12,
+ 11,14,13, 8, 9, 9,12,11, 9,10,10,12,13, 9,11,10,
+ 13,12,11,12,12,14,14,11,13,12,15,14, 8, 9, 9,12,
+ 11, 9,10,10,13,12, 9,11,10,13,12,11,12,12,14,14,
+ 11,13,12,15,13,10,11,12,13,14,11,12,13,13,14,12,
+ 13,12,14,14,13,13,14,14,16,14,15,14,16,16,10,12,
+ 11,14,13,12,13,13,14,14,11,13,12,15,13,14,14,15,
+ 16,16,13,14,13,16,14, 9,10,11,12,13,11,11,12,13,
+ 14,11,11,12,13,14,13,13,14,14,16,13,14,14,15,15,
+ 11,11,12,13,14,12,12,13,13,15,12,13,13,14,15,14,
+ 14,15,15,17,14,14,15,16,16,11,12,12,13,14,12,12,
+ 13,14,15,12,13,12,14,15,14,14,15,15,17,14,15,14,
+ 16,16,13,14,14,15,16,14,14,15,15,17,14,15,15,16,
+ 16,15,16,17,16,18,16,17,16,17,17,13,14,14,16,15,
+ 14,15,15,16,16,14,15,14,16,15,16,16,17,17,18,16,
+ 16,16,17,16, 9,11,10,13,12,11,12,11,14,13,11,12,
+ 11,14,13,13,14,14,16,15,13,14,13,16,14,11,12,12,
+ 14,13,12,12,13,14,14,12,13,13,15,14,14,14,15,16,
+ 16,14,15,14,17,15,11,12,11,14,13,12,13,13,15,14,
+ 12,13,12,15,13,14,15,14,16,16,14,15,14,17,15,13,
+ 14,14,15,16,14,14,15,16,16,14,15,15,16,16,15,16,
+ 16,16,17,16,16,16,17,17,13,14,14,16,15,14,15,15,
+ 17,16,14,15,14,17,15,16,17,17,17,17,16,16,16,18,
+ 16, 6, 8, 8,11,11, 8, 9, 9,11,12, 8, 9, 9,12,11,
+ 10,11,11,13,14,10,11,11,14,13, 8, 9, 9,11,12, 9,
+ 10,10,12,13, 9,10,10,13,12,11,11,12,13,15,11,12,
+ 12,15,14, 8, 9, 9,12,11, 9,10,11,12,13, 9,11,10,
+ 13,12,11,12,12,14,15,11,13,12,15,14,10,11,11,13,
+ 14,11,12,12,13,14,11,12,12,14,14,13,13,14,14,16,
+ 13,14,14,16,15,11,12,11,14,13,12,13,13,14,14,11,
+ 13,12,14,13,14,14,15,16,16,13,14,14,16,14, 8, 9,
+ 9,11,12, 9,10,10,12,13, 9,10,10,13,12,11,12,12,
+ 14,15,11,12,12,14,14, 9, 9,10,11,13,10,10,12,12,
+ 14,10,10,11,13,13,12,12,13,14,16,12,12,13,15,15,
+ 9,10,10,13,12,10,11,11,13,14,10,12,11,14,13,12,
+ 13,13,15,15,12,13,13,15,15,11,11,12,13,15,12,12,
+ 13,13,15,12,13,13,14,15,14,14,15,15,17,14,15,15,
+ 16,16,11,13,12,15,14,13,13,13,15,15,12,14,13,15,
+ 14,15,15,15,16,16,14,15,15,17,15, 7, 9, 9,12,11,
+ 9,10,10,12,12, 9,11,10,13,12,11,12,12,14,14,11,
+ 13,12,15,14, 9,10,10,12,12,10,10,11,12,13,10,11,
+ 11,14,13,12,12,13,14,15,12,13,13,15,14, 9,10,10,
+ 12,12,10,11,11,13,13,10,11,10,14,12,12,13,13,15,
+ 15,12,13,12,15,13,11,12,12,14,14,12,12,13,14,15,
+ 12,13,13,15,15,14,13,14,13,16,14,15,15,16,16,11,
+ 12,12,14,14,13,13,14,15,15,12,13,12,15,14,15,15,
+ 15,16,16,14,15,14,17,14,10,11,12,13,14,11,12,13,
+ 14,15,11,12,12,14,15,13,14,15,15,17,14,14,14,16,
+ 16,11,12,13,12,15,12,12,14,13,16,13,13,14,13,16,
+ 14,14,15,14,17,15,15,15,15,17,11,13,12,15,15,13,
+ 13,14,15,16,12,14,13,16,15,15,15,15,17,17,15,15,
+ 15,17,16,14,14,15,14,16,14,14,16,14,17,15,15,15,
+ 14,17,16,16,17,15,18,17,17,17,16,18,14,15,15,17,
+ 16,15,16,16,17,17,15,16,15,17,16,17,17,17,18,18,
+ 16,17,16,18,17,10,11,11,14,13,11,12,12,14,14,11,
+ 13,12,15,14,14,14,14,16,16,14,15,14,16,15,11,12,
+ 12,15,13,12,13,13,15,14,13,14,13,16,14,14,15,15,
+ 16,16,15,16,15,17,16,11,13,12,15,14,13,13,14,15,
+ 15,12,14,13,16,14,15,15,15,17,17,14,16,15,17,16,
+ 14,14,14,16,15,14,15,15,16,16,15,16,15,17,16,16,
+ 16,16,16,17,16,17,17,18,17,14,15,15,16,16,15,15,
+ 16,17,16,14,15,15,17,16,17,17,17,18,18,16,17,16,
+ 18,16, 6, 8, 8,11,11, 8, 9, 9,11,12, 8, 9, 9,12,
+ 11,10,11,12,13,14,10,11,11,14,13, 8, 9, 9,11,12,
+ 9,10,11,12,13, 9,11,10,13,12,11,12,13,14,15,11,
+ 12,12,15,14, 8, 9, 9,12,11, 9,10,10,12,13, 9,10,
+ 10,13,12,11,12,12,14,15,11,12,12,14,13,11,11,12,
+ 13,14,11,12,13,13,15,12,13,13,14,14,13,14,14,14,
+ 16,14,15,14,16,16,10,11,11,14,13,11,12,12,14,14,
+ 11,12,12,14,13,13,14,14,15,16,13,14,13,16,14, 7,
+ 9, 9,11,11, 9,10,11,12,13, 9,10,10,12,12,11,12,
+ 13,14,15,11,12,12,14,14, 9,10,10,12,12,10,10,11,
+ 12,13,10,11,11,13,13,12,12,13,13,15,12,13,13,15,
+ 15, 9,10,10,12,12,10,11,11,13,13,10,11,10,13,12,
+ 12,13,13,14,15,12,13,12,15,13,11,12,12,14,14,12,
+ 12,13,14,15,13,14,13,15,15,14,13,15,13,16,15,15,
+ 15,16,16,11,12,12,14,14,12,13,13,14,15,12,13,12,
+ 15,14,14,15,15,16,17,13,14,13,16,13, 8, 9, 9,12,
+ 11, 9,10,10,12,13, 9,10,10,13,12,11,12,12,14,15,
+ 11,12,12,15,14, 9,10,10,12,13,10,11,12,13,14,10,
+ 11,11,14,13,12,13,13,15,15,12,13,13,15,15, 9,10,
+ 9,13,11,10,11,10,13,13,10,12,10,14,12,12,13,12,
+ 15,15,12,13,12,15,14,11,12,13,14,15,12,13,14,14,
+ 15,13,13,13,15,15,14,15,15,15,17,15,15,15,16,16,
+ 11,12,11,15,13,12,13,13,15,14,12,13,12,16,13,14,
+ 15,15,16,16,14,15,14,17,14,10,11,11,13,14,11,12,
+ 13,14,15,11,12,12,14,14,14,14,15,15,17,14,14,14,
+ 15,16,11,12,13,14,15,12,13,14,14,16,13,14,13,15,
+ 15,14,15,16,15,17,15,15,15,17,17,11,12,12,13,15,
+ 13,13,14,14,16,12,13,13,14,15,15,15,15,16,17,14,
+ 15,15,16,16,14,15,15,16,16,14,15,15,16,17,15,15,
+ 16,16,17,16,16,17,16,18,17,17,17,18,18,14,14,15,
+ 15,16,15,15,15,16,17,14,15,15,16,16,16,17,17,17,
+ 18,16,16,16,17,16,10,11,11,14,13,11,13,12,15,14,
+ 11,13,12,15,14,14,15,14,16,16,13,15,14,17,15,11,
+ 12,13,15,15,12,13,14,15,16,13,14,13,16,15,15,15,
+ 15,16,17,15,15,15,17,16,11,13,11,15,12,13,14,13,
+ 16,13,12,14,12,16,13,15,15,15,17,15,14,16,14,17,
+ 14,14,15,15,16,17,15,15,16,16,17,15,16,15,17,17,
+ 16,16,17,17,18,16,17,17,18,18,14,15,14,17,13,15,
+ 16,15,17,15,15,16,15,17,14,16,17,16,18,16,16,17,
+ 16,18,15, 9,11,11,13,13,10,12,12,14,14,11,12,12,
+ 14,14,13,14,14,15,16,13,14,14,16,16,10,11,12,14,
+ 14,11,12,13,14,15,11,13,13,15,15,13,14,14,15,16,
+ 14,15,15,16,16,11,12,12,14,14,12,13,13,15,15,12,
+ 13,12,15,14,14,15,15,16,16,14,15,14,17,16,12,13,
+ 13,15,16,13,13,14,15,16,13,14,14,16,16,14,15,16,
+ 16,17,15,16,16,17,17,13,14,14,16,15,14,15,15,17,
+ 16,14,15,14,17,15,16,16,17,17,17,16,16,16,18,16,
+ 10,11,12,14,14,11,12,13,14,15,11,13,12,15,15,13,
+ 14,15,16,16,14,15,15,17,16,11,11,13,14,15,12,12,
+ 14,14,16,12,13,14,15,15,14,14,15,16,17,15,15,15,
+ 17,17,12,13,12,15,15,13,14,14,16,15,13,14,13,16,
+ 15,15,16,15,17,17,15,16,15,17,16,13,12,15,14,16,
+ 14,13,15,14,17,14,13,15,15,17,15,14,17,15,18,16,
+ 15,17,17,18,14,15,15,17,16,15,16,16,17,17,15,16,
+ 15,17,16,16,17,17,18,18,16,17,16,18,17,10,11,11,
+ 14,14,11,12,12,14,15,11,13,12,15,14,13,14,14,16,
+ 16,14,15,14,16,16,11,12,12,14,14,12,12,13,15,15,
+ 12,13,13,15,15,14,14,15,16,16,14,15,15,17,16,11,
+ 12,12,15,15,13,13,13,15,15,12,13,13,15,15,15,15,
+ 15,17,17,14,15,15,17,16,13,14,13,16,15,14,14,14,
+ 16,16,14,15,14,17,16,15,15,16,16,17,16,17,16,18,
+ 17,14,15,15,16,16,15,15,15,17,17,14,15,15,17,16,
+ 16,17,17,18,18,16,17,16,18,16,12,13,13,15,15,13,
+ 14,14,16,16,13,14,14,16,16,14,15,16,16,18,15,16,
+ 16,17,17,13,13,14,14,16,14,14,15,15,17,14,14,15,
+ 15,17,15,15,17,15,18,16,16,17,17,18,13,14,14,16,
+ 16,14,15,15,16,17,14,15,15,17,16,16,17,16,17,18,
+ 16,17,16,18,17,15,14,16,13,18,16,15,17,14,18,16,
+ 15,17,14,18,17,16,18,15,19,17,17,18,16,19,15,16,
+ 16,17,17,16,17,17,18,18,16,17,16,18,17,18,18,18,
+ 19,18,17,18,17,19,17,11,12,12,15,15,13,13,14,15,
+ 16,13,14,13,16,15,15,15,15,16,17,15,16,15,17,16,
+ 12,13,13,15,15,13,13,14,15,16,14,15,14,16,15,15,
+ 15,16,16,17,16,16,16,18,17,12,13,13,15,15,14,14,
+ 15,16,16,13,14,13,16,15,16,16,16,17,17,15,16,15,
+ 18,16,15,15,15,17,15,14,15,15,16,16,16,17,16,17,
+ 16,16,16,17,16,17,17,18,17,19,18,15,15,16,17,17,
+ 16,16,16,17,17,15,16,15,17,16,17,18,18,18,18,16,
+ 17,16,18,16, 9,11,11,13,13,11,12,12,14,14,10,12,
+ 12,14,14,13,14,14,15,16,13,14,14,16,15,11,12,12,
+ 14,14,12,12,13,14,15,12,13,13,15,15,14,14,15,16,
+ 17,14,15,15,16,16,10,12,11,14,14,11,13,13,15,15,
+ 11,13,12,15,14,14,14,15,16,16,13,14,14,16,15,13,
+ 14,14,15,16,14,14,15,15,17,14,15,15,16,17,16,16,
+ 16,16,18,16,16,17,17,17,12,13,13,16,15,13,14,14,
+ 16,16,12,14,13,16,15,15,16,16,17,17,14,16,15,17,
+ 16,10,11,11,14,14,11,12,13,14,15,11,12,12,15,14,
+ 14,14,15,16,16,13,14,14,16,16,11,12,12,14,15,12,
+ 13,14,15,15,13,13,13,15,15,14,15,15,16,17,15,15,
+ 15,16,17,11,12,12,14,14,12,13,13,15,15,12,13,12,
+ 15,15,14,15,15,16,17,14,15,14,16,16,14,14,15,16,
+ 16,14,15,15,16,17,15,16,15,17,17,16,16,17,16,18,
+ 16,17,17,18,18,13,13,14,15,16,14,14,15,16,17,14,
+ 14,14,16,15,16,16,17,17,18,15,16,15,17,16,10,12,
+ 11,14,14,11,13,13,15,15,11,13,12,15,15,14,15,15,
+ 16,16,13,15,14,16,16,12,12,13,15,15,13,13,14,15,
+ 16,13,14,14,16,15,15,15,16,16,17,15,15,15,17,17,
+ 11,13,11,15,14,12,14,13,16,15,12,14,12,16,14,15,
+ 15,15,17,17,14,15,14,17,15,14,15,15,16,17,15,15,
+ 16,16,17,15,16,16,17,17,16,16,17,17,18,16,17,17,
+ 18,18,13,14,12,16,14,14,15,13,17,15,14,15,13,17,
+ 14,16,17,15,18,17,15,17,14,18,15,11,12,12,14,15,
+ 13,13,14,15,16,13,14,13,16,15,15,15,16,16,17,15,
+ 15,15,16,16,12,13,13,15,15,13,13,14,15,16,14,15,
+ 14,16,16,15,15,16,16,18,16,16,16,18,17,12,13,13,
+ 15,15,14,14,15,15,16,13,14,13,15,15,16,16,16,17,
+ 18,15,16,15,17,16,15,16,15,17,16,15,15,16,16,17,
+ 16,17,16,17,17,16,16,17,16,18,17,18,18,18,18,14,
+ 15,15,15,17,16,15,17,16,17,14,15,15,16,16,17,17,
+ 18,18,19,16,16,16,17,16,12,13,13,15,15,13,14,14,
+ 16,16,13,14,14,16,16,15,16,16,17,17,15,16,15,18,
+ 16,13,14,14,16,16,14,15,15,16,17,14,15,15,17,16,
+ 16,16,17,17,18,16,17,16,18,18,13,14,13,16,14,14,
+ 15,14,17,15,14,15,14,17,14,16,17,16,18,17,15,17,
+ 15,18,15,15,16,16,17,18,16,16,17,17,18,16,17,17,
+ 17,18,17,17,18,18,19,17,18,18,19,18,15,16,14,17,
+ 13,16,17,15,18,14,16,17,15,18,14,18,18,17,19,16,
+ 17,18,16,19,15,
+};
+
+static const static_codebook _44p7_p2_0 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p7_p2_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p7_p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44p7_p3_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p7_p3_0[] = {
+ 2, 5, 5, 4, 7, 7, 4, 7, 7, 5, 7, 8, 7, 8,10, 8,
+ 9, 9, 5, 7, 7, 8, 9, 9, 7,10, 8, 5, 7, 8, 8, 9,
+ 10, 8,10,10, 8, 9,10,10,10,12,10,12,12, 8,10,10,
+ 10,12,12,10,12,11, 5, 8, 7, 8,10,10, 8,10, 9, 8,
+ 10,10,10,11,12,10,12,12, 8,10, 9,10,12,12,10,12,
+ 10, 5, 8, 8, 7,10,10, 8,10,10, 7, 9,10, 9,10,12,
+ 10,12,12, 8,10,10,10,12,12,10,12,11, 7, 9,10, 9,
+ 11,12,10,12,11, 9, 9,12,11,10,14,12,12,13,10,12,
+ 11,12,13,13,11,14,12, 7,10, 9,10,11,11,10,12,11,
+ 9,11,11,11,11,13,12,14,13,10,12,12,12,14,14,11,
+ 14,12, 5, 8, 8, 8,10,10, 7,10,10, 8,10,10,10,11,
+ 12,10,12,12, 7,10, 9,10,12,12, 9,12,10, 7, 9,10,
+ 10,11,12,10,11,11,10,12,12,11,12,14,12,14,14, 9,
+ 11,11,12,13,14,11,13,11, 7,10, 9,10,11,12, 9,12,
+ 11,10,11,12,11,12,14,12,13,13, 9,12, 9,12,13,12,
+ 11,14,10,
+};
+
+static const static_codebook _44p7_p3_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p7_p3_0,
+ 1, -533200896, 1614282752, 2, 0,
+ (long *)_vq_quantlist__44p7_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44p7_p3_1[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p7_p3_1[] = {
+ 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 7, 8, 8, 7,
+ 8, 8, 7, 8, 7, 7, 8, 8, 7, 8, 8, 7, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 8, 8, 9, 8, 8, 8,
+ 8, 8, 8, 8, 9, 8, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 9, 8, 8, 8, 8, 8, 8, 8, 9, 8, 8, 9,
+ 8, 7, 8, 8, 7, 8, 8, 7, 8, 8, 7, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 9, 8, 8, 9, 8, 7, 8, 8, 8,
+ 8, 9, 8, 8, 8, 8, 8, 8, 8, 8, 9, 8, 9, 9, 8, 8,
+ 8, 9, 9, 9, 8, 9, 9, 7, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 9, 8, 9, 9, 8, 8, 8, 8, 9, 9, 8,
+ 9, 8, 7, 8, 8, 7, 8, 8, 7, 8, 8, 8, 8, 8, 8, 8,
+ 9, 8, 8, 9, 7, 8, 8, 8, 8, 8, 8, 8, 8, 7, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 8, 9, 9, 8,
+ 8, 8, 8, 9, 9, 8, 9, 8, 7, 8, 8, 8, 8, 8, 8, 9,
+ 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 8, 8, 8, 8, 9, 9,
+ 8, 9, 8,
+};
+
+static const static_codebook _44p7_p3_1 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p7_p3_1,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44p7_p3_1,
+ 0
+};
+
+static const long _vq_quantlist__44p7_p4_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p7_p4_0[] = {
+ 1, 5, 5, 5, 7, 8, 5, 8, 7, 5, 7, 8, 7, 8,10, 8,
+ 10,10, 5, 8, 7, 8,10,10, 7,10, 8, 6, 8, 9, 9,10,
+ 12, 9,11,11, 9,10,11,11,11,13,11,13,13, 9,11,11,
+ 11,12,13,11,13,11, 6, 9, 8, 9,11,11, 9,12,10, 9,
+ 11,11,11,11,13,11,13,13, 9,11,10,11,13,13,11,13,
+ 11, 6, 9, 9, 8,10,11, 9,12,11, 8,10,11,10,11,13,
+ 11,13,13, 9,11,11,11,13,12,11,13,11, 8,10,10, 9,
+ 11,12,10,12,12,10,10,12,11,11,14,12,13,14,10,12,
+ 12,12,13,13,11,14,11, 8,11,10,11,12,13,11,14,12,
+ 10,12,11,11,12,14,13,15,14,10,12,12,13,14,15,12,
+ 14,12, 5, 9, 9, 9,11,12, 8,11,10, 9,11,11,11,11,
+ 13,11,12,13, 8,11,10,11,13,13,10,13,11, 8,10,11,
+ 11,12,14,11,13,12,10,12,12,12,12,14,14,15,14,10,
+ 11,12,13,14,15,11,14,12, 8,10,10,10,12,12, 9,12,
+ 11,10,12,12,11,11,14,12,13,13,10,12,10,12,14,13,
+ 11,13,11,
+};
+
+static const static_codebook _44p7_p4_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p7_p4_0,
+ 1, -531365888, 1616117760, 2, 0,
+ (long *)_vq_quantlist__44p7_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44p7_p4_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p7_p4_1[] = {
+ 7, 8, 8,10,10, 8, 9, 9,10,11, 8, 9, 9,10,10, 9,
+ 10,10,11,11, 9,10,10,11,11, 8, 9, 9,10,10, 9, 9,
+ 10,11,11, 9,10,10,11,11,10,10,11,11,11,10,11,11,
+ 11,11, 8, 9, 9,10,10, 9,10,10,11,11, 9,10, 9,11,
+ 11,10,11,11,11,11,10,11,10,11,11,10,10,10,11,11,
+ 10,11,11,11,11,10,11,11,11,11,11,11,11,11,12,11,
+ 11,11,11,12,10,10,10,11,11,10,11,11,11,11,10,11,
+ 11,11,11,11,11,11,12,11,11,11,11,12,11, 8, 9,10,
+ 11,11, 9,10,11,11,11, 9,10,10,11,11,10,11,11,12,
+ 12,10,11,11,12,12,10,10,10,11,11,10,10,11,11,12,
+ 10,11,11,12,12,11,11,12,12,12,11,11,12,12,12,10,
+ 10,10,11,11,10,11,11,12,12,10,11,11,12,11,11,12,
+ 12,12,12,11,12,11,12,12,11,11,11,11,12,11,11,12,
+ 12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,11,11,11,12,12,11,12,12,12,12,11,12,11,12,12,
+ 12,12,12,12,12,12,12,12,12,12, 8,10, 9,11,11, 9,
+ 10,10,11,11, 9,10,10,11,11,10,11,11,12,12,10,11,
+ 11,12,12,10,10,10,11,11,10,11,11,12,12,10,11,11,
+ 12,12,11,11,12,12,12,11,12,12,12,12,10,10,10,11,
+ 11,10,11,11,12,12,10,11,10,12,11,11,12,11,12,12,
+ 11,12,11,12,12,11,11,11,12,12,11,12,12,12,12,11,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,11,11,
+ 11,12,11,11,12,12,12,12,11,12,11,12,12,12,12,12,
+ 12,12,12,12,12,12,12,10,11,11,11,12,11,11,12,12,
+ 12,11,11,11,12,12,11,12,12,12,12,11,12,12,12,12,
+ 11,11,12,12,12,11,12,12,12,12,12,12,12,12,12,12,
+ 12,13,12,13,12,12,12,13,13,11,12,11,12,12,11,12,
+ 12,12,12,11,12,12,12,12,12,12,12,13,13,12,12,12,
+ 13,13,12,12,12,12,12,12,12,12,12,13,12,12,13,13,
+ 13,12,13,13,13,13,12,13,13,13,13,12,12,12,12,12,
+ 12,12,13,13,13,12,12,12,13,12,12,13,13,13,13,12,
+ 13,13,13,13,10,11,11,12,11,11,11,11,12,12,11,12,
+ 11,12,12,11,12,12,12,12,11,12,12,12,12,11,11,11,
+ 12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,13,
+ 13,12,12,12,13,13,11,12,11,12,12,12,12,12,12,12,
+ 11,12,11,12,12,12,12,12,13,13,12,12,12,13,12,12,
+ 12,12,12,12,12,12,12,13,13,12,12,12,13,13,12,13,
+ 13,13,13,12,13,13,13,13,12,12,12,12,12,12,12,12,
+ 13,13,12,13,12,13,12,12,13,13,13,13,13,13,13,13,
+ 13, 8,10,10,11,11, 9,10,10,11,11, 9,10,10,11,11,
+ 10,11,11,12,12,10,11,11,12,12, 9,10,10,11,11,10,
+ 10,11,11,12,10,11,11,12,12,11,11,12,12,12,11,11,
+ 12,12,12,10,10,10,11,11,10,11,11,12,12,10,11,10,
+ 12,11,11,12,11,12,12,11,12,11,12,12,11,11,11,12,
+ 12,11,11,12,12,12,11,12,12,12,12,11,12,12,12,12,
+ 12,12,12,12,12,11,11,11,12,11,11,12,12,12,12,11,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12, 9,10,
+ 10,11,11,10,11,11,11,12,10,11,11,12,12,11,11,11,
+ 12,12,11,11,11,12,12,10,10,11,11,12,11,11,12,12,
+ 12,11,11,11,12,12,11,11,12,12,12,11,12,12,12,12,
+ 10,11,11,12,12,11,11,11,12,12,11,12,11,12,12,11,
+ 12,12,12,12,11,12,12,12,12,11,11,12,12,12,11,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,13,12,12,12,
+ 12,13,11,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,13,12, 9,10,10,11,11,
+ 10,11,11,12,12,10,11,11,12,11,11,12,11,12,12,11,
+ 12,11,12,12,10,11,11,12,12,11,11,11,12,12,11,12,
+ 11,12,12,11,12,12,12,12,12,12,12,12,12,10,11,11,
+ 12,12,11,12,11,12,12,11,12,11,12,12,12,12,12,13,
+ 12,12,12,12,12,12,11,12,11,12,12,11,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,13,12,12,12,12,13,11,
+ 12,12,12,12,12,12,12,13,12,11,12,12,12,12,12,12,
+ 12,13,12,12,12,12,13,12,10,11,11,12,12,11,12,12,
+ 12,12,11,12,12,12,12,12,12,12,12,13,12,12,12,13,
+ 13,11,11,12,12,12,12,12,12,12,13,12,12,12,12,12,
+ 12,12,13,12,13,12,12,13,13,13,11,12,12,12,12,12,
+ 12,12,13,13,12,12,12,13,12,12,13,12,13,13,12,13,
+ 12,13,13,12,12,12,12,12,12,12,13,12,13,12,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,12,12,12,13,
+ 13,12,13,13,13,13,12,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,10,11,11,12,12,11,12,12,12,12,11,
+ 12,12,12,12,12,12,12,13,13,12,12,12,13,13,11,12,
+ 12,12,12,12,12,12,12,13,12,12,12,13,12,12,12,13,
+ 13,13,12,13,13,13,13,11,12,12,12,12,12,12,12,13,
+ 13,12,12,12,13,12,12,13,13,13,13,12,13,12,13,13,
+ 12,12,12,12,12,12,13,13,13,13,12,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,12,12,12,13,12,12,13,
+ 13,13,13,12,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13, 8,10,10,11,11, 9,10,10,11,11, 9,10,10,11,
+ 11,10,11,11,12,12,10,11,11,12,12,10,10,10,11,11,
+ 10,11,11,11,12,10,11,11,12,12,11,11,12,12,12,11,
+ 11,12,12,12, 9,10,10,11,11,10,11,11,12,12,10,11,
+ 10,12,11,11,12,11,12,12,11,12,11,12,12,11,11,11,
+ 12,12,11,11,12,12,12,11,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,11,11,11,12,11,11,12,12,12,12,
+ 11,12,11,12,12,12,12,12,12,12,12,12,12,12,12, 9,
+ 10,10,11,11,10,11,11,12,12,10,11,11,12,12,11,11,
+ 12,12,12,11,12,12,12,12,10,11,11,12,12,11,11,12,
+ 12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,10,11,11,12,12,11,11,12,12,12,11,11,11,12,12,
+ 12,12,12,12,12,11,12,12,12,12,11,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,13,12,13,12,12,
+ 12,13,12,11,12,12,12,12,12,12,12,12,12,11,12,12,
+ 12,12,12,12,12,13,12,12,12,12,13,12, 9,10,10,11,
+ 11,10,11,11,12,12,10,11,11,12,12,11,11,11,12,12,
+ 11,12,11,12,12,10,11,11,12,12,11,11,12,12,12,11,
+ 11,11,12,12,11,12,12,12,12,11,12,12,12,12,10,11,
+ 10,12,11,11,11,11,12,12,11,12,11,12,12,11,12,12,
+ 12,12,11,12,11,12,12,11,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,13,12,12,12,12,13,
+ 11,12,11,12,12,12,12,12,12,12,11,12,12,12,12,12,
+ 12,12,13,12,12,12,12,13,12,10,11,11,12,12,11,12,
+ 12,12,12,11,12,12,12,12,12,12,12,13,13,12,12,12,
+ 13,13,11,12,12,12,12,12,12,12,12,13,12,12,12,13,
+ 13,12,12,13,13,13,12,13,13,13,13,11,12,12,12,12,
+ 12,12,12,12,13,12,12,12,12,12,12,13,13,13,13,12,
+ 13,12,13,13,12,12,12,12,13,12,13,13,13,13,12,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,12,12,12,
+ 12,12,12,13,13,13,13,12,13,12,13,13,13,13,13,13,
+ 13,13,13,13,13,13,11,11,11,12,12,11,12,12,12,12,
+ 11,12,12,12,12,12,12,12,13,13,12,12,12,13,12,11,
+ 12,12,12,12,12,12,12,13,13,12,12,12,13,13,12,12,
+ 13,13,13,12,13,13,13,13,11,12,11,12,12,12,12,12,
+ 13,12,12,12,12,13,12,12,13,12,13,13,12,13,12,13,
+ 12,12,12,12,12,13,12,12,13,13,13,12,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,12,12,12,12,12,12,
+ 13,13,13,13,12,13,12,13,12,13,13,13,13,13,13,13,
+ 13,13,13,10,11,11,12,12,10,11,11,12,12,10,11,11,
+ 12,12,11,12,12,12,12,11,12,12,12,12,11,11,11,12,
+ 12,11,11,12,12,12,11,12,12,12,12,12,12,12,13,13,
+ 12,12,12,13,13,11,11,11,12,12,11,12,12,12,12,11,
+ 12,11,13,12,12,12,12,13,13,12,12,12,13,13,11,12,
+ 12,12,12,12,12,12,12,13,12,12,12,13,13,12,12,13,
+ 13,13,12,13,12,13,13,11,12,12,12,12,12,12,12,13,
+ 12,12,12,12,13,12,12,13,13,13,13,12,13,13,13,13,
+ 10,11,11,12,12,11,12,12,12,12,11,12,12,12,12,12,
+ 12,12,13,13,12,12,12,13,13,11,11,12,12,12,11,12,
+ 12,12,13,12,12,12,13,13,12,12,13,13,13,12,12,13,
+ 13,13,11,12,12,12,12,12,12,12,13,13,12,12,12,13,
+ 13,12,13,13,13,13,12,13,12,13,13,12,12,12,12,13,
+ 12,12,13,12,13,12,12,13,13,13,12,12,13,13,13,12,
+ 13,13,13,13,12,12,12,12,13,12,12,13,13,13,12,12,
+ 12,13,13,13,13,13,13,13,12,13,13,13,13,10,11,11,
+ 12,12,11,12,12,12,12,11,12,12,12,12,12,12,12,13,
+ 13,12,12,12,13,13,11,12,12,12,12,11,12,12,12,13,
+ 12,12,12,13,13,12,12,13,13,13,12,13,13,13,13,11,
+ 12,12,12,12,12,12,12,13,13,12,12,12,13,12,12,13,
+ 12,13,13,12,13,12,13,13,12,12,12,12,12,12,12,12,
+ 13,13,12,13,12,13,13,12,13,13,13,13,13,13,13,13,
+ 13,12,12,12,13,12,12,13,13,13,13,12,13,12,13,13,
+ 13,13,13,13,13,13,13,13,13,13,11,11,11,12,12,11,
+ 12,12,12,12,11,12,12,12,12,12,12,12,13,13,12,12,
+ 12,13,13,11,12,12,12,12,12,12,12,12,13,12,12,12,
+ 13,13,12,12,13,13,13,12,12,13,13,13,11,12,12,12,
+ 12,12,12,12,13,13,12,12,12,13,13,12,13,13,13,13,
+ 12,13,12,13,13,12,12,12,12,12,12,12,13,12,13,12,
+ 13,13,13,13,12,13,13,12,13,13,13,13,13,13,12,12,
+ 12,12,12,12,13,13,13,13,12,13,12,13,13,13,13,13,
+ 13,13,13,13,13,13,13,10,11,11,12,12,11,12,12,12,
+ 13,11,12,12,13,12,12,12,12,13,13,12,12,12,13,13,
+ 11,12,12,12,12,12,12,12,13,13,12,13,12,13,13,12,
+ 12,13,13,13,12,13,13,13,13,11,12,12,12,13,12,12,
+ 12,13,13,12,12,12,13,12,12,13,13,13,13,12,13,12,
+ 13,13,12,12,12,12,12,12,12,13,13,13,12,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,12,12,12,13,12,
+ 12,13,13,13,13,12,13,12,13,13,13,13,13,13,13,13,
+ 13,13,13,13,10,11,11,12,12,10,11,11,12,12,10,11,
+ 11,12,12,11,12,12,12,12,11,12,12,12,12,11,11,11,
+ 12,12,11,11,12,12,13,11,12,12,12,12,12,12,12,13,
+ 13,12,12,12,13,13,10,11,11,12,12,11,12,12,12,12,
+ 11,12,11,12,12,12,12,12,13,13,12,12,12,13,12,11,
+ 12,12,12,12,12,12,12,12,13,12,12,12,13,13,12,12,
+ 13,13,13,12,13,13,13,13,11,12,12,12,12,12,12,12,
+ 13,13,12,12,12,13,12,12,13,13,13,13,12,13,12,13,
+ 13,10,11,11,12,12,11,12,12,12,12,11,12,12,12,12,
+ 12,12,12,13,13,12,12,12,13,13,11,12,12,12,12,12,
+ 12,12,12,13,12,12,12,13,13,12,12,13,13,13,12,12,
+ 13,13,13,11,12,12,12,12,12,12,12,13,13,11,12,12,
+ 13,12,12,13,13,13,13,12,13,12,13,13,12,12,12,12,
+ 13,12,12,13,13,13,12,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,12,12,12,13,12,12,12,13,13,13,12,
+ 12,12,13,13,13,13,13,13,13,12,13,13,13,13,10,11,
+ 11,12,12,11,12,12,12,12,11,12,12,12,12,12,12,12,
+ 13,13,12,12,12,13,13,11,12,12,12,12,12,12,12,12,
+ 13,12,12,12,13,13,12,12,13,13,13,12,12,13,13,13,
+ 11,12,11,12,12,12,12,12,13,13,11,12,12,13,12,12,
+ 13,12,13,13,12,13,12,13,13,12,12,12,12,12,12,12,
+ 13,13,13,12,13,12,13,13,12,13,13,13,13,13,13,13,
+ 13,13,12,12,12,13,12,12,13,12,13,13,12,13,12,13,
+ 13,13,13,13,13,13,12,13,12,13,13,10,11,11,12,12,
+ 11,12,12,12,12,11,12,12,13,12,12,12,12,13,13,12,
+ 12,12,13,13,11,12,12,12,12,12,12,12,12,13,12,12,
+ 12,13,13,12,12,13,13,13,12,13,13,13,13,11,12,12,
+ 12,12,12,12,12,13,13,12,12,12,13,12,12,13,13,13,
+ 13,12,13,12,13,13,12,12,12,12,13,12,12,13,13,13,
+ 12,13,13,13,13,13,13,13,13,13,13,13,13,13,13,12,
+ 12,12,12,12,12,13,13,13,13,12,13,12,13,13,13,13,
+ 13,13,13,13,13,13,13,13,11,11,11,12,12,11,12,12,
+ 12,12,11,12,12,12,12,12,12,12,13,13,12,12,12,13,
+ 13,11,12,12,12,12,12,12,12,13,13,12,12,12,13,13,
+ 12,12,13,13,13,12,13,13,13,13,11,12,12,12,12,12,
+ 12,12,13,13,12,12,12,13,12,12,13,12,13,13,12,13,
+ 12,13,13,12,12,12,12,12,12,13,13,13,13,12,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,12,12,12,12,
+ 12,12,13,13,13,13,12,13,12,13,12,13,13,13,13,13,
+ 13,13,13,13,12,
+};
+
+static const static_codebook _44p7_p4_1 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p7_p4_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p7_p4_1,
+ 0
+};
+
+static const long _vq_quantlist__44p7_p5_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p7_p5_0[] = {
+ 2, 6, 6, 9, 9, 5, 7, 8,10,11, 5, 8, 7,11,10, 8,
+ 10,11,12,13, 8,11,10,13,12, 6, 7, 8,10,11, 7, 8,
+ 10,10,12, 8, 9, 9,12,11,10,10,12,11,14,10,11,12,
+ 14,13, 6, 8, 7,11,10, 8, 9, 9,11,12, 7,10, 8,12,
+ 10,10,12,12,13,14,10,12,10,14,11, 9,10,11,11,12,
+ 10,10,11,11,13,11,12,12,13,13,12,11,13,11,15,13,
+ 14,13,14,14, 9,11,10,12,11,11,12,12,13,13,10,11,
+ 10,13,11,13,13,14,14,14,12,13,11,14,11, 7, 8, 9,
+ 11,12, 9, 9,11,12,13, 9,10,10,13,12,11,12,13,13,
+ 15,11,12,12,14,14, 9,10,10,12,13,10,10,12,12,14,
+ 11,11,11,13,13,12,12,13,13,15,12,13,13,15,14, 9,
+ 10,10,12,13,10,11,11,13,14,10,12,11,14,13,12,13,
+ 13,14,15,12,13,13,15,14,12,12,13,13,14,12,13,13,
+ 13,15,13,14,14,14,15,14,14,15,14,16,14,15,15,16,
+ 16,12,13,13,14,14,13,13,14,15,14,12,13,13,15,14,
+ 14,15,15,15,16,14,15,14,16,14, 7, 9, 8,12,11, 9,
+ 10,10,12,13, 9,11, 9,13,12,11,12,12,14,14,11,13,
+ 12,15,13, 9,10,10,13,12,10,11,12,13,14,10,12,11,
+ 14,13,12,13,13,14,15,13,13,13,15,14, 9,10,10,13,
+ 12,11,11,11,13,13,10,12,10,14,12,13,13,13,14,15,
+ 12,13,12,15,13,12,13,13,14,14,12,13,13,14,15,13,
+ 14,13,15,15,14,14,15,14,16,14,15,15,16,15,12,13,
+ 12,14,13,13,13,13,15,14,12,13,13,15,13,14,15,15,
+ 16,15,14,15,14,16,14,11,12,12,13,14,12,13,14,14,
+ 15,12,13,13,14,15,14,14,15,15,16,14,15,15,16,16,
+ 12,13,13,14,15,13,13,14,14,16,13,14,14,15,15,15,
+ 15,16,15,17,15,15,15,16,16,12,13,13,14,15,13,14,
+ 14,15,16,13,14,14,15,15,15,15,16,16,17,15,15,15,
+ 17,16,14,15,15,16,16,15,15,16,15,16,15,16,16,16,
+ 17,16,16,17,16,18,16,16,17,18,17,14,15,15,16,16,
+ 15,16,16,16,17,15,16,15,17,16,16,17,17,17,18,16,
+ 16,16,17,16,11,12,12,14,13,12,13,13,15,14,12,14,
+ 13,15,14,14,15,15,16,16,14,15,14,16,15,12,13,13,
+ 15,14,13,14,14,15,15,13,14,14,16,15,15,15,15,16,
+ 16,15,16,15,17,16,12,13,13,15,14,13,14,14,15,15,
+ 13,14,13,16,14,15,15,15,16,16,15,15,15,17,15,14,
+ 15,15,16,16,15,15,15,16,16,15,16,16,17,17,16,16,
+ 17,17,17,16,17,17,18,17,14,15,15,16,15,15,15,16,
+ 16,16,15,15,15,17,15,17,17,17,18,17,16,17,16,18,
+ 16, 6, 9, 9,12,12, 8,10,10,12,13, 9,11,10,13,12,
+ 10,12,12,14,14,11,13,12,14,14, 8,10,10,12,12, 9,
+ 10,11,12,14,10,11,11,13,13,12,12,13,13,15,12,13,
+ 13,15,14, 9,10,10,13,13,10,11,11,13,13,10,12,10,
+ 14,13,12,13,13,14,15,12,13,13,15,14,11,12,12,13,
+ 14,12,12,13,13,15,12,13,13,14,14,13,13,14,13,16,
+ 14,15,15,16,15,11,12,12,14,14,13,13,13,15,14,12,
+ 13,13,15,14,14,15,15,16,15,14,14,14,16,14, 7, 9,
+ 10,12,12, 9,10,11,13,13, 9,11,10,13,13,11,12,13,
+ 14,15,12,13,13,15,14, 9,10,11,12,13,10,10,12,13,
+ 14,11,11,12,14,14,12,12,14,14,15,13,13,13,15,15,
+ 9,11,11,13,13,11,12,12,14,14,10,12,10,14,13,13,
+ 14,13,15,15,12,14,13,15,14,12,12,13,13,15,12,12,
+ 14,13,15,13,14,14,15,15,14,14,15,14,17,14,15,15,
+ 16,16,12,13,13,15,14,13,14,14,15,15,12,14,13,15,
+ 14,14,15,15,16,16,14,15,14,16,14, 7,10,10,12,12,
+ 10,11,11,12,13,10,12,10,14,12,12,13,13,14,15,12,
+ 13,13,15,14, 9,11,10,13,12,10,10,12,12,14,11,13,
+ 12,14,13,13,13,14,13,15,13,14,14,15,14,10,11,11,
+ 13,13,12,12,12,13,14,10,12,10,14,12,13,14,14,15,
+ 15,13,14,13,15,13,12,13,13,14,14,12,12,13,14,15,
+ 13,14,14,15,15,13,13,14,13,15,14,15,15,16,16,12,
+ 13,13,14,14,13,14,14,15,15,12,13,13,15,13,15,15,
+ 15,16,16,13,14,13,16,13,11,12,13,14,14,12,13,14,
+ 14,15,12,13,13,15,15,14,14,15,15,17,14,15,15,16,
+ 16,12,13,14,14,15,13,13,14,14,16,13,14,14,15,16,
+ 14,14,16,15,17,15,15,16,16,16,12,13,13,15,15,13,
+ 14,14,15,16,13,14,14,15,16,15,15,16,17,17,15,16,
+ 15,17,16,14,15,15,15,16,15,15,16,15,17,15,15,16,
+ 16,17,16,16,16,16,18,16,16,17,17,17,14,15,15,16,
+ 16,15,16,16,16,17,15,16,15,17,16,16,17,17,17,17,
+ 16,17,16,18,17,11,12,12,14,14,13,13,14,14,15,13,
+ 14,13,15,14,14,15,15,15,16,14,15,15,17,15,12,13,
+ 13,15,14,13,13,14,15,15,14,15,14,16,15,15,15,15,
+ 15,16,15,16,15,17,16,12,13,13,15,15,14,14,14,15,
+ 16,13,14,13,16,15,15,15,16,16,17,15,16,15,17,15,
+ 14,15,15,16,16,14,15,15,16,16,15,16,16,17,16,15,
+ 15,16,15,17,16,17,17,18,17,14,15,15,16,16,15,16,
+ 16,16,17,14,15,15,17,16,17,17,17,17,18,15,16,16,
+ 18,15, 6, 9, 9,12,12, 9,10,11,12,13, 8,10,10,13,
+ 12,11,12,13,14,14,10,12,12,14,13, 9,10,10,12,13,
+ 10,10,12,13,14,10,11,11,13,13,12,13,13,14,15,12,
+ 13,13,15,14, 8,10,10,12,12,10,11,11,13,13, 9,11,
+ 10,13,13,12,13,13,14,15,12,13,12,15,13,11,12,12,
+ 14,14,12,13,13,13,15,13,13,13,14,15,14,14,15,14,
+ 16,14,15,15,15,15,11,12,12,14,13,12,13,13,15,14,
+ 12,13,12,15,13,14,14,15,16,16,13,14,13,16,13, 7,
+ 10,10,12,12,10,10,12,12,14,10,11,11,13,12,12,13,
+ 13,13,15,12,13,13,15,14,10,11,11,13,13,10,10,12,
+ 12,14,12,12,12,14,13,13,13,14,13,15,13,14,14,15,
+ 14, 9,10,11,13,13,11,12,12,13,14,10,12,10,14,12,
+ 13,13,14,14,15,13,13,12,15,13,12,13,13,14,14,12,
+ 13,13,14,15,13,14,14,15,15,13,13,15,13,16,15,15,
+ 15,16,16,12,13,13,14,14,13,14,14,15,15,12,13,12,
+ 15,14,15,15,15,16,16,13,14,13,15,13, 7,10, 9,12,
+ 12, 9,10,11,13,13, 9,11,10,13,13,11,13,13,14,15,
+ 11,13,12,15,14, 9,11,11,13,13,10,10,12,13,14,11,
+ 12,12,14,14,12,13,14,14,15,13,13,13,15,15, 9,11,
+ 10,13,12,11,12,11,14,14,10,12,10,14,13,13,14,13,
+ 15,15,12,14,12,15,14,12,13,13,14,15,13,13,14,14,
+ 15,13,14,14,15,15,14,14,15,14,17,14,15,15,16,16,
+ 12,13,12,15,13,13,14,14,15,15,12,14,13,15,13,14,
+ 15,15,16,16,14,15,14,16,14,11,12,12,14,14,13,13,
+ 14,14,15,13,14,13,15,15,14,15,15,16,17,14,15,15,
+ 16,15,12,13,13,15,15,13,13,14,15,16,14,14,14,16,
+ 15,15,15,16,15,17,15,16,15,17,16,12,13,13,14,15,
+ 14,14,15,15,16,13,14,13,15,15,15,15,16,16,17,15,
+ 15,15,16,15,14,15,15,16,16,14,15,15,16,17,15,16,
+ 16,17,17,16,15,16,15,17,16,17,17,17,17,14,15,15,
+ 15,16,15,15,16,16,17,14,15,15,16,16,16,16,17,17,
+ 18,15,16,15,17,15,11,13,12,14,14,12,13,13,15,15,
+ 12,14,13,15,14,14,15,15,16,16,14,15,14,16,15,12,
+ 13,13,15,15,13,14,14,15,16,13,14,14,16,16,15,15,
+ 16,16,17,15,16,15,17,16,12,13,13,15,14,13,14,14,
+ 16,15,13,14,13,16,14,15,16,15,17,16,15,15,14,18,
+ 15,14,15,15,16,16,15,15,16,16,17,15,16,15,17,16,
+ 16,16,17,17,18,16,17,17,18,17,14,15,15,16,15,15,
+ 16,15,17,16,15,15,15,17,15,16,17,17,18,17,16,17,
+ 16,18,15,10,12,12,14,14,12,13,13,14,14,12,13,13,
+ 14,14,13,14,14,15,15,13,14,14,16,15,11,12,13,14,
+ 14,12,13,13,15,15,12,13,13,15,15,13,14,15,15,16,
+ 14,15,15,16,16,12,13,13,14,14,13,13,14,15,15,13,
+ 14,13,15,15,14,15,15,16,16,14,15,14,16,15,13,14,
+ 14,15,15,13,14,14,15,16,14,14,15,16,16,14,15,15,
+ 15,17,15,16,16,17,17,13,14,14,15,15,14,15,15,16,
+ 16,14,15,15,16,16,15,16,16,16,17,15,16,15,17,16,
+ 11,12,12,14,14,12,13,13,14,15,12,13,13,15,14,13,
+ 14,14,15,16,13,14,14,16,15,12,13,13,14,15,13,13,
+ 14,15,15,13,14,14,15,15,14,14,15,15,17,14,15,15,
+ 16,16,12,13,13,15,15,13,14,14,15,15,13,14,13,15,
+ 15,14,15,15,16,17,14,15,15,16,16,13,13,14,15,16,
+ 14,14,15,15,16,14,15,15,16,16,15,15,16,15,18,15,
+ 16,16,17,17,14,15,15,16,16,15,15,15,16,16,14,15,
+ 15,17,16,16,16,16,17,17,15,16,16,17,16,10,12,12,
+ 14,14,12,13,13,14,15,12,13,13,15,14,14,14,15,15,
+ 16,14,15,14,16,15,12,13,13,15,14,13,13,14,15,15,
+ 13,14,14,15,15,14,14,15,15,16,14,15,15,16,16,12,
+ 13,13,15,15,13,14,14,15,16,13,14,13,15,14,15,15,
+ 15,16,16,14,15,15,16,15,13,14,14,16,15,14,14,14,
+ 15,16,14,15,15,16,16,15,15,16,15,17,16,17,16,17,
+ 17,14,14,15,15,16,15,15,16,16,16,14,15,14,16,15,
+ 16,16,16,17,17,15,16,15,17,15,11,13,13,14,15,13,
+ 13,14,15,15,13,14,13,15,15,14,15,15,15,16,14,15,
+ 15,17,15,13,13,14,15,15,13,14,15,15,16,14,14,14,
+ 16,16,15,14,16,15,17,15,16,16,17,16,13,14,14,15,
+ 15,14,14,14,16,16,13,15,14,16,15,15,15,16,17,17,
+ 15,16,15,17,16,14,15,15,15,16,15,15,16,15,17,15,
+ 16,16,16,17,16,16,17,15,18,16,17,17,17,17,14,15,
+ 15,16,16,15,16,16,17,17,15,16,15,17,16,16,17,17,
+ 18,18,16,17,15,18,16,10,12,12,14,14,13,13,14,14,
+ 15,13,14,13,15,14,14,15,15,15,16,15,15,15,16,15,
+ 12,13,13,15,14,12,12,14,14,15,14,15,14,16,15,15,
+ 14,15,14,17,15,16,16,17,16,12,13,13,14,15,14,14,
+ 15,15,16,13,14,12,16,14,15,16,16,16,17,15,16,14,
+ 17,15,14,15,14,16,15,14,14,15,15,15,15,16,15,17,
+ 16,15,14,16,14,16,16,17,17,18,17,14,14,15,15,16,
+ 15,16,16,16,17,14,15,14,16,15,16,16,17,17,17,15,
+ 16,14,17,14,10,12,12,14,13,12,13,13,14,14,11,13,
+ 12,14,14,13,14,14,15,16,13,14,14,16,15,12,13,13,
+ 14,14,13,13,14,15,15,13,14,13,15,15,14,14,15,15,
+ 16,14,15,15,16,16,11,13,12,14,14,12,13,13,15,15,
+ 12,13,13,15,15,14,15,15,16,16,13,14,14,16,15,13,
+ 14,14,15,15,14,15,15,15,16,14,15,15,16,16,15,16,
+ 16,16,17,16,16,16,17,17,13,14,14,15,15,14,15,15,
+ 16,16,13,14,14,16,15,15,16,16,17,17,15,15,15,17,
+ 15,11,12,12,14,14,12,13,13,14,15,12,13,13,15,14,
+ 14,14,15,15,16,14,14,14,16,15,12,13,13,15,14,13,
+ 13,14,15,15,13,14,14,16,15,14,15,15,15,16,15,15,
+ 15,16,16,12,13,13,14,15,13,13,14,15,15,13,14,13,
+ 15,15,15,15,15,16,16,14,15,14,16,15,14,14,15,16,
+ 16,14,15,15,15,16,15,16,15,16,16,15,15,16,15,17,
+ 16,16,16,17,17,13,14,14,15,16,14,15,15,16,16,14,
+ 14,14,16,16,16,16,16,17,17,15,15,15,17,15,11,12,
+ 12,14,14,12,13,13,14,15,12,13,13,15,14,14,14,14,
+ 15,16,13,14,14,16,15,12,13,13,15,15,13,13,14,15,
+ 16,13,14,14,15,15,14,15,15,16,17,14,15,15,17,16,
+ 12,13,13,15,14,13,14,14,15,15,13,14,13,15,15,14,
+ 15,15,16,16,14,15,14,17,15,14,15,15,16,16,14,15,
+ 15,16,17,15,15,15,17,17,15,16,16,16,17,16,17,16,
+ 17,17,13,15,14,16,15,14,15,15,16,16,14,15,14,16,
+ 15,16,16,16,17,17,15,16,15,17,15,10,12,12,14,14,
+ 13,13,14,14,15,13,14,13,15,14,14,15,15,15,17,14,
+ 15,15,16,15,12,13,13,15,14,12,12,14,14,15,14,15,
+ 14,16,15,15,14,16,15,17,15,16,16,17,16,12,13,13,
+ 14,15,14,14,15,15,16,12,14,12,15,14,15,16,16,16,
+ 17,15,16,14,17,14,14,15,14,16,16,14,14,15,15,16,
+ 15,16,16,17,16,15,14,16,14,17,16,17,17,18,17,14,
+ 14,15,15,16,15,15,16,16,17,14,15,14,16,15,16,17,
+ 17,17,18,15,16,14,17,14,11,13,13,15,14,13,13,14,
+ 15,15,12,14,13,15,15,14,15,15,15,17,14,15,14,16,
+ 15,13,14,14,15,15,13,14,15,15,16,14,15,14,16,16,
+ 15,15,16,16,17,15,16,16,17,17,13,14,13,15,15,14,
+ 14,14,16,16,13,15,14,16,15,15,16,16,17,17,15,16,
+ 14,17,15,15,15,15,16,17,15,15,16,16,17,15,16,16,
+ 17,17,16,15,17,16,17,17,17,17,18,18,14,15,15,17,
+ 15,15,16,16,17,16,15,16,15,17,15,16,17,17,17,17,
+ 16,17,15,18,15,
+};
+
+static const static_codebook _44p7_p5_0 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p7_p5_0,
+ 1, -528744448, 1616642048, 3, 0,
+ (long *)_vq_quantlist__44p7_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44p7_p5_1[] = {
+ 3,
+ 2,
+ 4,
+ 1,
+ 5,
+ 0,
+ 6,
+};
+
+static const long _vq_lengthlist__44p7_p5_1[] = {
+ 2, 3, 3, 3, 3, 3, 3,
+};
+
+static const static_codebook _44p7_p5_1 = {
+ 1, 7,
+ (long *)_vq_lengthlist__44p7_p5_1,
+ 1, -533200896, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p7_p5_1,
+ 0
+};
+
+static const long _vq_quantlist__44p7_p6_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p7_p6_0[] = {
+ 2, 5, 6, 5, 7, 8, 5, 8, 7, 5, 7, 7, 7, 7, 9, 8,
+ 9, 9, 5, 7, 7, 8, 9, 9, 7, 9, 7, 6, 8, 8, 8, 9,
+ 10, 8, 9, 9, 8, 9,10, 9, 9,11,10,10,11, 8,10, 9,
+ 10,10,11, 9,10,10, 6, 8, 8, 8, 9, 9, 8,10, 9, 8,
+ 9,10, 9,10,10,10,11,10, 8,10, 9,10,11,10, 9,11,
+ 9, 6, 8, 8, 7, 9, 9, 8, 9, 9, 7, 9, 9, 9, 9,10,
+ 9,10,10, 8, 9, 9, 9,10,10, 9,10, 9, 7, 9, 9, 9,
+ 10,10, 9,10,10, 9, 9,10,10, 9,11,10,11,11, 9,10,
+ 10,10,11,11,10,11,10, 6, 9, 8, 9,10,10, 9,10, 9,
+ 8,10,10, 9, 9,10,10,11,11, 9,10,10,10,11,11, 9,
+ 11, 9, 6, 8, 8, 8, 9, 9, 7, 9, 9, 8, 9, 9, 9, 9,
+ 10, 9,10,10, 7, 9, 9, 9,10,10, 9,10, 9, 6, 8, 9,
+ 9, 9,10, 9,10,10, 9,10,10, 9, 9,11,10,11,11, 8,
+ 10,10,10,11,11, 9,10, 9, 7, 9, 9, 9,10,10, 9,10,
+ 10, 9,10,10,10,10,11,10,11,11, 9,10, 9,10,11,11,
+ 10,11, 9,
+};
+
+static const static_codebook _44p7_p6_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p7_p6_0,
+ 1, -527106048, 1620377600, 2, 0,
+ (long *)_vq_quantlist__44p7_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44p7_p6_1[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p7_p6_1[] = {
+ 4, 7, 7, 6, 7, 8, 6, 8, 7, 7, 7, 8, 7, 7, 8, 8,
+ 8, 8, 7, 7, 7, 8, 8, 8, 7, 8, 8, 7, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 8, 9, 9, 8, 8, 8,
+ 8, 9, 9, 8, 9, 8, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 9, 8, 9, 9, 8, 8, 8, 8, 9, 9, 8, 9,
+ 8, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9,
+ 8, 9, 9, 8, 8, 8, 8, 9, 9, 8, 9, 8, 7, 8, 8, 8,
+ 8, 9, 8, 9, 8, 8, 8, 8, 8, 8, 9, 8, 9, 9, 8, 8,
+ 8, 9, 9, 9, 8, 9, 9, 7, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 9, 8, 9, 9, 8, 8, 8, 8, 9, 9, 8,
+ 9, 8, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 9, 8, 9, 9, 8, 8, 8, 8, 9, 9, 8, 9, 8, 7, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 8, 9, 9, 8,
+ 8, 8, 8, 9, 9, 8, 9, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 9, 9, 8, 9, 9, 8, 8, 8, 9, 9, 9,
+ 8, 9, 8,
+};
+
+static const static_codebook _44p7_p6_1 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p7_p6_1,
+ 1, -530841600, 1616642048, 2, 0,
+ (long *)_vq_quantlist__44p7_p6_1,
+ 0
+};
+
+static const long _vq_quantlist__44p7_p7_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p7_p7_0[] = {
+ 1, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9,
+};
+
+static const static_codebook _44p7_p7_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p7_p7_0,
+ 1, -513979392, 1633504256, 2, 0,
+ (long *)_vq_quantlist__44p7_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44p7_p7_1[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p7_p7_1[] = {
+ 1, 5, 5, 4,10,10, 5,10,10, 5,10,10,10,10,10,10,
+ 10,10, 5,10,10,10,10,10, 9,10,10, 6,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10, 7,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10, 6,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10, 6,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,11,11,
+};
+
+static const static_codebook _44p7_p7_1 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p7_p7_1,
+ 1, -516716544, 1630767104, 2, 0,
+ (long *)_vq_quantlist__44p7_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44p7_p7_2[] = {
+ 12,
+ 11,
+ 13,
+ 10,
+ 14,
+ 9,
+ 15,
+ 8,
+ 16,
+ 7,
+ 17,
+ 6,
+ 18,
+ 5,
+ 19,
+ 4,
+ 20,
+ 3,
+ 21,
+ 2,
+ 22,
+ 1,
+ 23,
+ 0,
+ 24,
+};
+
+static const long _vq_lengthlist__44p7_p7_2[] = {
+ 1, 3, 2, 4, 5, 7, 7, 8, 8, 9, 9,10,10,11,11,12,
+ 12,13,13,14,14,15,15,15,15,
+};
+
+static const static_codebook _44p7_p7_2 = {
+ 1, 25,
+ (long *)_vq_lengthlist__44p7_p7_2,
+ 1, -518864896, 1620639744, 5, 0,
+ (long *)_vq_quantlist__44p7_p7_2,
+ 0
+};
+
+static const long _vq_quantlist__44p7_p7_3[] = {
+ 12,
+ 11,
+ 13,
+ 10,
+ 14,
+ 9,
+ 15,
+ 8,
+ 16,
+ 7,
+ 17,
+ 6,
+ 18,
+ 5,
+ 19,
+ 4,
+ 20,
+ 3,
+ 21,
+ 2,
+ 22,
+ 1,
+ 23,
+ 0,
+ 24,
+};
+
+static const long _vq_lengthlist__44p7_p7_3[] = {
+ 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5,
+};
+
+static const static_codebook _44p7_p7_3 = {
+ 1, 25,
+ (long *)_vq_lengthlist__44p7_p7_3,
+ 1, -529006592, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44p7_p7_3,
+ 0
+};
+
+static const long _huff_lengthlist__44p7_short[] = {
+ 3, 9,14,16,17,19,22,22, 5, 4, 6, 9,11,13,17,20,
+ 9, 5, 5, 6, 9,11,15,19,11, 7, 5, 5, 7, 9,13,17,
+ 14, 9, 7, 6, 6, 7,11,14,16,11, 9, 7, 6, 4, 4, 8,
+ 19,15,13,11, 9, 4, 3, 4,21,16,16,15,12, 6, 4, 4,
+};
+
+static const static_codebook _huff_book__44p7_short = {
+ 2, 64,
+ (long *)_huff_lengthlist__44p7_short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44p8_l0_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44p8_l0_0[] = {
+ 2, 4, 4, 7, 7, 8, 8,10,10,11,11,12,12, 4, 5, 5,
+ 7, 7, 9, 9,10, 9,12,10,12,12, 4, 5, 5, 7, 7, 9,
+ 9, 9,10,10,12,12,12, 7, 7, 7, 7, 8, 9, 8,11, 5,
+ 12, 6,12,10, 7, 7, 7, 8, 7, 8, 9, 5,11, 6,12,10,
+ 12, 8, 9, 9, 9, 9, 9, 9,11, 7,11, 7,11, 9, 8, 9,
+ 9, 9, 9, 9, 9, 7,10, 7,11, 9,11,10,10,10,10,10,
+ 10,10,11,10,11, 8,12, 9,10,10,10,10,10,10,10,10,
+ 11, 8,11, 9,12,10,11,11,11,11,11,11,11,11,12,10,
+ 12,11,10,11,11,11,11,11,11,11,11,10,12,11,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,11,12,12,12,
+ 12,12,12,12,12,12,11,12,12,
+};
+
+static const static_codebook _44p8_l0_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44p8_l0_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44p8_l0_0,
+ 0
+};
+
+static const long _vq_quantlist__44p8_l0_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p8_l0_1[] = {
+ 4, 4, 4, 5, 5, 4, 4, 5, 5, 5, 4, 5, 4, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5,
+};
+
+static const static_codebook _44p8_l0_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44p8_l0_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p8_l0_1,
+ 0
+};
+
+static const long _vq_quantlist__44p8_l1_0[] = {
+ 54,
+ 29,
+ 79,
+ 0,
+ 108,
+};
+
+static const long _vq_lengthlist__44p8_l1_0[] = {
+ 1, 2, 3, 6, 7, 7, 6, 7, 7, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8,
+};
+
+static const static_codebook _44p8_l1_0 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44p8_l1_0,
+ 1, -514516992, 1620639744, 7, 0,
+ (long *)_vq_quantlist__44p8_l1_0,
+ 0
+};
+
+static const long _huff_lengthlist__44p8_lfe[] = {
+ 2, 3, 1, 3,
+};
+
+static const static_codebook _huff_book__44p8_lfe = {
+ 2, 4,
+ (long *)_huff_lengthlist__44p8_lfe,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44p8_long[] = {
+ 2, 7,14,16,17,18,20,21, 7, 4, 6, 8,11,12,14,16,
+ 13, 5, 4, 4, 8, 9,11,13,15, 8, 4, 3, 5, 7, 9,10,
+ 17,11, 8, 4, 4, 6, 9, 9,17,11, 9, 7, 6, 5, 7, 8,
+ 19,13,11, 9, 9, 7, 8, 8,21,15,13,11,10, 8, 8, 7,
+};
+
+static const static_codebook _huff_book__44p8_long = {
+ 2, 64,
+ (long *)_huff_lengthlist__44p8_long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44p8_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p8_p1_0[] = {
+ 2, 5, 5, 4, 7, 7, 4, 7, 7, 5, 7, 7, 7, 8, 9, 7,
+ 9, 9, 5, 7, 7, 7, 9, 9, 7, 9, 8, 6, 7, 8, 8, 9,
+ 10, 8, 9,10, 8, 9,10,10,10,12,10,11,12, 8,10,10,
+ 10,11,12,10,11,11, 6, 8, 7, 8,10, 9, 8,10, 9, 8,
+ 10,10,10,11,11,10,12,11, 8,10, 9,10,12,11,10,12,
+ 10, 5, 8, 8, 8,10,10, 8,10,10, 7, 9,10, 9,10,11,
+ 9,11,11, 8,10,10,10,12,12,10,12,11, 7, 9, 9, 9,
+ 10,11, 9,11,11, 9, 9,11,10,11,12,10,11,12, 9,11,
+ 11,11,12,12,11,12,12, 7, 9, 9,10,11,11,10,12,11,
+ 9,11,10,11,11,12,11,13,12,10,11,11,12,13,13,11,
+ 13,11, 5, 8, 8, 8,10,10, 8,10,10, 8,10,10,10,11,
+ 12,10,12,11, 7,10, 9, 9,11,11, 9,11,10, 7, 9, 9,
+ 10,11,12,10,11,11,10,11,11,11,11,13,12,13,13, 9,
+ 10,11,12,12,13,11,12,11, 7, 9, 9, 9,11,11, 9,11,
+ 10, 9,11,11,11,12,12,11,12,12, 9,11, 9,10,12,11,
+ 10,12,11,
+};
+
+static const static_codebook _44p8_p1_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p8_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44p8_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44p8_p2_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p8_p2_0[] = {
+ 4, 6, 6, 9, 9, 6, 8, 8,10,10, 6, 8, 8,10,10, 8,
+ 9,10,12,12, 8,10, 9,12,12, 6, 8, 8,10,10, 8, 8,
+ 9,10,11, 8, 9, 9,11,11, 9,10,11,12,13,10,11,11,
+ 13,13, 6, 8, 8,10,10, 8, 9, 9,11,11, 8, 9, 8,11,
+ 10,10,11,11,13,13, 9,11,10,13,12, 9,10,10,12,12,
+ 10,10,11,12,13,10,11,11,13,13,12,12,13,12,15,12,
+ 13,13,15,14, 9,10,10,12,12,10,11,11,13,13,10,11,
+ 10,13,12,12,13,13,14,15,12,13,12,15,12, 7, 8, 8,
+ 10,11, 8, 9,10,11,12, 8, 9, 9,11,11,10,11,11,13,
+ 14,10,11,11,13,13, 8, 9, 9,11,12, 9,10,11,11,13,
+ 9,10,10,12,12,11,11,12,13,15,11,12,12,14,14, 8,
+ 9, 9,11,11, 9,10,11,12,13, 9,10,10,12,12,11,12,
+ 12,14,15,11,12,12,14,14,10,11,12,13,13,11,12,12,
+ 13,14,12,12,12,14,14,13,13,14,14,16,14,14,14,16,
+ 15,10,11,11,13,13,12,12,12,14,14,11,12,12,14,13,
+ 14,14,14,15,16,13,14,13,16,14, 7, 8, 8,11,10, 8,
+ 9, 9,11,11, 8,10, 9,12,11,10,11,11,13,13,10,11,
+ 11,14,13, 8, 9, 9,12,11, 9,10,10,12,12, 9,11,10,
+ 13,12,11,12,12,13,14,11,12,12,15,14, 8, 9, 9,12,
+ 11, 9,10,10,12,12, 9,11,10,13,11,11,12,12,14,14,
+ 11,12,12,14,13,10,11,11,13,13,11,12,12,13,14,12,
+ 13,12,14,14,13,13,14,14,16,13,14,14,16,15,10,11,
+ 11,13,13,12,12,12,14,14,11,12,12,14,13,13,14,14,
+ 15,15,13,14,13,16,14, 9,10,11,12,13,11,11,12,12,
+ 14,11,11,12,13,14,13,13,14,14,16,13,13,14,15,15,
+ 11,11,12,12,14,12,12,13,13,15,12,12,13,13,15,14,
+ 14,15,15,16,14,14,14,15,16,11,12,12,13,14,12,12,
+ 13,14,15,12,13,12,14,14,14,14,15,15,16,14,14,14,
+ 16,16,13,13,14,15,16,14,14,15,15,16,14,15,15,16,
+ 16,15,15,16,16,18,16,16,16,17,17,13,14,14,15,15,
+ 14,14,15,16,16,14,15,14,16,16,16,16,16,17,18,15,
+ 16,16,17,16, 9,11,10,13,12,11,12,11,14,13,11,12,
+ 11,14,12,13,14,13,15,14,13,14,13,16,14,11,12,12,
+ 14,13,12,12,13,14,14,12,13,12,15,14,14,14,14,16,
+ 16,14,15,14,17,15,11,12,11,14,12,12,13,12,15,13,
+ 12,13,12,15,13,14,14,14,16,15,14,15,14,16,15,13,
+ 14,14,15,15,14,14,15,16,16,14,15,14,16,16,15,15,
+ 16,16,17,16,16,16,17,17,13,14,14,16,15,14,15,15,
+ 16,16,14,15,14,17,15,16,16,16,17,17,15,16,15,18,
+ 16, 7, 8, 8,10,11, 8, 9, 9,11,12, 8, 9, 9,12,11,
+ 10,11,11,13,14,10,11,11,14,13, 8, 9, 9,11,11, 9,
+ 10,10,12,12, 9,10,10,12,12,11,12,12,13,14,11,12,
+ 12,14,14, 8, 9, 9,12,11, 9,10,11,12,13, 9,11,10,
+ 13,12,11,12,12,14,14,11,12,12,14,13,10,11,11,13,
+ 13,11,12,12,13,14,11,12,12,14,14,13,13,14,14,16,
+ 13,14,14,16,15,10,12,11,13,13,12,12,12,14,14,11,
+ 12,12,14,13,14,14,14,15,16,13,14,14,16,14, 8, 9,
+ 9,11,11, 9,10,10,12,12, 9,10,10,12,12,11,11,12,
+ 13,14,11,12,12,14,14, 9, 9,10,11,12,10,10,11,12,
+ 13,10,10,11,12,13,12,12,13,14,15,12,12,13,14,15,
+ 9,10,10,12,12,10,11,11,13,13,10,11,11,13,13,12,
+ 13,13,15,15,12,13,13,15,14,11,11,12,13,14,12,12,
+ 13,13,15,12,12,13,14,15,14,14,15,14,16,14,14,15,
+ 15,16,11,12,12,14,14,12,13,13,15,15,12,13,13,15,
+ 14,14,15,15,16,16,14,15,14,17,15, 8, 9, 9,11,11,
+ 9,10,10,12,12, 9,11,10,13,12,11,12,12,14,14,11,
+ 13,12,15,13, 9,10,10,12,12,10,10,11,12,13,10,12,
+ 11,13,13,12,12,13,13,15,12,13,13,15,14, 9,10,10,
+ 12,12,11,11,12,13,13,10,12,10,13,12,12,13,13,15,
+ 15,12,13,13,15,13,11,12,12,14,14,12,12,13,14,14,
+ 12,13,13,15,14,13,13,14,13,16,14,15,14,16,16,11,
+ 12,12,14,14,13,13,13,15,15,12,13,12,15,14,14,15,
+ 15,16,17,14,15,13,16,13,10,11,11,13,14,11,12,12,
+ 13,15,11,12,12,14,14,13,14,14,15,16,13,14,14,16,
+ 16,11,11,12,12,14,12,12,13,13,15,12,13,13,13,15,
+ 14,14,15,14,17,14,14,15,15,16,11,12,12,14,14,12,
+ 13,13,15,15,12,13,13,15,15,14,15,15,16,17,14,15,
+ 15,16,16,13,14,14,14,16,14,14,15,14,17,14,15,15,
+ 14,17,16,16,17,15,18,16,16,17,16,18,13,14,14,16,
+ 16,14,15,15,17,16,14,15,15,17,16,16,17,17,18,18,
+ 16,17,16,18,17,10,11,11,14,13,11,12,12,14,14,11,
+ 13,12,15,14,14,14,14,16,15,14,15,14,16,15,11,12,
+ 12,14,13,12,13,13,15,14,13,14,13,15,14,14,15,15,
+ 16,16,14,15,15,17,15,11,12,12,14,14,13,13,13,15,
+ 15,12,13,13,15,14,15,15,15,17,17,14,15,15,17,15,
+ 13,14,14,16,15,14,15,15,16,16,15,15,15,17,16,16,
+ 16,16,16,17,16,17,16,18,17,14,14,14,16,16,15,15,
+ 15,16,16,14,15,14,17,16,16,17,17,17,18,16,17,16,
+ 18,16, 7, 8, 8,11,11, 8, 9, 9,11,12, 8, 9, 9,12,
+ 11,10,11,11,13,14,10,11,11,14,13, 8, 9, 9,11,12,
+ 9,10,11,12,13, 9,11,10,13,12,11,12,12,13,14,11,
+ 12,12,14,14, 8, 9, 9,11,11, 9,10,10,12,12, 9,10,
+ 10,13,12,11,12,12,14,14,11,12,11,14,13,10,11,12,
+ 13,13,11,12,12,13,14,12,13,12,14,14,13,13,14,14,
+ 16,13,14,14,16,15,10,11,11,13,13,11,12,12,14,14,
+ 11,12,12,14,13,13,14,14,15,16,13,14,13,16,14, 8,
+ 9, 9,11,11, 9,10,11,12,13, 9,10,10,12,12,11,12,
+ 13,13,14,11,12,12,14,14, 9,10,10,12,12,10,10,11,
+ 12,13,11,12,11,13,13,12,12,13,13,15,12,13,13,15,
+ 15, 9,10,10,12,12,10,11,12,13,14,10,11,10,13,12,
+ 12,13,13,14,15,12,13,12,15,13,12,12,12,14,14,12,
+ 12,13,14,15,13,13,13,15,15,14,14,15,13,16,14,15,
+ 15,16,16,11,12,12,14,14,12,13,13,14,15,12,13,12,
+ 14,14,14,14,15,16,16,13,14,13,16,14, 8, 9, 9,11,
+ 11, 9,10,10,12,12, 9,10,10,12,12,11,12,12,14,14,
+ 11,12,11,14,14, 9,10,10,12,12,10,11,11,13,13,10,
+ 11,11,13,13,12,13,13,14,15,12,13,13,15,14, 9,10,
+ 9,12,11,10,11,10,13,12,10,11,10,13,12,12,13,12,
+ 15,14,12,13,12,15,14,11,12,12,14,14,12,13,13,14,
+ 15,12,13,13,15,15,14,14,15,15,17,14,15,15,16,16,
+ 11,12,11,14,13,12,13,12,15,14,12,13,12,15,13,14,
+ 15,14,16,15,13,15,14,17,14,10,11,11,13,14,11,12,
+ 13,13,15,11,12,12,14,14,14,14,15,15,17,13,14,14,
+ 15,16,11,12,12,14,14,12,12,13,14,15,13,13,13,15,
+ 15,14,15,15,15,17,15,15,15,16,16,11,12,12,13,14,
+ 13,13,14,14,15,12,13,13,14,15,14,15,15,16,17,14,
+ 15,15,16,16,14,14,14,16,16,14,14,15,15,17,15,15,
+ 15,17,16,16,16,17,16,18,16,17,17,18,17,13,14,14,
+ 15,16,14,15,15,16,17,14,15,15,16,16,16,17,17,17,
+ 18,16,16,16,17,16,10,11,11,14,13,11,12,12,14,14,
+ 11,12,12,15,13,13,14,14,16,15,13,14,14,16,15,11,
+ 12,12,14,14,12,13,13,15,15,12,13,13,15,15,14,15,
+ 15,16,17,14,15,15,17,16,11,12,11,14,12,12,13,13,
+ 15,13,12,13,12,15,13,14,15,15,16,15,14,15,14,17,
+ 14,13,14,14,16,16,14,15,15,16,17,14,15,15,16,17,
+ 16,16,17,17,18,16,17,17,18,18,13,14,14,16,13,14,
+ 15,15,17,14,14,15,14,17,14,16,17,16,17,16,16,17,
+ 16,18,15, 8,11,11,13,13,10,12,12,14,14,11,12,12,
+ 14,14,13,13,14,15,16,13,14,14,16,15,10,11,11,14,
+ 14,11,12,12,14,15,11,12,12,15,14,13,14,14,15,16,
+ 13,14,14,16,16,11,12,12,14,14,12,13,13,15,15,12,
+ 13,12,15,14,14,14,15,16,16,14,15,14,16,16,12,13,
+ 13,15,15,12,13,14,15,16,13,14,14,16,16,14,15,15,
+ 16,17,15,15,16,17,17,13,14,14,16,15,14,15,15,16,
+ 16,14,15,14,16,16,16,16,16,17,17,15,16,16,18,16,
+ 10,11,11,13,14,11,12,12,14,15,11,12,12,15,14,13,
+ 14,14,16,16,13,14,14,16,16,11,11,12,14,14,12,12,
+ 13,14,15,12,13,13,15,15,14,14,15,15,17,14,14,15,
+ 16,16,11,12,12,15,14,12,13,13,15,15,12,13,13,15,
+ 15,14,15,15,17,17,14,15,15,17,16,13,12,14,14,16,
+ 13,13,15,14,17,14,13,15,15,17,15,14,16,15,18,16,
+ 15,16,16,18,13,14,14,16,16,14,15,15,17,17,14,15,
+ 15,17,16,16,17,17,18,18,16,17,16,18,17,10,11,11,
+ 14,13,11,12,12,14,14,11,13,12,15,14,13,14,14,15,
+ 16,13,14,14,16,16,11,12,12,14,14,12,13,13,14,15,
+ 12,13,13,15,15,14,14,15,15,16,14,15,15,17,16,11,
+ 12,12,14,14,13,13,13,15,15,12,13,13,15,14,14,15,
+ 15,16,17,14,15,14,17,15,13,14,13,16,15,14,14,14,
+ 15,16,14,15,14,16,16,15,15,16,16,17,16,16,16,18,
+ 17,14,14,14,16,16,15,15,15,17,16,14,15,14,17,16,
+ 16,16,17,17,18,16,17,16,18,16,11,13,13,15,15,12,
+ 13,14,15,16,12,14,14,15,15,14,15,15,16,17,14,15,
+ 15,17,17,12,13,14,14,16,13,14,14,14,16,14,14,14,
+ 15,16,15,15,16,15,18,15,16,16,17,17,13,14,14,16,
+ 16,14,14,15,16,16,14,15,14,16,16,15,16,16,17,18,
+ 15,16,16,18,17,14,14,16,13,17,15,15,16,14,18,15,
+ 15,16,14,18,16,16,18,15,19,17,17,18,16,18,15,16,
+ 15,17,17,15,16,17,18,18,16,16,16,18,17,17,18,18,
+ 19,19,17,18,17,19,18,11,12,12,15,14,13,13,14,15,
+ 16,13,14,13,16,14,15,15,15,16,17,15,16,15,17,16,
+ 12,13,13,15,14,13,13,14,15,15,14,15,14,16,15,15,
+ 15,16,16,17,16,16,16,18,17,12,13,13,15,15,14,14,
+ 15,16,16,13,14,13,16,15,16,16,16,17,18,15,16,15,
+ 17,16,14,15,14,17,15,14,15,15,16,16,15,16,15,17,
+ 16,16,15,16,15,17,17,18,17,18,17,15,15,15,16,17,
+ 16,16,16,17,17,15,16,15,17,16,17,18,18,18,18,16,
+ 17,16,18,15, 8,11,11,13,13,11,12,12,14,14,10,12,
+ 12,14,14,13,14,14,15,16,13,14,13,16,15,11,12,12,
+ 14,14,12,12,13,14,15,12,13,13,15,15,14,14,15,15,
+ 16,14,14,14,16,16,10,11,11,14,14,11,12,12,14,15,
+ 11,12,12,15,14,13,14,14,16,16,13,14,14,16,15,13,
+ 14,14,15,16,14,14,15,16,16,14,15,15,16,16,15,16,
+ 16,16,18,16,16,16,17,17,12,13,13,15,15,13,14,14,
+ 16,16,12,14,13,16,15,15,16,15,17,17,14,16,15,17,
+ 16,10,11,11,13,14,11,12,13,14,15,11,13,12,14,14,
+ 14,14,15,16,16,13,14,14,16,16,11,12,12,14,14,12,
+ 13,13,14,15,13,14,13,15,15,14,15,15,16,17,14,15,
+ 15,17,16,11,12,12,14,14,12,13,13,15,15,12,13,12,
+ 15,14,14,15,15,16,17,14,15,15,16,16,14,14,14,16,
+ 16,14,14,15,16,16,15,15,15,16,16,16,16,17,16,18,
+ 16,17,17,18,18,13,13,14,15,16,14,14,15,16,17,13,
+ 14,14,16,16,16,16,17,17,18,15,16,15,17,16,10,11,
+ 11,14,13,11,12,12,14,14,11,12,12,15,14,13,14,14,
+ 16,16,13,14,14,16,16,11,12,12,14,14,12,13,13,15,
+ 15,12,13,13,15,15,14,15,15,16,17,14,15,15,17,16,
+ 11,12,11,14,14,12,13,13,15,15,12,13,12,15,14,14,
+ 15,14,16,16,14,15,14,17,16,14,14,14,16,16,14,15,
+ 15,16,17,14,15,15,17,17,16,16,17,17,18,16,17,17,
+ 18,18,13,14,12,16,14,14,15,13,17,15,13,15,13,17,
+ 14,16,16,15,18,16,15,17,14,18,15,11,12,12,14,15,
+ 13,13,14,14,16,13,14,13,15,14,15,15,16,16,17,15,
+ 16,15,17,16,12,13,13,15,15,13,13,14,15,16,14,15,
+ 14,16,16,15,15,16,15,18,16,16,16,18,17,12,13,13,
+ 15,15,14,14,15,15,16,13,14,13,15,15,16,16,16,16,
+ 18,15,16,15,17,16,15,15,15,17,16,15,15,16,16,17,
+ 16,16,16,18,17,16,16,17,15,18,17,18,17,19,18,14,
+ 14,15,15,17,15,15,16,16,17,14,15,15,16,16,17,17,
+ 18,17,19,16,17,15,17,15,11,13,12,15,15,12,14,14,
+ 15,15,12,14,13,16,15,15,15,15,17,17,14,15,15,17,
+ 16,12,14,14,16,16,14,14,15,16,16,14,14,14,16,16,
+ 15,16,17,17,18,15,16,16,18,17,12,14,13,16,14,13,
+ 14,14,16,15,13,15,14,16,14,15,16,16,17,17,15,16,
+ 15,18,15,15,15,16,17,17,15,16,16,17,18,16,16,16,
+ 18,18,17,17,18,18,19,17,17,18,19,19,14,15,14,17,
+ 13,15,16,15,18,14,15,16,15,18,14,17,18,17,18,16,
+ 16,18,16,19,15,
+};
+
+static const static_codebook _44p8_p2_0 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p8_p2_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p8_p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44p8_p3_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p8_p3_0[] = {
+ 2, 5, 5, 5, 7, 7, 5, 7, 7, 5, 7, 7, 7, 8, 9, 7,
+ 9, 9, 5, 7, 7, 7, 9, 9, 7, 9, 8, 5, 7, 8, 7, 9,
+ 10, 8, 9, 9, 8, 9,10, 9,10,12,10,11,11, 8,10, 9,
+ 10,11,12, 9,11,10, 5, 8, 7, 8,10, 9, 7,10, 9, 8,
+ 9,10, 9,10,11,10,12,11, 8,10, 9,10,11,11, 9,12,
+ 10, 5, 8, 8, 7, 9,10, 8,10, 9, 7, 9,10, 9,10,11,
+ 9,11,11, 8,10, 9,10,11,11,10,12,10, 7, 9,10, 9,
+ 10,12, 9,11,11, 9, 9,12,11,10,13,11,11,13,10,12,
+ 11,11,13,13,11,13,12, 7, 9, 9, 9,11,11, 9,12,11,
+ 9,11,10,10,11,12,11,13,12, 9,11,11,12,13,13,11,
+ 13,11, 5, 8, 8, 8, 9,10, 7,10, 9, 8, 9,10,10,10,
+ 12,10,11,11, 7,10, 9, 9,11,11, 9,11,10, 7, 9, 9,
+ 9,11,12, 9,11,11, 9,11,11,11,11,13,12,13,13, 9,
+ 10,11,11,12,13,10,12,11, 7,10, 9, 9,11,11, 9,12,
+ 10,10,11,12,11,12,13,12,13,13, 9,12, 9,11,13,11,
+ 10,13,10,
+};
+
+static const static_codebook _44p8_p3_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p8_p3_0,
+ 1, -533200896, 1614282752, 2, 0,
+ (long *)_vq_quantlist__44p8_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44p8_p3_1[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p8_p3_1[] = {
+ 6, 7, 7, 7, 7, 8, 7, 8, 7, 7, 7, 8, 7, 8, 8, 8,
+ 8, 8, 7, 8, 7, 7, 8, 8, 7, 8, 8, 7, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 7, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 8, 8, 9, 8, 8,
+ 8, 8, 9, 9, 8, 9, 9, 7, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 9, 8, 8, 8, 8, 8, 9, 9, 8,
+ 9, 8, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 7, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 8, 9, 9, 8,
+ 8, 8, 8, 8, 9, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 9, 9, 8, 9, 9, 8, 8, 8, 8, 9, 8,
+ 8, 9, 8,
+};
+
+static const static_codebook _44p8_p3_1 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p8_p3_1,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44p8_p3_1,
+ 0
+};
+
+static const long _vq_quantlist__44p8_p4_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p8_p4_0[] = {
+ 2, 5, 5, 4, 7, 8, 4, 8, 7, 5, 7, 8, 7, 7,10, 8,
+ 9, 9, 5, 7, 7, 8, 9, 9, 7,10, 7, 5, 7, 8, 8, 9,
+ 11, 8,10,10, 8, 9,10,10,10,12,11,12,12, 8,10,10,
+ 10,12,12,10,12,11, 5, 8, 7, 8,10,10, 8,11, 9, 8,
+ 10,10,10,11,12,10,12,12, 8,10, 9,11,12,12,10,12,
+ 10, 5, 8, 8, 7,10,10, 8,11,10, 7, 9,10, 9,10,12,
+ 10,12,12, 8,10,10,10,12,12,10,12,11, 7, 9,10, 9,
+ 11,12,10,12,11, 9, 9,12,10,10,13,12,12,13,10,12,
+ 11,12,13,13,11,13,11, 7,10, 9,10,11,12,10,13,11,
+ 9,11,11,11,11,13,12,14,13,10,11,11,12,14,14,11,
+ 14,11, 5, 8, 8, 8,10,11, 7,10,10, 8,10,10,10,11,
+ 12,10,12,12, 7,10, 9,10,12,12, 9,12,10, 7, 9,10,
+ 10,11,13,10,12,11,10,11,11,11,11,14,12,14,14, 9,
+ 11,11,12,13,14,11,13,11, 7,10, 9,10,11,12, 9,12,
+ 10,10,11,12,11,11,13,12,13,13, 9,12, 9,12,13,12,
+ 10,13,10,
+};
+
+static const static_codebook _44p8_p4_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p8_p4_0,
+ 1, -531365888, 1616117760, 2, 0,
+ (long *)_vq_quantlist__44p8_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44p8_p4_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p8_p4_1[] = {
+ 7, 9, 9,10,10, 9,10,10,10,11, 9,10,10,11,10, 9,
+ 10,10,11,11, 9,10,10,11,11, 9,10,10,11,11,10,10,
+ 10,11,11,10,10,10,11,11,10,11,11,11,11,10,11,11,
+ 11,11, 9,10,10,11,11,10,10,10,11,11, 9,10,10,11,
+ 11,10,11,11,11,11,10,11,11,11,11,10,11,11,11,11,
+ 10,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,12,10,11,11,11,11,11,11,11,11,11,10,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11, 9,10,10,
+ 11,11,10,10,11,11,11,10,10,11,11,11,10,11,11,11,
+ 12,10,11,11,12,12,10,10,11,11,11,10,11,11,11,12,
+ 11,11,11,12,12,11,11,12,12,12,11,11,12,12,12,10,
+ 11,11,11,11,11,11,11,12,12,10,11,11,12,12,11,12,
+ 11,12,12,11,12,11,12,12,11,11,11,11,12,11,11,12,
+ 12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,11,11,11,12,12,11,12,12,12,12,11,12,11,12,12,
+ 12,12,12,12,12,12,12,12,12,12, 9,10,10,11,11,10,
+ 11,10,11,11,10,11,10,11,11,10,11,11,12,12,10,11,
+ 11,12,11,10,11,11,11,11,10,11,11,11,12,11,11,11,
+ 12,12,11,11,12,12,12,11,11,11,12,12,10,11,10,11,
+ 11,11,11,11,12,12,10,11,11,12,11,11,12,11,12,12,
+ 11,12,11,12,12,11,11,11,12,12,11,11,12,12,12,11,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,11,11,
+ 11,12,11,11,12,12,12,12,11,12,11,12,12,12,12,12,
+ 12,12,12,12,12,12,12,10,11,11,11,11,11,11,11,12,
+ 12,11,11,11,12,12,11,12,12,12,12,11,12,12,12,12,
+ 11,11,11,12,12,11,11,12,12,12,11,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,11,11,11,12,12,11,12,
+ 12,12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,13,12,13,12,12,12,12,13,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,13,12,10,11,11,11,11,11,11,11,12,12,11,11,
+ 11,12,12,11,12,12,12,12,11,12,12,12,12,11,11,11,
+ 12,12,11,12,12,12,12,11,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,11,11,11,12,12,11,12,12,12,12,
+ 11,12,11,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,13,12,12,13,12,13,
+ 12, 9,10,10,11,11,10,10,11,11,11,10,11,10,11,11,
+ 10,11,11,12,12,10,11,11,12,12,10,10,11,11,11,10,
+ 11,11,11,12,10,11,11,12,12,11,11,12,12,12,11,11,
+ 11,12,12,10,11,10,11,11,11,11,11,12,12,10,11,11,
+ 12,11,11,12,11,12,12,11,12,11,12,12,11,11,11,11,
+ 12,11,11,12,12,12,11,12,12,12,12,11,12,12,12,12,
+ 11,12,12,12,12,11,11,11,12,11,11,12,12,12,12,11,
+ 12,11,12,12,12,12,12,12,12,12,12,12,12,12,10,10,
+ 11,11,11,10,11,11,12,12,10,11,11,12,12,11,11,11,
+ 12,12,11,11,12,12,12,10,11,11,11,12,11,11,12,12,
+ 12,11,11,12,12,12,11,11,12,12,12,11,12,12,12,12,
+ 11,11,11,12,12,11,12,12,12,12,11,12,11,12,12,11,
+ 12,12,12,12,11,12,12,12,12,11,11,12,12,12,11,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12, 9,10,10,11,11,
+ 10,11,11,11,12,10,11,11,12,11,11,12,11,12,12,11,
+ 12,11,12,12,10,11,11,12,11,11,11,11,12,12,11,12,
+ 11,12,12,11,12,12,12,12,11,12,12,12,12,10,11,11,
+ 12,12,11,12,11,12,12,11,12,11,12,12,12,12,12,12,
+ 12,11,12,12,12,12,11,12,11,12,12,11,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,11,
+ 12,12,12,12,12,12,12,12,12,11,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,11,11,11,12,12,11,12,12,
+ 12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,11,11,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,13,12,12,12,12,12,11,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,13,13,12,12,
+ 12,13,13,12,12,12,12,12,12,12,12,12,13,12,12,12,
+ 12,13,12,12,13,12,13,12,13,13,13,13,12,12,12,12,
+ 12,12,12,12,13,12,12,12,12,13,12,12,13,13,13,13,
+ 12,13,13,13,13,10,11,11,12,12,11,12,12,12,12,11,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,11,11,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,11,12,12,12,12,12,12,12,12,
+ 12,12,12,12,13,12,12,12,12,13,13,12,12,12,13,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,13,13,12,
+ 13,13,12,13,12,13,13,13,13,12,12,12,12,12,12,12,
+ 12,13,12,12,12,12,13,12,12,13,13,13,13,12,13,13,
+ 13,13, 9,10,10,11,11,10,10,11,11,11,10,11,10,11,
+ 11,10,11,11,12,12,10,11,11,12,12,10,11,11,11,11,
+ 10,11,11,12,12,11,11,11,12,12,11,11,12,12,12,11,
+ 11,12,12,12,10,11,10,11,11,10,11,11,12,12,10,11,
+ 11,12,11,11,12,11,12,12,11,11,11,12,12,11,11,11,
+ 11,12,11,11,12,12,12,11,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,11,11,11,12,11,11,12,12,12,12,
+ 11,12,11,12,12,12,12,12,12,12,11,12,12,12,12, 9,
+ 10,10,11,11,10,11,11,11,12,10,11,11,12,11,11,11,
+ 12,12,12,11,11,12,12,12,10,11,11,12,12,11,11,12,
+ 12,12,11,11,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,10,11,11,12,12,11,11,11,12,12,11,11,11,12,12,
+ 11,12,12,12,12,11,12,12,12,12,11,12,12,12,12,11,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,11,11,12,12,12,12,12,12,12,12,11,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,10,11,10,11,
+ 11,10,11,11,12,12,10,11,11,12,12,11,11,11,12,12,
+ 11,12,11,12,12,11,11,11,12,12,11,11,12,12,12,11,
+ 11,12,12,12,11,12,12,12,12,11,12,12,12,12,10,11,
+ 11,12,11,11,12,11,12,12,11,12,11,12,12,11,12,12,
+ 12,12,11,12,11,12,12,11,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 11,12,11,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,11,11,11,12,12,11,11,
+ 12,12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,11,12,12,12,12,12,12,12,12,13,12,12,12,12,
+ 12,12,12,12,13,13,12,12,12,13,13,11,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,13,12,
+ 12,12,12,12,12,12,12,12,12,12,12,13,12,13,12,12,
+ 12,13,13,12,13,13,12,13,12,13,13,13,13,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,13,13,13,
+ 13,12,13,12,13,12,11,11,11,12,12,11,12,12,12,12,
+ 11,12,12,12,12,12,12,12,12,12,12,12,12,12,12,11,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,13,13,12,12,12,13,13,11,12,11,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,13,12,12,12,12,13,
+ 12,12,12,12,12,12,12,12,12,13,13,12,12,12,12,13,
+ 12,13,13,13,13,12,13,13,13,13,12,12,12,12,12,12,
+ 12,12,13,12,12,12,12,13,12,12,13,13,13,13,12,13,
+ 13,13,12,10,11,11,12,12,11,11,11,12,12,11,11,11,
+ 12,12,11,12,12,12,12,11,12,12,12,12,11,11,11,12,
+ 12,11,11,12,12,12,11,12,12,12,12,11,12,12,12,12,
+ 12,12,12,12,12,11,11,11,12,12,11,12,12,12,12,11,
+ 12,11,12,12,12,12,12,12,12,12,12,12,12,12,11,12,
+ 12,12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,13,12,12,12,12,12,11,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,13,12,12,12,12,12,12,
+ 11,11,11,12,12,11,12,12,12,12,11,12,12,12,12,12,
+ 12,12,12,12,11,12,12,12,12,11,11,12,12,12,11,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,13,12,12,12,
+ 13,13,11,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,13,13,12,12,12,13,13,12,12,12,12,12,
+ 12,12,12,12,13,12,12,12,12,13,12,12,13,12,13,12,
+ 12,13,13,13,12,12,12,12,12,12,12,12,12,13,12,12,
+ 12,13,12,12,13,13,13,13,12,13,13,13,13,10,11,11,
+ 12,12,11,12,12,12,12,11,12,12,12,12,11,12,12,12,
+ 12,12,12,12,12,12,11,11,12,12,12,11,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,13,12,12,12,13,13,11,
+ 12,11,12,12,12,12,12,12,12,11,12,12,12,12,12,12,
+ 12,13,13,12,12,12,13,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,13,12,12,12,12,12,13,12,13,12,13,
+ 13,12,12,12,12,12,12,12,12,13,12,12,12,12,13,12,
+ 12,13,12,13,13,12,13,12,13,12,11,11,11,12,12,11,
+ 12,12,12,12,11,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,13,12,13,12,12,13,13,13,11,12,12,12,
+ 12,12,12,12,12,12,12,12,12,13,12,12,12,12,13,13,
+ 12,12,12,13,12,12,12,12,12,12,12,12,13,12,13,12,
+ 12,12,12,13,12,12,13,12,13,12,13,13,12,13,12,12,
+ 12,12,12,12,13,13,13,12,12,12,12,13,12,12,13,13,
+ 13,13,12,13,13,13,12,11,11,11,12,12,11,12,12,12,
+ 12,11,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 11,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,13,12,12,13,13,13,11,12,12,12,12,12,12,
+ 12,12,13,12,12,12,13,12,12,13,12,13,13,12,13,12,
+ 13,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,13,12,13,12,13,13,13,12,12,12,12,12,12,
+ 12,13,12,13,12,12,12,12,13,12,12,13,13,13,12,12,
+ 13,12,13,12,10,11,11,12,12,11,11,11,12,12,11,11,
+ 11,12,12,11,12,12,12,12,11,12,12,12,12,11,11,11,
+ 12,12,11,11,12,12,12,11,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,11,11,11,12,12,11,12,12,12,12,
+ 11,12,11,12,12,12,12,12,12,12,11,12,12,12,12,11,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,13,12,12,12,12,12,11,12,12,12,12,12,12,12,
+ 12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,10,11,11,12,12,11,11,12,12,12,11,12,12,12,12,
+ 11,12,12,12,12,12,12,12,12,12,11,11,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,13,12,12,
+ 12,13,13,11,11,11,12,12,12,12,12,12,12,11,12,12,
+ 12,12,12,12,12,13,13,12,12,12,13,13,12,12,12,12,
+ 12,12,12,12,12,13,12,12,12,12,13,12,12,13,12,13,
+ 12,12,13,13,13,12,12,12,12,12,12,12,12,12,13,12,
+ 12,12,12,12,12,12,13,13,13,12,12,12,13,12,11,11,
+ 11,12,12,11,12,12,12,12,11,12,12,12,12,12,12,12,
+ 12,12,11,12,12,12,12,11,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,13,13,12,12,12,13,13,
+ 11,12,11,12,12,12,12,12,12,12,11,12,12,12,12,12,
+ 12,12,13,13,12,12,12,13,12,12,12,12,12,12,12,12,
+ 12,12,13,12,12,12,13,13,12,13,13,13,13,12,13,13,
+ 13,13,12,12,12,12,12,12,12,12,13,12,12,12,12,13,
+ 12,12,13,12,13,13,12,13,12,13,12,11,11,11,12,12,
+ 11,12,12,12,12,11,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,11,12,12,12,12,12,12,12,12,13,12,12,
+ 12,13,13,12,12,13,12,13,12,12,13,13,13,11,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,13,
+ 13,12,12,12,13,12,12,12,12,12,12,12,12,12,12,13,
+ 12,12,12,13,13,12,12,13,12,13,12,13,13,13,13,12,
+ 12,12,12,12,12,12,13,12,13,12,12,12,12,12,12,13,
+ 13,12,12,12,13,12,12,12,11,11,11,12,12,11,12,12,
+ 12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,11,12,12,12,12,12,12,12,12,13,12,12,12,12,13,
+ 12,12,13,13,13,12,12,12,13,13,11,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,13,12,13,13,12,13,
+ 12,13,12,12,12,12,12,12,12,12,12,12,13,12,13,12,
+ 13,13,12,13,13,12,13,12,13,13,13,13,12,12,12,12,
+ 12,12,12,12,13,12,12,13,12,13,12,12,13,12,13,12,
+ 12,13,12,13,12,
+};
+
+static const static_codebook _44p8_p4_1 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p8_p4_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p8_p4_1,
+ 0
+};
+
+static const long _vq_quantlist__44p8_p5_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p8_p5_0[] = {
+ 2, 6, 6, 9, 9, 5, 7, 8,10,11, 5, 8, 7,11,10, 8,
+ 10,11,12,13, 8,11,10,13,12, 6, 7, 8,10,11, 7, 8,
+ 10,10,12, 8, 9, 9,12,12,10,10,12,12,14,10,12,12,
+ 14,13, 6, 8, 7,11,10, 8, 9, 9,12,12, 7,10, 8,12,
+ 11,10,12,12,13,14,10,12,10,14,12, 9,10,11,11,13,
+ 10,10,11,11,13,11,12,12,13,14,12,12,13,11,15,13,
+ 14,14,15,14, 9,11,10,13,11,11,12,12,13,13,10,11,
+ 10,13,11,13,14,14,15,15,12,13,12,15,11, 6, 8, 9,
+ 11,12, 8, 9,11,12,13, 8,10,10,13,13,11,12,13,14,
+ 15,11,12,13,14,14, 9, 9,10,12,13,10,10,12,12,14,
+ 10,11,11,13,14,12,12,14,14,15,13,13,14,15,15, 9,
+ 10,10,13,13,10,11,11,13,14,10,11,10,14,13,13,13,
+ 14,15,15,12,14,13,15,14,12,12,13,13,14,12,13,14,
+ 13,15,13,14,14,15,15,14,14,15,14,16,15,15,15,16,
+ 16,12,13,13,14,14,13,14,14,15,15,12,14,13,15,14,
+ 14,15,15,16,16,14,15,14,16,14, 6, 9, 8,12,11, 8,
+ 10,10,13,13, 8,11, 9,13,12,11,12,12,14,14,11,13,
+ 12,15,14, 9,10,10,13,13,10,10,11,13,14,10,12,11,
+ 14,13,12,13,14,14,15,13,13,13,15,14, 9,10, 9,13,
+ 12,10,11,11,14,13,10,12,10,14,12,13,14,13,15,15,
+ 12,14,12,15,14,12,13,13,14,14,13,13,13,14,15,13,
+ 14,14,15,15,14,14,15,14,16,14,15,15,16,16,12,13,
+ 12,14,13,13,14,14,15,15,12,14,13,15,13,15,15,15,
+ 16,16,14,15,14,16,14,11,12,12,13,14,12,13,14,14,
+ 16,12,13,13,15,15,14,14,16,15,17,14,15,15,16,16,
+ 12,13,14,14,15,13,13,15,15,16,14,14,14,15,16,15,
+ 15,16,16,17,15,15,16,16,17,13,13,13,15,15,14,14,
+ 15,15,16,13,14,14,15,16,15,15,16,16,17,15,16,15,
+ 17,16,14,15,15,16,16,15,15,16,16,17,15,16,16,17,
+ 17,16,16,17,16,18,16,17,17,17,17,15,15,15,16,16,
+ 15,16,16,17,17,15,16,16,17,16,16,17,17,18,18,16,
+ 17,16,17,16,11,12,12,15,13,13,13,13,15,15,12,14,
+ 13,16,14,14,15,15,16,16,14,15,14,17,15,13,13,13,
+ 15,14,13,14,14,16,15,14,14,14,16,15,15,15,16,16,
+ 17,15,16,15,17,16,12,14,13,15,14,14,14,14,16,15,
+ 13,14,13,16,15,15,16,16,17,16,15,16,15,17,16,15,
+ 15,15,16,16,15,15,16,16,17,15,16,16,17,17,16,16,
+ 17,17,17,17,17,17,18,17,14,15,15,16,16,15,16,16,
+ 17,16,15,16,15,17,16,17,17,17,18,17,16,17,16,18,
+ 16, 6, 9, 9,12,12, 8,10,10,12,13, 8,10,10,13,12,
+ 10,12,12,14,15,11,13,12,15,14, 8, 9,10,12,13, 9,
+ 10,11,13,14,10,11,11,14,13,12,12,13,14,15,12,13,
+ 13,15,15, 8,10,10,13,13,10,11,11,13,14,10,12,10,
+ 14,13,12,13,13,15,15,12,14,13,15,14,11,12,12,13,
+ 14,12,12,13,13,15,12,13,13,15,15,14,13,15,14,16,
+ 14,15,15,16,16,12,13,13,14,14,13,13,14,15,14,12,
+ 14,13,15,14,14,15,15,16,15,14,15,14,16,14, 7, 9,
+ 10,12,12, 9,10,11,13,14, 9,11,10,13,13,11,12,13,
+ 14,15,12,13,13,15,14, 9,10,11,12,13,10,10,12,13,
+ 14,11,11,12,14,14,12,12,14,14,15,13,13,14,15,15,
+ 9,11,11,13,13,11,12,12,14,14,10,12,10,14,13,13,
+ 14,14,15,15,13,14,13,16,14,12,12,13,14,15,13,13,
+ 14,14,16,13,14,14,15,15,14,14,15,14,17,14,15,15,
+ 16,16,12,13,13,15,14,13,14,14,15,15,13,14,13,16,
+ 14,15,15,15,16,16,14,15,14,16,14, 7,10, 9,13,12,
+ 10,11,12,12,14,10,12,11,14,12,12,13,13,14,15,12,
+ 14,13,15,14, 9,11,10,13,13,10,11,12,13,14,12,13,
+ 12,15,13,13,13,14,13,15,13,14,14,16,15,10,11,11,
+ 13,13,12,12,13,14,14,11,12,11,14,13,14,14,14,15,
+ 16,13,14,13,16,13,12,13,13,14,14,12,13,13,14,15,
+ 14,14,14,15,15,14,13,15,13,16,15,15,15,17,16,13,
+ 13,13,14,14,14,14,14,15,15,12,13,13,15,14,15,16,
+ 16,16,16,14,15,14,16,13,11,12,13,14,15,12,13,14,
+ 15,16,13,14,14,15,15,14,14,15,15,17,14,15,15,16,
+ 16,13,13,14,14,15,13,13,15,14,16,14,14,15,15,16,
+ 15,14,16,15,17,15,16,16,16,17,13,14,14,15,15,14,
+ 14,15,16,16,13,15,14,16,16,15,16,16,17,17,15,16,
+ 15,17,16,14,15,15,15,17,15,15,16,15,17,15,16,16,
+ 16,17,16,16,17,16,18,17,17,17,17,18,15,15,15,17,
+ 16,15,16,16,17,17,15,16,16,17,16,16,17,17,18,18,
+ 16,17,16,18,17,11,13,12,15,14,13,13,14,15,15,13,
+ 14,13,16,14,15,15,15,16,16,15,16,15,17,16,13,14,
+ 13,15,14,13,13,14,15,15,14,15,14,16,15,15,15,16,
+ 16,16,15,16,15,18,16,13,14,14,15,15,14,15,15,15,
+ 16,13,15,13,16,15,15,16,16,17,17,15,16,15,17,16,
+ 15,15,15,16,16,15,15,15,16,17,16,16,16,17,16,16,
+ 16,17,16,17,17,17,17,18,17,15,15,15,16,16,16,16,
+ 16,17,17,15,16,15,17,16,17,17,17,18,18,16,17,16,
+ 17,15, 6, 9, 9,12,12, 8,10,10,12,13, 8,10,10,13,
+ 12,11,12,13,14,15,10,12,12,14,14, 9,10,10,13,13,
+ 10,10,12,13,14,10,11,11,14,13,12,13,14,14,15,12,
+ 13,13,15,15, 8,10, 9,13,12,10,11,11,13,14, 9,11,
+ 10,14,13,12,13,13,15,15,12,13,12,15,14,12,13,13,
+ 14,14,12,13,13,14,15,13,14,14,14,15,14,14,15,14,
+ 16,14,15,15,16,16,11,12,12,14,13,13,13,13,15,15,
+ 12,13,12,15,13,14,15,15,16,16,14,15,14,16,14, 7,
+ 9,10,12,13,10,10,12,12,14,10,12,11,14,13,12,13,
+ 14,14,15,12,13,13,15,14,10,11,11,13,13,11,11,12,
+ 13,14,12,13,12,14,14,13,13,14,13,16,14,14,14,15,
+ 15, 9,10,11,13,14,12,12,13,13,15,10,12,10,14,13,
+ 13,14,14,15,16,13,14,13,15,13,13,14,13,14,15,12,
+ 13,13,14,15,14,14,14,15,15,14,13,15,13,16,15,16,
+ 16,16,16,12,13,13,14,14,14,14,14,15,15,12,13,13,
+ 15,14,15,15,16,16,16,14,15,13,16,13, 7,10, 9,12,
+ 12, 9,10,11,13,13, 9,11,10,14,13,12,13,13,14,15,
+ 11,13,12,15,14, 9,11,11,13,13,10,10,12,13,14,11,
+ 12,12,14,14,13,13,14,14,16,13,14,14,16,15, 9,11,
+ 10,13,12,11,12,11,14,14,10,12,10,14,13,13,14,13,
+ 15,15,12,14,12,16,14,12,13,13,14,15,13,13,14,14,
+ 16,13,14,14,15,15,14,14,15,14,16,15,15,15,16,16,
+ 12,13,12,15,14,13,14,14,15,15,12,14,13,16,14,14,
+ 15,15,16,16,14,15,14,17,14,11,12,13,14,15,13,13,
+ 14,14,16,13,14,13,15,15,15,15,16,16,17,15,15,15,
+ 16,16,13,14,13,15,15,13,13,15,15,16,14,15,15,16,
+ 16,15,15,16,15,17,16,16,16,17,17,13,13,14,14,15,
+ 14,14,15,15,16,13,14,13,15,15,15,16,16,16,17,15,
+ 16,15,16,16,15,15,15,16,16,15,15,16,16,17,16,16,
+ 16,17,17,16,16,17,16,18,17,17,17,18,18,15,15,15,
+ 16,16,16,16,16,17,17,15,15,15,16,16,17,17,17,17,
+ 18,16,16,16,17,15,11,13,12,15,14,13,13,14,15,15,
+ 12,14,13,16,14,14,15,15,16,16,14,15,14,16,15,13,
+ 14,14,15,15,13,14,14,16,16,14,15,14,16,16,15,15,
+ 16,17,17,15,16,16,17,17,13,14,13,15,14,14,14,14,
+ 16,15,13,15,13,16,14,15,16,15,17,16,15,16,14,17,
+ 15,14,16,15,16,17,15,16,16,16,17,15,16,16,17,17,
+ 16,16,17,17,18,16,17,17,18,17,14,15,15,17,15,15,
+ 16,16,17,16,15,16,15,17,15,16,17,17,18,17,16,17,
+ 16,18,15,10,12,12,14,14,12,13,13,15,15,12,13,13,
+ 15,15,13,14,14,15,16,14,15,14,16,16,12,13,13,15,
+ 15,12,13,14,15,15,13,14,14,15,15,14,14,15,16,17,
+ 14,15,15,17,16,12,13,13,15,15,13,14,14,15,16,13,
+ 14,14,16,15,14,15,15,16,17,14,15,15,17,16,13,14,
+ 14,15,16,14,14,15,15,16,14,15,15,16,16,15,15,16,
+ 16,17,15,16,16,17,17,14,15,15,16,16,15,15,15,16,
+ 16,15,15,15,16,16,16,17,16,17,17,16,16,16,18,16,
+ 11,12,12,14,14,12,13,14,15,15,12,13,13,15,15,13,
+ 14,15,16,16,14,15,15,16,16,12,13,13,15,15,13,13,
+ 14,15,16,13,14,14,15,16,14,14,15,16,17,15,15,15,
+ 16,17,12,13,13,15,15,13,14,14,15,16,13,14,14,16,
+ 15,15,15,15,16,17,15,16,15,17,16,14,14,15,15,16,
+ 14,14,15,15,17,15,15,16,16,17,15,15,16,15,18,16,
+ 16,16,17,17,14,15,15,16,16,15,16,16,17,17,15,15,
+ 15,17,16,16,17,16,17,17,16,16,16,18,16,11,12,12,
+ 14,14,13,13,14,15,15,13,14,13,15,15,14,15,15,16,
+ 16,14,15,15,16,16,12,13,13,15,15,13,13,14,15,15,
+ 14,14,14,16,15,15,15,15,15,16,15,16,15,17,16,12,
+ 13,13,15,15,14,14,15,15,16,13,14,13,16,15,15,15,
+ 16,16,17,15,16,15,17,15,14,15,14,16,16,14,15,15,
+ 16,16,15,16,15,17,16,15,15,16,15,17,16,17,16,17,
+ 17,14,15,15,16,16,15,16,16,16,17,14,15,15,16,16,
+ 16,17,17,17,18,16,16,16,17,16,12,13,13,15,15,13,
+ 13,14,15,16,13,14,14,16,15,14,15,15,16,17,14,15,
+ 15,17,16,13,14,14,15,16,14,14,15,15,17,14,15,15,
+ 16,16,15,14,16,15,17,15,16,16,17,17,13,14,14,16,
+ 16,14,15,15,16,16,14,15,14,16,16,15,16,16,17,17,
+ 15,16,15,17,16,15,15,16,15,17,15,15,16,15,17,15,
+ 16,16,16,17,16,15,17,15,18,17,17,17,17,17,15,15,
+ 15,17,17,16,16,16,17,17,15,16,15,17,17,16,17,17,
+ 18,18,16,17,15,18,15,11,12,12,15,15,13,13,15,14,
+ 16,13,14,13,16,14,15,15,16,16,17,15,16,15,17,15,
+ 12,14,13,16,14,13,13,14,14,16,14,15,14,16,15,15,
+ 15,16,15,17,16,16,16,17,16,12,13,14,15,16,15,15,
+ 15,15,16,13,15,13,16,14,16,16,16,17,17,15,16,15,
+ 17,15,15,16,15,16,15,14,14,15,16,16,16,16,16,17,
+ 16,15,15,16,15,17,17,17,17,18,17,15,15,15,16,16,
+ 16,16,16,16,17,14,15,15,17,16,17,17,17,17,18,15,
+ 16,15,18,14,10,12,12,14,14,12,13,13,15,15,12,13,
+ 13,15,15,14,14,15,15,16,13,15,14,16,16,12,13,13,
+ 15,15,13,14,14,15,16,13,14,14,15,15,14,15,15,16,
+ 17,14,15,15,17,16,12,13,13,15,15,13,14,14,15,15,
+ 12,14,13,15,15,14,15,15,16,17,14,15,14,17,15,14,
+ 15,15,16,16,14,15,15,16,17,15,15,15,17,16,16,16,
+ 16,16,17,16,16,16,17,17,13,14,14,16,15,14,15,15,
+ 16,16,14,15,14,16,16,15,16,16,17,17,15,16,15,17,
+ 16,11,12,12,14,15,13,13,14,14,15,13,14,13,15,15,
+ 14,15,15,16,16,14,15,15,16,16,12,14,13,15,15,13,
+ 13,14,15,16,14,15,14,16,15,15,15,16,15,17,15,16,
+ 16,17,16,12,13,13,15,15,14,14,15,15,16,13,14,13,
+ 16,15,15,15,16,16,17,15,15,15,16,16,14,15,15,16,
+ 16,14,15,15,16,16,15,16,16,17,17,16,16,16,16,17,
+ 16,17,17,18,17,14,14,15,15,16,15,15,16,16,17,14,
+ 15,15,16,16,16,16,16,17,17,15,16,15,17,15,11,12,
+ 12,14,14,12,13,14,15,15,12,13,13,15,15,14,15,15,
+ 16,16,13,15,14,16,16,12,13,13,15,15,13,14,14,15,
+ 16,13,14,14,16,16,15,15,15,16,17,15,15,15,17,16,
+ 12,13,13,15,15,13,14,14,16,15,13,14,13,16,15,15,
+ 16,15,17,17,14,15,14,17,16,14,15,15,16,16,15,15,
+ 16,16,17,15,16,16,17,17,16,16,16,16,18,16,17,16,
+ 18,17,14,15,14,16,15,15,15,15,17,16,14,15,14,17,
+ 15,16,17,16,17,17,15,16,15,17,15,11,12,12,15,15,
+ 13,13,15,14,16,13,15,13,16,14,15,15,16,15,17,15,
+ 16,15,17,16,12,14,13,15,15,13,13,15,15,16,15,15,
+ 15,16,15,15,15,16,15,17,16,16,16,17,16,12,13,14,
+ 15,16,14,14,15,15,16,13,14,13,16,14,16,16,16,16,
+ 17,15,16,15,17,15,15,16,15,16,16,14,15,15,16,16,
+ 16,16,16,17,16,15,15,16,15,17,17,17,17,18,17,15,
+ 15,15,15,16,16,16,16,16,17,14,15,14,16,15,17,17,
+ 17,17,18,15,16,15,17,15,12,13,13,15,15,13,14,14,
+ 15,16,13,14,14,16,15,14,15,15,16,17,14,15,15,17,
+ 16,13,14,14,16,15,13,14,15,16,16,14,15,15,16,16,
+ 15,15,16,16,17,15,16,16,17,17,13,14,13,16,15,14,
+ 15,15,16,16,13,15,14,16,15,15,16,16,17,17,15,16,
+ 14,17,15,15,15,16,17,17,15,15,16,16,17,16,16,16,
+ 17,17,16,15,17,16,18,17,17,17,18,18,15,15,15,17,
+ 14,16,16,16,17,16,15,16,15,17,15,16,17,17,18,17,
+ 16,17,15,18,15,
+};
+
+static const static_codebook _44p8_p5_0 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p8_p5_0,
+ 1, -528744448, 1616642048, 3, 0,
+ (long *)_vq_quantlist__44p8_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44p8_p5_1[] = {
+ 3,
+ 2,
+ 4,
+ 1,
+ 5,
+ 0,
+ 6,
+};
+
+static const long _vq_lengthlist__44p8_p5_1[] = {
+ 2, 3, 3, 3, 3, 3, 3,
+};
+
+static const static_codebook _44p8_p5_1 = {
+ 1, 7,
+ (long *)_vq_lengthlist__44p8_p5_1,
+ 1, -533200896, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p8_p5_1,
+ 0
+};
+
+static const long _vq_quantlist__44p8_p6_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p8_p6_0[] = {
+ 2, 6, 6, 5, 7, 7, 5, 7, 7, 5, 7, 7, 7, 7, 9, 7,
+ 9, 9, 6, 7, 7, 8, 9, 9, 7, 9, 7, 6, 8, 8, 8, 9,
+ 10, 8, 9, 9, 8, 9,10, 9, 9,10,10,10,10, 8, 9, 9,
+ 10,10,11, 9,10,10, 6, 8, 8, 8, 9, 9, 8,10, 9, 8,
+ 9, 9, 9,10,10,10,11,10, 8,10, 9,10,11,10, 9,11,
+ 9, 6, 8, 8, 7, 9, 9, 7, 9, 9, 7, 9, 9, 8, 9,10,
+ 9,10,10, 8, 9, 9, 9,10,10, 9,10, 9, 7, 9, 9, 9,
+ 9,10, 9,10,10, 9, 9,10,10, 9,11,10,11,11, 9,10,
+ 10,10,11,11,10,11,10, 6, 9, 8, 9, 9,10, 9,10, 9,
+ 8,10,10, 9, 9,10,10,11,11, 9,10,10,10,11,11, 9,
+ 11, 9, 6, 8, 8, 7, 9, 9, 7, 9, 9, 8, 9, 9, 9, 9,
+ 10, 9,10,10, 7, 9, 9, 9,10,10, 8,10, 9, 6, 8, 9,
+ 9, 9,10, 9,10, 9, 9,10,10, 9, 9,11,10,11,11, 8,
+ 9,10,10,11,11, 9,10, 9, 7, 9, 9, 9,10,10, 9,10,
+ 9, 9,10,10,10,10,11,10,11,11, 9,10, 9,10,11,11,
+ 10,11, 9,
+};
+
+static const static_codebook _44p8_p6_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p8_p6_0,
+ 1, -527106048, 1620377600, 2, 0,
+ (long *)_vq_quantlist__44p8_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44p8_p6_1[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p8_p6_1[] = {
+ 4, 7, 7, 7, 7, 8, 7, 8, 7, 7, 7, 8, 7, 8, 8, 8,
+ 8, 8, 7, 8, 7, 8, 8, 8, 7, 8, 8, 7, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 8, 8, 9, 8, 8, 8,
+ 8, 9, 8, 8, 8, 8, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 8, 8, 9,
+ 8, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9,
+ 8, 8, 9, 8, 8, 8, 8, 9, 9, 8, 9, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 8, 9, 9, 8, 8,
+ 8, 8, 9, 9, 8, 9, 9, 7, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 9, 8, 9, 8, 8, 8, 8, 8, 9, 9, 8,
+ 9, 8, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 9, 8, 9, 9, 8, 8, 8, 8, 9, 8, 8, 9, 8, 7, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 8, 9, 9, 8,
+ 8, 8, 8, 9, 9, 8, 9, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 9, 9, 8, 9, 9, 8, 8, 8, 8, 9, 9,
+ 8, 9, 8,
+};
+
+static const static_codebook _44p8_p6_1 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p8_p6_1,
+ 1, -530841600, 1616642048, 2, 0,
+ (long *)_vq_quantlist__44p8_p6_1,
+ 0
+};
+
+static const long _vq_quantlist__44p8_p7_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p8_p7_0[] = {
+ 1, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9,
+};
+
+static const static_codebook _44p8_p7_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p8_p7_0,
+ 1, -512202240, 1635281408, 2, 0,
+ (long *)_vq_quantlist__44p8_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44p8_p7_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p8_p7_1[] = {
+ 1, 7, 7,12,12, 5,11,12,12,12, 5,12,11,12,12,12,
+ 12,12,12,12,12,13,13,13,13, 7,11,11,13,13,13,12,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13, 7,13,10,13,13,13,13,13,13,13,12,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13, 7,13,12,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,12,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13, 8,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,12,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,12,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13, 8,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,12,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,10,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13, 8,13,12,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,11,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,11,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,
+};
+
+static const static_codebook _44p8_p7_1 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p8_p7_1,
+ 1, -514619392, 1630767104, 3, 0,
+ (long *)_vq_quantlist__44p8_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44p8_p7_2[] = {
+ 12,
+ 11,
+ 13,
+ 10,
+ 14,
+ 9,
+ 15,
+ 8,
+ 16,
+ 7,
+ 17,
+ 6,
+ 18,
+ 5,
+ 19,
+ 4,
+ 20,
+ 3,
+ 21,
+ 2,
+ 22,
+ 1,
+ 23,
+ 0,
+ 24,
+};
+
+static const long _vq_lengthlist__44p8_p7_2[] = {
+ 1, 3, 2, 4, 5, 7, 7, 8, 8, 9, 9,10,10,11,11,12,
+ 12,13,13,14,14,15,15,15,15,
+};
+
+static const static_codebook _44p8_p7_2 = {
+ 1, 25,
+ (long *)_vq_lengthlist__44p8_p7_2,
+ 1, -518864896, 1620639744, 5, 0,
+ (long *)_vq_quantlist__44p8_p7_2,
+ 0
+};
+
+static const long _vq_quantlist__44p8_p7_3[] = {
+ 12,
+ 11,
+ 13,
+ 10,
+ 14,
+ 9,
+ 15,
+ 8,
+ 16,
+ 7,
+ 17,
+ 6,
+ 18,
+ 5,
+ 19,
+ 4,
+ 20,
+ 3,
+ 21,
+ 2,
+ 22,
+ 1,
+ 23,
+ 0,
+ 24,
+};
+
+static const long _vq_lengthlist__44p8_p7_3[] = {
+ 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5,
+};
+
+static const static_codebook _44p8_p7_3 = {
+ 1, 25,
+ (long *)_vq_lengthlist__44p8_p7_3,
+ 1, -529006592, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44p8_p7_3,
+ 0
+};
+
+static const long _huff_lengthlist__44p8_short[] = {
+ 3, 9,15,17,20,21,22,23, 5, 5, 7, 9,11,13,17,20,
+ 9, 5, 5, 6, 8,10,15,18,11, 7, 5, 4, 6, 9,13,17,
+ 14, 9, 7, 5, 6, 7,10,14,17,10, 8, 6, 6, 4, 5, 8,
+ 20,14,13,10, 8, 4, 3, 4,23,17,16,14,12, 6, 4, 4,
+};
+
+static const static_codebook _huff_book__44p8_short = {
+ 2, 64,
+ (long *)_huff_lengthlist__44p8_short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44p9_l0_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44p9_l0_0[] = {
+ 2, 5, 5, 7, 6, 8, 8, 9, 9,10,10,11,11, 4, 5, 5,
+ 6, 7, 8, 8, 9, 9,10,10,11,10, 4, 5, 5, 7, 6, 8,
+ 8, 9, 9,10,10,10,10, 6, 6, 7, 6, 7, 8, 8, 9, 9,
+ 10, 9,11, 9, 6, 6, 6, 7, 6, 8, 8, 9, 9, 9,10, 9,
+ 11, 7, 7, 8, 8, 8, 8, 9, 9, 9,10, 9,11, 9, 7, 8,
+ 8, 8, 8, 9, 8, 9, 9, 9,10, 9,11, 8, 9, 9, 9, 9,
+ 9, 9,10,10,11,10,12,10, 8, 9, 9, 9, 9, 9, 9,10,
+ 9,10,11,11,12, 9,10,10,10,10,10,10,10,11,11,11,
+ 11,12, 9,10,10,10,10,11,10,11,10,11,11,12,11,11,
+ 11,11,11,11,11,11,11,12,11,12,11,12,11,11,11,11,
+ 11,11,11,12,11,12,11,12,11,
+};
+
+static const static_codebook _44p9_l0_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44p9_l0_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44p9_l0_0,
+ 0
+};
+
+static const long _vq_quantlist__44p9_l0_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p9_l0_1[] = {
+ 4, 4, 4, 5, 5, 4, 4, 5, 5, 5, 4, 5, 4, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5,
+};
+
+static const static_codebook _44p9_l0_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44p9_l0_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p9_l0_1,
+ 0
+};
+
+static const long _vq_quantlist__44p9_l1_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p9_l1_0[] = {
+ 1, 2, 3, 5, 9, 9, 4, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9,10,10,10,10,10,10,10,10,
+};
+
+static const static_codebook _44p9_l1_0 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44p9_l1_0,
+ 1, -514619392, 1630767104, 3, 0,
+ (long *)_vq_quantlist__44p9_l1_0,
+ 0
+};
+
+static const long _huff_lengthlist__44p9_lfe[] = {
+ 1, 1,
+};
+
+static const static_codebook _huff_book__44p9_lfe = {
+ 1, 2,
+ (long *)_huff_lengthlist__44p9_lfe,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44p9_long[] = {
+ 3, 3, 3, 3, 3, 3, 3, 3,
+};
+
+static const static_codebook _huff_book__44p9_long = {
+ 1, 8,
+ (long *)_huff_lengthlist__44p9_long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44p9_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p9_p1_0[] = {
+ 1, 5, 5, 4, 8, 8, 4, 8, 8, 5, 7, 8, 8, 9,10, 8,
+ 10,10, 5, 8, 7, 8,10,10, 8,10, 9, 7, 9, 9, 9,11,
+ 11, 9,11,11, 9,11,11,11,12,13,11,13,13, 9,11,11,
+ 11,13,13,11,13,13, 7, 9, 9, 9,11,11, 9,11,11, 9,
+ 11,11,11,13,13,11,13,13, 9,11,11,11,13,13,11,13,
+ 12, 5, 9, 9, 9,11,11, 9,11,11, 9,11,11,11,12,13,
+ 11,13,13, 9,11,11,11,13,13,11,13,13, 9,11,12,11,
+ 13,13,12,13,13,11,12,13,13,14,15,13,14,14,12,13,
+ 13,13,15,15,13,15,14, 8,10,10,11,13,13,12,14,13,
+ 11,12,12,13,14,15,13,15,15,11,12,12,13,15,15,13,
+ 15,14, 5, 9, 9, 9,11,11, 9,11,11, 9,11,11,11,13,
+ 13,11,13,13, 9,11,10,11,13,13,11,13,12, 8,10,10,
+ 11,13,13,12,13,13,11,12,12,13,14,15,14,15,15,10,
+ 12,12,13,14,15,13,15,14, 9,12,11,12,13,13,11,13,
+ 13,12,13,13,13,15,15,13,14,15,11,13,12,13,15,14,
+ 13,15,14,
+};
+
+static const static_codebook _44p9_p1_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p9_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44p9_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44p9_p2_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p9_p2_0[] = {
+ 4, 6, 6, 8, 8, 5, 7, 7, 9, 9, 5, 7, 7, 9, 9, 6,
+ 8, 8,11,11, 6, 8, 8,11,11, 6, 7, 7, 9, 9, 7, 8,
+ 9,10,11, 7, 9, 9,11,10, 8, 9,10,12,12, 8,10,10,
+ 12,12, 6, 7, 7, 9, 9, 7, 9, 9,10,10, 7, 9, 8,11,
+ 10, 8,10,10,12,12, 8,10, 9,12,12, 8, 9, 9,11,11,
+ 9,10,10,12,12, 9,11,11,12,13,11,12,12,13,14,11,
+ 12,12,14,14, 8, 9, 9,11,11, 9,11,10,13,12, 9,10,
+ 10,13,12,11,12,12,14,14,11,12,12,14,13, 7, 8, 9,
+ 10,10, 8,10,10,11,11, 8,10,10,11,11,10,11,11,13,
+ 13,10,11,11,13,13, 8, 9,10,10,11,10,11,11,12,13,
+ 10,11,11,12,12,11,11,12,13,14,11,12,12,14,14, 8,
+ 10,10,11,11,10,11,11,12,13,10,11,11,12,12,11,12,
+ 12,14,14,11,12,12,14,14,10,11,11,12,13,11,12,12,
+ 13,14,12,13,13,14,14,13,13,14,14,16,13,14,14,15,
+ 16,10,11,11,13,13,12,12,12,14,14,11,12,12,14,14,
+ 13,14,14,15,16,13,14,14,16,15, 7, 8, 8,10,10, 8,
+ 10,10,11,11, 8,10,10,12,11,10,11,11,13,13,10,11,
+ 11,13,13, 8,10,10,11,11,10,11,11,12,12,10,11,11,
+ 12,12,11,12,12,14,14,11,12,12,14,14, 8,10, 9,11,
+ 10,10,11,11,13,12,10,11,10,13,12,11,12,12,14,14,
+ 11,12,11,14,13,10,11,11,13,13,11,12,12,14,14,12,
+ 12,12,14,14,13,14,14,15,16,13,14,14,15,15,10,11,
+ 11,13,12,12,12,12,14,14,11,12,12,14,13,13,14,14,
+ 16,15,13,14,13,16,14,10,11,11,13,13,12,12,13,14,
+ 15,12,13,13,14,15,13,14,15,15,16,13,14,14,16,16,
+ 11,12,13,14,14,13,13,14,15,16,13,14,14,15,16,14,
+ 15,15,16,17,14,15,16,17,17,11,12,12,14,14,13,14,
+ 14,15,16,13,14,14,15,15,14,15,15,16,18,14,15,15,
+ 17,16,13,14,15,15,16,15,15,16,16,18,15,15,15,17,
+ 17,16,16,17,17,18,16,16,16,18,18,14,14,14,16,16,
+ 15,15,15,16,17,15,15,15,16,17,16,17,17,18,18,16,
+ 16,17,18,17,10,11,11,14,13,12,13,13,15,14,11,13,
+ 13,15,14,13,15,15,16,16,13,14,14,16,16,11,12,12,
+ 14,14,13,13,13,15,15,13,14,13,15,15,15,15,15,17,
+ 16,14,15,15,17,16,11,13,12,14,14,13,14,13,15,15,
+ 13,14,13,15,15,14,15,15,17,17,14,15,15,17,16,14,
+ 14,14,16,16,14,15,15,17,17,15,15,16,17,16,17,16,
+ 17,18,18,16,17,17,18,18,13,14,14,16,15,15,15,15,
+ 17,17,14,16,15,16,16,17,17,17,18,18,16,17,16,20,
+ 19, 6, 8, 8,10,10, 8,10,10,11,11, 8,10,10,12,11,
+ 10,11,11,13,13,10,11,11,13,13, 8, 9,10,11,11,10,
+ 11,11,12,12,10,11,11,13,12,11,12,12,14,14,11,12,
+ 12,14,14, 9,10,10,11,11,10,11,11,12,12,10,11,11,
+ 13,12,11,12,12,14,14,11,12,12,14,14,10,10,11,12,
+ 13,11,12,12,14,14,11,12,12,14,14,13,14,14,15,16,
+ 13,14,14,15,16,10,11,11,13,13,12,12,12,14,14,12,
+ 13,12,14,14,13,14,14,16,16,13,14,14,15,15, 9,10,
+ 10,11,12,10,11,11,12,13,10,11,11,13,12,11,12,12,
+ 14,14,11,12,12,14,14,10,10,11,12,13,11,12,12,13,
+ 14,11,12,12,13,14,12,13,14,14,15,12,13,13,15,15,
+ 10,11,11,13,13,11,12,12,13,14,11,12,12,14,13,12,
+ 13,13,15,15,12,13,13,15,15,12,11,13,12,14,13,13,
+ 14,14,15,13,13,14,14,15,14,15,15,16,17,14,15,15,
+ 16,17,12,13,12,14,14,13,14,14,15,15,13,14,14,15,
+ 15,14,15,15,16,17,14,15,15,16,17, 8, 9, 9,11,11,
+ 10,11,11,12,13,10,11,11,13,12,12,13,13,14,15,11,
+ 13,12,15,14, 9,11,10,12,12,11,12,12,13,14,11,12,
+ 12,14,13,13,13,14,15,15,13,14,13,15,15, 9,11,11,
+ 12,12,11,12,12,14,14,11,12,12,14,13,13,14,14,15,
+ 16,13,14,13,15,14,11,12,12,14,13,12,13,13,14,15,
+ 13,14,14,16,15,15,15,15,15,16,15,16,15,17,17,11,
+ 12,12,14,14,13,14,14,15,15,12,13,13,15,14,15,15,
+ 15,17,17,14,15,15,17,15,11,12,12,14,14,12,13,13,
+ 15,15,12,13,13,15,15,14,15,15,17,17,14,15,15,16,
+ 16,12,13,13,14,15,13,14,14,16,16,14,14,14,15,16,
+ 15,16,16,17,17,15,16,16,17,17,12,13,13,15,15,14,
+ 14,14,16,16,14,14,15,16,16,15,16,16,17,17,15,16,
+ 16,17,17,14,15,15,15,16,15,15,16,16,18,15,16,16,
+ 17,17,17,17,17,18,18,16,17,17,19,18,14,15,15,16,
+ 17,15,16,16,17,17,15,16,16,18,17,16,17,17,19,18,
+ 17,17,17,19,18,10,12,12,14,14,13,13,14,15,15,12,
+ 14,13,16,15,15,15,15,17,17,14,15,15,17,16,12,13,
+ 13,15,14,13,14,14,16,16,14,14,15,17,16,15,16,16,
+ 17,17,15,16,16,18,17,12,13,13,15,14,14,15,15,16,
+ 16,13,15,14,16,15,16,17,16,19,17,15,16,16,17,17,
+ 14,15,15,17,15,15,16,15,17,17,16,17,16,18,17,17,
+ 17,18,18,18,17,17,18,19,18,14,15,15,16,16,15,16,
+ 16,17,18,15,16,16,18,16,17,18,18,19,19,17,18,17,
+ 18,19, 6, 8, 8,10,10, 8,10,10,11,11, 8,10,10,12,
+ 11,10,11,11,13,13, 9,11,11,13,13, 9,10,10,11,11,
+ 10,11,11,12,12,10,11,11,12,12,11,12,12,14,14,11,
+ 12,12,14,14, 8,10, 9,11,11,10,11,11,12,12,10,11,
+ 11,12,12,11,12,12,14,14,11,12,12,14,14,10,11,11,
+ 13,13,11,12,13,14,14,12,12,12,14,14,13,14,14,15,
+ 16,13,14,14,16,16,10,11,10,13,12,11,12,12,14,14,
+ 11,12,12,14,14,13,14,14,15,16,13,14,14,16,15, 8,
+ 9, 9,11,11,10,11,11,12,13,10,11,11,13,12,12,13,
+ 13,14,15,12,13,13,15,14,10,11,11,12,12,11,11,12,
+ 13,14,11,12,12,14,14,13,13,14,15,16,13,14,14,15,
+ 15, 9,10,11,12,12,11,12,12,13,14,11,12,12,14,13,
+ 13,14,14,15,16,12,14,13,15,15,11,12,12,14,14,12,
+ 13,13,14,15,13,14,14,16,15,14,15,15,15,17,15,15,
+ 16,16,17,11,12,12,13,14,13,14,14,15,15,12,13,13,
+ 15,14,15,16,15,16,17,14,16,15,17,15, 9,10,10,12,
+ 11,10,11,11,13,13,10,11,11,13,12,11,12,12,14,14,
+ 11,12,12,14,14,10,11,11,12,13,11,12,12,13,14,11,
+ 12,12,14,14,12,13,13,15,15,12,13,13,15,15,10,11,
+ 10,13,12,11,12,12,13,13,11,12,12,14,13,12,13,13,
+ 15,15,12,13,13,15,14,12,13,12,14,14,13,14,14,15,
+ 15,13,14,14,15,15,14,15,15,16,16,14,15,15,16,16,
+ 11,13,11,14,12,13,13,13,15,14,12,14,13,15,14,15,
+ 15,15,17,16,14,15,14,17,15,10,12,12,14,14,13,13,
+ 14,15,16,12,14,13,15,15,14,15,16,17,17,14,15,16,
+ 17,17,12,13,13,14,15,13,14,14,16,16,14,14,15,16,
+ 16,16,16,16,17,17,16,16,16,18,18,12,13,13,14,15,
+ 14,14,15,16,16,13,14,14,16,15,16,16,16,17,18,15,
+ 16,16,17,17,14,15,15,16,16,15,15,16,17,17,15,16,
+ 16,17,18,17,18,18,18,19,17,18,18,19,19,14,15,15,
+ 16,16,15,16,16,17,17,15,16,16,17,17,17,17,18,20,
+ 18,17,18,17,18,18,11,12,12,14,14,12,13,14,15,15,
+ 12,13,13,15,15,14,15,15,16,17,14,15,15,16,17,12,
+ 13,13,15,15,14,14,14,16,16,14,14,14,16,16,15,16,
+ 16,17,17,15,16,16,17,17,12,13,13,15,14,13,14,14,
+ 16,15,14,15,14,16,15,15,16,16,17,17,15,16,16,17,
+ 16,14,15,15,16,16,15,16,16,17,17,16,16,16,17,17,
+ 17,17,17,19,18,17,17,17,18,19,14,15,14,17,15,15,
+ 16,16,17,17,15,16,15,17,17,16,17,17,18,18,16,17,
+ 17,18,17, 6,11,11,13,13,11,12,12,14,14,11,12,12,
+ 14,14,13,14,14,16,16,13,14,14,16,16,11,12,12,14,
+ 14,12,13,13,15,15,12,13,13,15,15,14,15,15,16,17,
+ 14,15,15,17,18,11,12,12,14,14,12,13,13,15,15,12,
+ 13,13,15,15,14,15,15,17,17,14,15,15,16,16,13,14,
+ 14,15,16,14,15,15,16,17,14,15,15,17,16,15,16,17,
+ 18,17,16,16,16,18,17,14,14,15,16,16,14,15,15,18,
+ 16,14,15,15,17,16,16,17,17,18,18,16,17,16,18,17,
+ 11,12,12,14,14,12,13,13,15,15,12,13,13,15,15,14,
+ 15,15,17,17,14,15,15,16,16,12,13,13,15,15,13,14,
+ 14,15,16,13,14,14,16,16,15,16,16,17,17,15,15,16,
+ 17,17,12,13,13,15,15,14,14,14,16,16,13,14,14,16,
+ 16,15,16,16,17,17,15,16,16,17,17,14,14,15,15,16,
+ 15,15,16,16,17,15,15,16,16,17,16,17,17,17,18,16,
+ 17,17,18,18,14,15,15,16,16,15,16,16,17,17,15,16,
+ 16,17,17,17,17,17,18,19,17,17,17,18,18,10,12,12,
+ 14,14,12,13,14,15,16,13,14,13,15,15,14,15,15,17,
+ 17,14,15,16,17,17,12,13,13,15,15,13,14,14,15,15,
+ 14,15,14,16,16,15,16,16,17,18,15,17,16,18,17,12,
+ 13,13,15,15,14,14,14,16,16,13,14,14,16,15,15,16,
+ 16,17,18,15,16,16,17,17,14,14,14,16,16,15,15,16,
+ 17,17,15,16,16,17,17,17,17,17,18,20,17,17,17,19,
+ 19,14,15,15,16,16,15,17,16,18,18,15,16,15,17,16,
+ 17,18,19,19,19,17,17,17,18,17,13,14,14,16,16,14,
+ 15,15,17,17,14,15,15,16,17,15,17,17,18,18,16,16,
+ 17,18,17,14,15,15,16,17,15,16,16,17,17,15,16,16,
+ 17,17,16,17,17,18,18,17,17,17,18,19,14,15,15,16,
+ 17,15,16,16,17,17,15,16,16,17,17,16,17,17,18,18,
+ 17,17,17,19,19,16,16,16,16,18,16,17,17,17,18,17,
+ 17,17,17,19,18,18,18,19,19,18,18,18,19,20,16,16,
+ 17,18,18,16,18,17,18,18,17,17,17,20,19,18,18,19,
+ 21,20,18,20,18,18,19,10,12,12,14,14,14,14,15,15,
+ 17,14,15,14,17,15,16,16,17,18,18,16,18,17,19,18,
+ 12,14,13,16,15,14,14,15,15,17,15,16,16,18,17,16,
+ 17,18,17,19,17,19,18,20,19,12,13,13,15,15,15,16,
+ 17,17,18,14,16,14,17,16,17,18,18,19,19,17,17,17,
+ 18,18,15,15,15,17,16,15,16,16,17,17,17,19,17,18,
+ 18,18,18,18,18,21,19,20,19,20,19,15,15,16,16,17,
+ 17,17,18,20,20,15,16,16,18,17,18,19,19,19,20,18,
+ 19,18,19,17, 6,11,11,13,13,11,12,12,14,14,11,12,
+ 12,14,14,13,14,14,16,16,13,14,14,16,16,11,12,12,
+ 14,14,12,13,13,15,15,12,13,13,15,15,14,15,15,17,
+ 17,14,15,15,17,16,11,12,12,14,14,12,13,13,15,15,
+ 12,13,13,15,15,14,15,15,16,16,14,15,15,16,16,13,
+ 14,14,16,16,15,15,15,16,16,14,15,15,17,16,16,17,
+ 17,19,18,16,17,17,18,18,13,14,14,15,15,14,15,15,
+ 17,16,14,15,15,17,16,16,17,16,17,18,15,16,16,18,
+ 18,10,12,12,14,14,12,13,14,15,15,12,13,13,15,15,
+ 14,15,15,17,17,14,15,15,17,16,12,13,13,15,15,14,
+ 14,14,15,16,14,15,15,16,16,15,16,16,17,18,16,16,
+ 16,18,18,12,13,13,14,14,14,14,15,16,16,13,14,14,
+ 16,16,15,16,16,18,18,15,16,16,19,17,14,15,15,16,
+ 17,15,15,16,17,17,16,17,16,17,18,17,17,18,17,19,
+ 17,17,18,18,19,14,14,14,16,16,15,16,16,17,17,15,
+ 16,15,17,17,17,17,17,19,20,16,17,17,18,18,11,12,
+ 12,14,14,12,13,13,15,15,12,13,13,15,15,14,15,15,
+ 16,16,14,15,14,16,16,12,13,13,15,15,14,14,14,16,
+ 16,13,14,14,16,16,15,16,16,18,17,15,16,16,17,17,
+ 12,13,13,15,15,13,14,14,16,16,13,14,14,16,16,15,
+ 16,15,18,18,15,16,15,17,16,14,15,15,16,16,15,16,
+ 16,17,17,15,16,16,18,17,16,17,17,18,18,16,17,17,
+ 18,18,14,15,14,16,15,15,16,15,17,17,15,16,15,17,
+ 16,16,17,17,18,18,17,17,16,19,17,10,12,12,14,15,
+ 14,14,15,15,17,14,15,14,17,15,16,17,17,17,18,16,
+ 17,17,18,18,12,14,13,16,15,14,14,16,15,17,15,17,
+ 16,18,17,17,17,18,17,19,18,18,18,19,18,12,13,14,
+ 15,15,15,16,16,16,17,14,15,14,18,16,18,17,18,19,
+ 19,17,18,17,20,18,15,15,15,17,17,15,16,16,17,18,
+ 18,18,18,19,18,18,18,19,18,20,18,19,19,21,21,15,
+ 15,16,16,17,17,18,18,18,18,15,16,16,17,17,17,19,
+ 20,19,20,17,18,18,19,17,13,14,14,16,16,14,15,15,
+ 16,17,14,15,15,17,17,16,16,17,17,18,15,17,16,17,
+ 17,14,15,15,16,16,15,16,16,17,17,16,16,16,17,17,
+ 17,17,18,17,18,17,17,17,18,20,14,15,15,17,16,15,
+ 16,16,17,17,15,16,16,17,17,17,17,17,18,18,16,17,
+ 17,19,18,16,16,17,17,17,17,18,17,19,18,17,17,17,
+ 18,19,17,20,18,19,21,17,19,18,19,20,15,17,15,17,
+ 16,16,17,17,18,18,17,17,17,18,17,18,19,18,19,21,
+ 18,18,17,19,19,
+};
+
+static const static_codebook _44p9_p2_0 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p9_p2_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p9_p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44p9_p3_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p9_p3_0[] = {
+ 2, 5, 4, 4, 7, 7, 4, 7, 6, 5, 6, 7, 7, 8, 9, 7,
+ 9, 9, 5, 7, 6, 7, 9, 9, 7, 9, 8, 6, 8, 8, 8,10,
+ 10, 8,10,10, 8, 9,10,10,11,12,10,12,12, 8,10,10,
+ 10,12,12,10,12,11, 6, 8, 8, 8,10,10, 8,10,10, 8,
+ 10,10,10,11,12,10,12,12, 8,10, 9,10,12,11,10,12,
+ 11, 5, 8, 8, 8,10,10, 8,10,10, 8, 9,10,10,11,11,
+ 10,11,11, 8,10,10,10,11,12,10,12,11, 8,10,10,10,
+ 11,11,10,11,11,10,11,11,11,12,13,11,12,13,10,11,
+ 11,11,13,13,11,13,13, 7, 9, 9,10,11,12,10,12,11,
+ 9,11,11,11,12,13,12,14,13, 9,11,11,12,13,14,11,
+ 13,12, 5, 8, 8, 8,10,10, 8,10,10, 8,10,10,10,11,
+ 12,10,12,12, 8,10, 9,10,12,11, 9,11,11, 7, 9, 9,
+ 10,11,12,10,12,11, 9,11,11,11,12,13,12,14,13, 9,
+ 11,11,12,13,14,11,13,12, 8,10,10,10,11,11,10,11,
+ 11,10,11,11,11,13,13,11,13,13,10,11,10,11,13,12,
+ 11,13,12,
+};
+
+static const static_codebook _44p9_p3_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p9_p3_0,
+ 1, -533200896, 1614282752, 2, 0,
+ (long *)_vq_quantlist__44p9_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44p9_p3_1[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p9_p3_1[] = {
+ 4, 6, 6, 6, 7, 7, 6, 7, 7, 6, 7, 7, 7, 7, 8, 7,
+ 7, 8, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 8, 9, 9, 8, 8, 8,
+ 8, 9, 9, 8, 9, 9, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 9, 9, 8, 9, 9, 8, 8, 8, 8, 9, 9, 8, 9,
+ 9, 5, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9,
+ 8, 9, 9, 8, 8, 8, 8, 9, 9, 8, 9, 9, 8, 8, 8, 8,
+ 9, 9, 8, 9, 9, 8, 8, 9, 9, 9, 9, 9, 9, 9, 8, 9,
+ 9, 9, 9, 9, 9, 9, 9, 7, 8, 8, 8, 9, 9, 8, 9, 9,
+ 8, 9, 8, 9, 9, 9, 9, 9, 9, 8, 8, 8, 9, 9, 9, 9,
+ 9, 9, 6, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9,
+ 9, 8, 9, 9, 8, 8, 8, 8, 9, 9, 8, 9, 9, 7, 8, 8,
+ 8, 9, 9, 8, 9, 9, 8, 8, 9, 9, 9, 9, 9, 9, 9, 8,
+ 8, 8, 9, 9, 9, 9, 9, 9, 8, 8, 8, 8, 9, 9, 8, 9,
+ 9, 8, 9, 9, 9, 9, 9, 9, 9, 9, 8, 9, 8, 9, 9, 9,
+ 9, 9, 9,
+};
+
+static const static_codebook _44p9_p3_1 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p9_p3_1,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44p9_p3_1,
+ 0
+};
+
+static const long _vq_quantlist__44p9_p4_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p9_p4_0[] = {
+ 2, 5, 5, 4, 7, 7, 4, 7, 6, 5, 7, 7, 7, 8, 9, 7,
+ 9, 9, 5, 7, 7, 7, 9, 9, 7, 9, 8, 6, 7, 8, 8, 9,
+ 10, 8,10,10, 8, 9,10,10,11,12,10,11,12, 8,10,10,
+ 10,11,12,10,12,11, 6, 8, 7, 8,10,10, 8,10, 9, 8,
+ 10,10,10,11,12,10,12,12, 8,10, 9,10,12,11,10,12,
+ 11, 5, 8, 8, 8,10,10, 8,10,10, 7, 9,10, 9,10,11,
+ 10,11,11, 8,10,10,10,12,12,10,12,11, 7, 9, 9, 9,
+ 11,11, 9,11,11, 9,10,11,11,11,12,11,12,12, 9,11,
+ 11,11,12,12,11,12,12, 7, 9, 9,10,11,12,10,12,11,
+ 9,11,10,11,11,12,12,13,13, 9,11,11,12,13,13,11,
+ 13,11, 5, 8, 8, 8,10,10, 8,10,10, 8,10,10,10,11,
+ 12,10,12,12, 7, 9, 9, 9,11,11, 9,11,10, 7, 9, 9,
+ 10,11,12,10,12,11, 9,11,11,11,11,13,12,13,13, 9,
+ 10,11,12,13,13,11,12,11, 7, 9, 9, 9,11,11, 9,11,
+ 11, 9,11,11,11,12,12,11,12,12, 9,11,10,11,12,12,
+ 10,12,11,
+};
+
+static const static_codebook _44p9_p4_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p9_p4_0,
+ 1, -531365888, 1616117760, 2, 0,
+ (long *)_vq_quantlist__44p9_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44p9_p4_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p9_p4_1[] = {
+ 6, 8, 8,10, 9, 8, 9, 9,10,10, 8, 9, 9,10,10, 8,
+ 10,10,10,10, 8,10,10,10,10, 9, 9, 9,10,10, 9,10,
+ 10,10,11, 9,10,10,11,11,10,10,10,11,11,10,10,10,
+ 11,11, 9, 9, 9,10,10, 9,10,10,11,11, 9,10,10,11,
+ 10,10,10,10,11,11,10,10,10,11,11,10,10,10,10,11,
+ 10,10,11,11,11,10,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,10,10,10,11,10,10,11,11,11,11,10,11,
+ 10,11,11,11,11,11,11,11,10,11,11,11,11, 9,10,10,
+ 10,11,10,10,11,11,11,10,11,11,11,11,10,11,11,11,
+ 11,10,11,11,11,11,10,10,11,11,11,11,11,11,11,11,
+ 11,11,11,11,12,11,11,12,12,12,11,11,11,12,12,10,
+ 11,11,11,11,11,11,11,12,12,11,11,11,11,11,11,11,
+ 11,12,12,11,11,11,12,12,11,11,11,11,11,11,12,12,
+ 12,12,11,12,12,12,12,11,12,12,12,12,12,12,12,12,
+ 12,11,11,11,11,11,11,12,12,12,12,11,12,11,12,12,
+ 11,12,12,12,12,12,12,12,12,12, 9,10,10,11,10,10,
+ 11,11,11,11,10,11,11,11,11,10,11,11,11,11,10,11,
+ 11,11,11,10,11,11,11,11,11,11,11,11,11,11,11,11,
+ 12,12,11,11,12,12,12,11,11,11,12,12,10,11,10,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,
+ 11,11,11,12,12,11,11,11,11,11,11,12,12,12,12,11,
+ 12,12,12,12,11,12,12,12,12,12,12,12,12,12,11,11,
+ 11,11,11,11,12,12,12,12,11,12,11,12,12,12,12,12,
+ 12,12,11,12,12,12,12,11,11,11,11,11,11,12,12,12,
+ 12,11,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 11,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,13,13,12,12,12,13,13,11,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,13,13,12,12,12,
+ 13,13,12,12,12,12,12,12,12,12,12,13,12,12,12,13,
+ 13,12,13,13,13,13,12,13,13,13,13,12,12,12,12,12,
+ 12,12,12,13,13,12,12,12,13,13,12,13,13,13,13,12,
+ 13,13,13,13,11,11,11,11,11,11,12,12,12,12,11,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,11,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,13,
+ 13,12,12,12,13,13,11,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,13,13,12,12,12,13,13,12,
+ 12,12,12,12,12,12,12,13,13,12,12,12,13,13,12,13,
+ 13,13,13,12,13,13,13,13,12,12,12,12,12,12,12,12,
+ 13,13,12,12,12,13,12,12,13,13,13,13,12,13,13,13,
+ 13, 7,10,10,11,11,10,10,11,11,11,10,11,11,11,11,
+ 10,11,11,11,11,10,11,11,11,11,10,10,10,11,11,10,
+ 11,11,11,11,11,11,11,11,12,11,11,11,12,12,11,11,
+ 11,12,12,10,11,11,11,11,11,11,11,12,11,11,11,11,
+ 12,11,11,11,11,12,12,11,11,11,12,12,11,11,11,11,
+ 11,11,11,11,12,12,11,11,12,12,12,11,12,12,12,12,
+ 11,12,12,12,12,11,11,11,11,11,11,12,12,12,12,11,
+ 11,12,12,12,11,12,12,12,12,11,12,12,12,12,10,11,
+ 11,11,11,11,11,11,11,12,11,11,11,11,11,11,11,11,
+ 12,12,11,11,11,12,12,11,11,11,11,11,11,11,12,12,
+ 12,11,11,11,12,12,11,12,12,12,12,11,12,12,12,12,
+ 11,11,11,11,11,11,12,11,12,12,11,11,11,12,12,11,
+ 12,12,12,12,11,12,12,12,12,11,11,11,11,12,11,12,
+ 12,12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,11,11,11,12,12,11,12,12,12,12,11,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,10,11,10,11,11,
+ 11,11,11,12,12,11,11,11,12,12,11,12,12,12,12,11,
+ 12,12,12,12,10,11,11,12,11,11,11,12,12,12,11,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,11,11,11,
+ 12,11,11,12,12,12,12,11,12,11,12,12,12,12,12,12,
+ 12,12,12,12,12,12,11,12,11,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,13,12,12,12,12,12,11,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,13,12,12,12,13,12,11,11,11,12,12,12,12,12,
+ 12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 13,11,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,13,13,13,12,12,12,13,13,11,12,12,12,12,12,
+ 12,12,12,13,12,12,12,12,12,12,12,13,13,13,12,13,
+ 12,13,13,12,12,12,12,12,12,12,12,13,13,12,12,12,
+ 13,13,12,13,13,13,13,12,13,13,13,13,12,12,12,12,
+ 12,12,12,12,13,13,12,13,12,13,13,12,13,13,13,13,
+ 12,13,13,13,13,11,11,11,12,12,12,12,12,12,12,11,
+ 12,12,12,12,12,12,12,13,13,12,12,12,13,13,11,12,
+ 12,12,12,12,12,12,12,12,12,12,12,13,13,12,13,12,
+ 13,13,12,13,13,13,13,11,12,12,12,12,12,12,12,13,
+ 13,12,12,12,13,12,12,13,13,13,13,12,13,13,13,13,
+ 12,12,12,12,12,12,12,13,13,13,12,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,12,12,12,12,12,12,13,
+ 13,13,13,12,12,12,13,13,13,13,13,13,13,13,13,13,
+ 13,13, 7,10,10,11,11,10,11,11,11,11,10,11,11,11,
+ 11,10,11,11,11,11,10,11,11,11,11,10,11,11,11,11,
+ 11,11,11,11,11,11,11,11,12,11,11,11,12,12,12,11,
+ 11,11,12,12,10,10,10,11,11,11,11,11,12,11,10,11,
+ 11,11,11,11,11,11,12,12,11,11,11,12,12,11,11,11,
+ 11,11,11,11,12,12,12,11,12,11,12,12,11,12,12,12,
+ 12,11,12,12,12,12,11,11,11,11,11,11,11,11,12,12,
+ 11,12,11,12,12,11,12,12,12,12,11,12,12,12,12,10,
+ 10,10,11,11,11,11,11,12,12,11,11,11,12,12,11,12,
+ 12,12,12,11,12,12,12,12,11,11,11,11,11,11,11,12,
+ 12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,11,11,11,11,11,11,12,12,12,12,11,12,11,12,12,
+ 12,12,12,12,12,12,12,12,12,12,11,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,13,12,12,
+ 12,13,12,11,11,11,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,10,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,
+ 11,11,11,12,12,11,11,11,11,11,11,11,12,12,12,11,
+ 12,11,12,12,11,12,12,12,12,11,12,12,12,12,11,11,
+ 11,11,11,11,11,11,12,12,11,11,11,12,12,11,12,12,
+ 12,12,11,12,12,12,12,11,11,11,12,11,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 11,11,11,12,11,11,12,12,12,12,11,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,11,11,11,12,12,11,12,
+ 12,12,12,12,12,12,12,12,12,12,12,13,13,12,12,12,
+ 13,12,11,12,12,12,12,12,12,12,12,13,12,12,12,13,
+ 13,12,13,13,13,13,12,13,13,13,13,11,12,12,12,12,
+ 12,12,12,12,13,12,12,12,12,12,12,13,13,13,13,12,
+ 13,13,13,13,12,12,12,12,12,12,12,13,13,13,12,13,
+ 12,13,13,13,13,13,13,13,13,13,13,13,13,12,12,12,
+ 12,12,12,13,13,13,13,12,13,12,13,13,13,13,13,13,
+ 13,13,13,13,13,13,11,11,11,12,12,11,12,12,12,12,
+ 11,12,12,12,12,12,12,12,12,12,12,12,12,12,12,11,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,13,
+ 12,13,13,12,12,12,13,13,11,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,13,13,12,13,12,13,
+ 13,12,12,12,12,12,12,12,12,13,13,12,12,12,13,13,
+ 13,13,13,13,13,12,13,13,13,13,12,12,12,12,12,12,
+ 13,12,13,13,12,13,12,13,12,12,13,13,13,13,12,13,
+ 13,13,13, 8,11,11,12,12,11,12,12,12,12,11,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,11,11,11,12,
+ 12,11,12,12,12,12,12,12,12,12,12,12,12,12,13,13,
+ 12,12,12,13,13,11,11,11,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,13,13,12,12,12,13,13,11,12,
+ 12,12,12,12,12,12,12,13,12,12,12,12,12,12,12,13,
+ 13,13,12,12,13,13,13,11,12,12,12,12,12,12,12,13,
+ 12,12,12,12,13,13,12,13,13,13,13,12,13,13,13,13,
+ 11,11,11,12,12,11,12,12,12,12,11,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,11,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,13,13,12,12,12,
+ 13,13,11,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,13,12,13,13,12,13,12,13,13,12,12,12,12,12,
+ 12,12,12,12,13,12,12,12,13,13,12,13,13,13,13,12,
+ 13,13,13,13,12,12,12,12,12,12,12,12,13,13,12,12,
+ 12,13,13,12,13,13,13,13,12,13,13,13,13,11,11,11,
+ 12,12,11,12,12,12,12,11,12,12,12,12,12,12,12,13,
+ 12,12,12,12,12,13,11,12,12,12,12,12,12,12,12,13,
+ 12,12,12,12,13,12,13,13,13,13,12,13,13,13,13,11,
+ 12,12,12,12,12,12,12,12,13,12,12,12,13,12,12,13,
+ 13,13,13,12,13,13,13,13,12,12,12,12,12,12,12,12,
+ 13,13,12,12,13,13,13,12,13,13,13,13,12,13,13,13,
+ 13,12,12,12,12,12,12,13,13,13,13,12,13,12,13,13,
+ 12,13,13,13,13,13,13,13,13,13,11,11,11,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,13,13,13,12,13,13,13,13,11,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,13,13,13,13,
+ 12,13,12,13,13,12,12,12,12,12,12,12,12,13,13,12,
+ 12,12,13,13,12,13,13,13,13,12,13,13,13,13,12,12,
+ 12,12,12,12,13,12,13,13,12,12,12,13,13,13,13,13,
+ 13,13,12,13,13,13,13,11,11,11,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,13,12,12,12,13,12,
+ 11,12,12,12,12,12,12,12,12,12,12,12,12,13,13,12,
+ 12,13,13,13,12,13,13,13,13,11,12,12,12,12,12,12,
+ 12,12,13,12,12,12,13,12,12,13,13,13,13,12,13,13,
+ 13,13,12,12,12,12,12,12,12,12,13,13,12,12,12,13,
+ 13,13,13,13,13,13,13,13,13,13,13,12,12,12,12,12,
+ 12,13,13,13,13,12,13,12,13,13,13,13,13,13,13,13,
+ 13,13,13,13, 8,11,11,11,11,11,12,12,12,12,11,12,
+ 12,12,12,12,12,12,12,12,11,12,12,12,12,11,11,11,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 13,12,12,12,13,13,11,11,11,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,13,13,12,12,12,13,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,13,13,12,13,
+ 13,13,13,12,13,13,13,13,11,12,12,12,12,12,12,12,
+ 12,13,12,12,12,13,12,12,13,13,13,13,12,13,12,13,
+ 13,11,11,11,12,12,12,12,12,12,12,11,12,12,12,12,
+ 12,12,12,13,13,12,12,12,13,12,11,12,12,12,12,12,
+ 12,12,12,12,12,12,12,13,13,12,12,13,13,13,12,13,
+ 13,13,13,11,12,12,12,12,12,12,12,13,13,12,12,12,
+ 12,12,12,13,13,13,13,12,13,13,13,13,12,12,12,12,
+ 12,12,12,13,13,13,12,12,13,13,13,13,13,13,13,13,
+ 12,13,13,13,13,12,12,12,12,12,12,13,12,13,13,12,
+ 12,12,13,13,13,13,13,13,13,12,13,13,13,13,11,11,
+ 11,12,12,11,12,12,12,12,11,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,11,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,13,12,13,13,12,12,12,13,13,
+ 11,12,12,12,12,12,12,12,12,13,12,12,12,12,12,12,
+ 12,12,13,13,12,13,12,13,13,12,12,12,12,12,12,12,
+ 12,13,12,12,12,12,13,13,12,13,13,13,13,12,13,13,
+ 13,13,12,12,12,12,12,12,12,12,13,13,12,12,12,13,
+ 12,12,13,13,13,13,12,13,13,13,13,11,11,11,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,13,13,11,12,12,12,12,12,12,12,12,13,12,12,
+ 12,12,12,12,13,13,13,13,12,13,13,13,13,11,12,12,
+ 12,12,12,12,12,12,13,12,12,12,12,12,12,13,13,13,
+ 13,12,13,13,13,13,12,12,12,12,12,12,12,12,13,13,
+ 12,12,13,13,13,13,13,13,13,13,13,13,13,13,13,12,
+ 12,12,12,12,12,13,13,13,13,12,12,12,13,12,13,13,
+ 13,13,13,12,13,13,13,13,11,11,11,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 13,11,12,12,12,12,12,12,12,12,12,12,12,12,13,12,
+ 12,12,12,13,13,12,13,13,13,13,11,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,13,13,13,13,12,13,
+ 12,13,13,12,12,12,12,12,12,12,13,13,13,12,13,12,
+ 13,13,12,13,13,13,13,13,13,13,13,13,12,12,12,12,
+ 12,12,12,12,12,13,12,12,12,13,13,13,13,13,13,13,
+ 12,13,13,13,13,
+};
+
+static const static_codebook _44p9_p4_1 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p9_p4_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p9_p4_1,
+ 0
+};
+
+static const long _vq_quantlist__44p9_p5_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p9_p5_0[] = {
+ 4, 6, 6, 9, 9, 6, 7, 8,10,11, 6, 8, 7,10,10, 8,
+ 10,10,12,12, 8,10,10,12,12, 6, 7, 8,10,10, 7, 8,
+ 9,10,11, 8, 9, 9,11,11,10,10,11,12,13,10,11,11,
+ 13,13, 6, 8, 7,10,10, 8, 9, 9,11,11, 7, 9, 8,11,
+ 10,10,11,11,13,13,10,11,10,13,12, 9,10,10,11,12,
+ 10,10,11,12,13,10,11,11,12,13,12,12,13,12,14,12,
+ 13,13,14,14, 9,10,10,12,11,10,11,11,13,12,10,11,
+ 10,13,12,12,13,13,14,14,12,13,12,14,12, 7, 8, 8,
+ 10,11, 8, 9,10,11,12, 8, 9, 9,11,12,10,11,12,13,
+ 14,10,11,11,13,13, 8, 9,10,11,12, 9,10,11,12,13,
+ 10,10,11,12,12,11,12,12,13,14,11,12,12,14,14, 8,
+ 9, 9,11,12,10,10,11,12,13, 9,10,10,12,12,11,12,
+ 12,14,14,11,12,12,14,13,11,11,12,12,13,11,12,12,
+ 13,14,12,12,13,14,14,13,13,14,14,16,13,14,14,15,
+ 15,11,12,11,13,13,12,12,12,14,14,11,12,12,14,13,
+ 13,14,14,15,15,13,14,13,15,14, 7, 8, 8,11,10, 8,
+ 10, 9,12,11, 8,10, 9,12,11,10,11,11,13,13,10,12,
+ 11,14,13, 8, 9, 9,12,11, 9,10,10,12,12,10,11,10,
+ 13,12,11,12,12,13,14,11,12,12,14,14, 8,10, 9,12,
+ 11,10,11,10,12,12, 9,11,10,13,11,11,12,12,14,14,
+ 11,12,12,14,13,11,11,12,13,13,11,12,12,13,14,12,
+ 12,12,14,14,13,13,14,14,15,13,14,14,15,15,11,12,
+ 11,13,12,12,12,12,14,14,11,12,12,14,13,13,14,14,
+ 15,15,13,14,13,15,14,10,11,11,12,13,11,12,12,13,
+ 14,11,12,12,13,14,13,13,14,14,16,13,14,14,15,15,
+ 11,12,12,12,14,12,12,13,13,15,12,13,13,13,15,14,
+ 14,15,15,16,14,14,15,15,16,11,12,12,13,14,12,13,
+ 13,14,15,12,13,13,14,14,14,14,15,15,16,14,14,14,
+ 15,15,13,14,14,14,15,14,14,15,15,16,14,15,15,15,
+ 16,15,15,16,16,18,16,16,16,17,17,13,14,14,15,15,
+ 14,14,15,16,16,14,14,14,16,15,16,16,16,17,17,15,
+ 16,16,17,16,10,11,11,13,12,11,12,12,14,13,11,12,
+ 12,14,13,13,14,14,15,15,13,14,13,16,14,11,12,12,
+ 14,13,12,13,13,14,14,12,13,13,15,14,14,14,14,15,
+ 15,14,15,14,16,15,11,12,12,14,12,12,13,13,15,14,
+ 12,13,12,15,13,14,15,14,16,15,14,15,14,16,15,13,
+ 14,14,15,15,14,14,14,15,16,14,15,14,16,16,15,16,
+ 16,16,17,16,16,16,17,17,13,14,14,15,14,14,15,15,
+ 16,15,14,15,14,16,15,16,16,16,17,17,15,16,15,18,
+ 16, 6, 8, 8,11,11, 8, 9,10,11,12, 8,10, 9,12,12,
+ 10,11,11,13,13,10,12,11,14,13, 8, 9, 9,11,12, 9,
+ 10,10,12,12, 9,10,10,12,12,11,11,12,13,14,11,12,
+ 12,14,14, 8,10, 9,12,11,10,11,11,12,12, 9,11,10,
+ 13,12,11,12,12,14,14,11,12,12,14,13,10,11,11,13,
+ 13,11,12,12,13,14,11,12,12,14,14,13,13,14,13,15,
+ 13,14,14,15,15,11,12,11,13,13,12,12,12,14,14,11,
+ 12,12,14,13,13,14,14,15,15,13,14,13,15,14, 8, 9,
+ 9,11,11, 9,10,10,12,12, 9,10,10,12,12,11,12,12,
+ 13,14,11,12,12,14,14, 9, 9,10,11,12,10,10,11,12,
+ 13,10,10,11,12,13,12,12,13,13,15,12,12,13,14,14,
+ 9,10,10,12,12,10,11,11,13,13,10,11,11,13,13,12,
+ 13,13,14,15,12,13,12,14,14,11,11,12,12,14,12,12,
+ 13,13,14,12,12,13,13,14,13,13,14,14,16,14,14,14,
+ 15,15,11,12,12,14,13,12,13,13,14,14,12,13,13,15,
+ 14,14,14,14,16,16,13,14,14,16,14, 7, 9, 9,12,11,
+ 9,10,10,12,12, 9,11,10,13,12,11,12,12,13,14,11,
+ 13,12,14,13, 9,10,10,12,12,10,10,11,12,13,10,12,
+ 11,13,13,12,12,13,13,14,12,13,13,15,14, 9,10,10,
+ 12,12,11,11,11,13,13,10,12,10,13,12,12,13,13,14,
+ 15,12,13,12,15,13,11,12,12,14,13,12,12,13,13,14,
+ 12,13,13,15,14,13,13,14,13,16,14,15,14,16,15,12,
+ 12,12,14,14,13,13,13,14,14,12,13,12,14,13,14,15,
+ 15,16,16,13,14,13,16,13,10,11,12,13,14,11,12,13,
+ 13,15,12,12,13,14,14,13,14,14,15,16,13,14,14,16,
+ 15,12,12,13,12,14,12,12,13,13,15,13,13,13,13,15,
+ 14,14,15,14,16,14,15,15,15,16,12,13,12,14,14,13,
+ 13,13,15,15,12,13,13,15,15,14,15,15,16,16,14,15,
+ 15,16,16,13,14,14,13,16,14,14,15,14,16,14,14,15,
+ 14,16,15,15,16,15,18,16,16,16,16,17,14,14,14,16,
+ 15,14,15,15,16,16,14,15,15,16,16,16,16,16,17,17,
+ 15,16,16,17,16,10,12,11,14,13,12,13,13,14,14,12,
+ 13,12,15,14,14,14,14,15,15,14,15,14,16,15,12,13,
+ 12,14,13,12,13,13,15,14,13,14,13,15,14,14,15,15,
+ 16,16,14,15,15,17,15,12,13,12,14,14,13,14,14,15,
+ 15,13,14,13,15,14,15,15,15,16,16,14,15,15,17,15,
+ 14,14,14,16,15,14,15,15,16,16,14,15,15,16,15,16,
+ 16,16,16,17,16,17,16,18,17,14,14,14,16,15,15,15,
+ 15,16,16,14,15,14,16,15,16,16,17,17,17,15,16,15,
+ 17,16, 6, 8, 8,11,11, 8, 9,10,12,12, 8,10, 9,12,
+ 11,10,11,12,13,13,10,11,11,13,13, 8, 9,10,11,12,
+ 9,10,11,12,13,10,11,11,12,12,11,12,12,13,14,11,
+ 12,12,14,14, 8, 9, 9,12,11, 9,10,10,12,12, 9,10,
+ 10,12,12,11,12,12,14,14,11,12,11,14,13,11,11,12,
+ 13,13,11,12,12,13,14,12,12,12,14,14,13,13,14,14,
+ 15,13,14,14,15,15,10,11,11,13,13,11,12,12,14,14,
+ 11,12,12,14,13,13,14,14,15,15,13,14,13,15,13, 7,
+ 9, 9,11,12, 9,10,11,12,13, 9,10,10,12,12,11,12,
+ 13,13,14,11,12,12,14,14, 9,10,10,12,12,10,10,11,
+ 12,13,11,12,11,13,13,12,12,13,13,15,12,13,13,15,
+ 14, 9,10,10,12,12,10,11,12,13,13,10,11,10,13,12,
+ 12,13,13,14,15,12,13,12,14,13,12,12,12,14,14,12,
+ 12,13,13,14,13,13,13,15,14,14,13,14,13,16,14,15,
+ 15,16,16,11,12,12,13,14,12,13,13,14,15,12,13,12,
+ 14,13,14,14,15,15,16,13,14,13,15,13, 8, 9, 9,11,
+ 11, 9,10,10,12,12, 9,10,10,12,12,11,12,12,14,14,
+ 11,12,11,14,13, 9,10,10,12,12,10,11,11,13,13,10,
+ 11,11,13,13,12,12,13,14,15,12,13,13,15,14, 9,10,
+ 9,12,11,10,11,10,13,12,10,11,10,13,12,12,13,12,
+ 14,14,12,13,12,15,13,11,12,12,13,14,12,13,13,14,
+ 14,12,13,13,14,14,14,14,14,14,16,14,14,14,16,15,
+ 11,12,11,14,12,12,13,12,15,13,12,13,12,15,13,14,
+ 14,14,16,15,13,14,13,16,14,10,11,12,13,14,12,12,
+ 13,13,15,12,13,13,14,14,14,14,15,15,16,14,14,14,
+ 15,16,12,12,13,14,14,12,13,14,14,15,13,14,14,15,
+ 15,14,15,15,15,17,15,15,15,16,16,12,12,13,13,14,
+ 13,13,14,14,15,12,13,13,14,15,15,15,15,15,17,14,
+ 15,15,15,15,14,14,14,16,16,14,15,15,15,16,15,15,
+ 15,16,16,16,15,16,16,18,16,16,17,17,17,14,14,14,
+ 15,16,15,15,15,16,17,14,15,14,16,16,16,16,17,17,
+ 18,16,16,15,17,16,10,12,11,14,13,12,12,12,14,14,
+ 11,13,12,14,13,13,14,14,15,15,13,14,13,16,15,12,
+ 12,13,14,14,12,13,13,15,15,13,13,13,15,15,14,15,
+ 15,16,16,14,15,15,17,16,12,13,12,14,12,13,13,13,
+ 15,13,12,13,12,15,13,14,15,15,16,15,14,15,14,16,
+ 14,14,14,14,16,16,14,15,15,16,16,14,15,15,16,16,
+ 15,16,16,16,17,16,17,16,18,17,13,14,14,16,13,14,
+ 15,15,16,14,14,15,14,16,14,16,16,16,17,16,15,16,
+ 15,18,15, 9,11,11,13,13,11,12,12,14,14,11,12,12,
+ 14,14,13,14,14,15,15,13,14,14,15,15,11,12,12,14,
+ 14,11,12,13,14,15,12,13,13,15,14,13,14,14,15,16,
+ 13,14,14,16,16,11,12,12,14,14,12,13,13,15,15,12,
+ 13,13,15,14,14,14,14,16,16,14,15,14,16,15,12,13,
+ 13,14,15,12,13,14,15,16,13,14,14,16,16,14,14,15,
+ 16,17,15,15,15,17,17,13,14,14,15,15,14,15,14,16,
+ 16,14,15,14,16,15,15,16,16,17,17,15,16,15,17,16,
+ 10,12,12,13,14,11,12,13,14,14,12,13,12,14,14,13,
+ 14,14,15,16,13,14,14,16,15,11,12,12,14,14,12,12,
+ 13,14,15,12,13,13,15,15,13,13,15,15,17,14,14,15,
+ 16,16,12,13,12,14,14,12,13,13,15,15,12,13,13,15,
+ 14,14,15,15,16,16,14,15,14,16,16,13,12,14,13,16,
+ 13,13,15,14,16,14,13,15,15,16,14,14,16,15,17,15,
+ 15,16,16,17,13,14,14,16,15,14,15,15,16,16,14,15,
+ 14,16,15,16,16,16,17,17,15,16,16,18,16,10,12,12,
+ 14,14,12,12,13,14,14,12,13,12,15,14,13,14,14,15,
+ 16,14,15,14,16,15,11,12,12,14,14,12,13,13,14,15,
+ 13,14,13,15,15,14,14,15,15,16,14,15,15,17,16,12,
+ 13,13,14,14,13,13,14,15,15,12,14,13,15,15,14,15,
+ 15,16,16,14,15,15,17,15,13,14,13,15,15,13,14,14,
+ 15,16,14,15,14,17,16,15,15,15,15,17,16,16,16,18,
+ 17,14,14,14,16,16,15,15,15,16,16,14,15,14,16,16,
+ 16,16,17,17,17,16,16,16,17,16,11,12,13,14,14,12,
+ 13,13,15,15,12,13,13,15,15,14,15,15,16,16,14,15,
+ 15,17,16,12,13,13,14,15,13,13,14,14,16,13,14,14,
+ 15,16,15,14,16,15,17,15,15,16,16,17,12,13,13,15,
+ 15,13,14,14,16,16,13,14,14,16,15,15,15,16,17,17,
+ 15,16,15,17,16,14,14,15,13,16,15,14,16,14,17,15,
+ 15,16,14,17,16,15,17,15,18,16,16,17,16,18,14,15,
+ 15,17,16,15,16,16,17,17,15,16,15,17,16,16,17,17,
+ 18,18,16,17,15,18,16,11,12,12,14,14,13,13,14,14,
+ 15,13,14,13,16,14,15,15,15,16,16,15,16,15,17,16,
+ 12,13,13,15,14,13,13,14,15,15,14,15,14,16,15,15,
+ 15,16,15,16,16,16,16,18,16,12,13,13,15,15,14,14,
+ 15,15,16,13,14,13,16,15,16,16,16,17,17,15,16,15,
+ 17,15,14,15,14,16,15,14,15,15,16,16,15,16,15,17,
+ 16,16,15,16,15,17,17,18,17,18,17,15,15,15,16,16,
+ 16,16,16,17,17,14,15,15,17,16,17,17,18,18,18,16,
+ 17,15,18,15, 9,11,11,13,13,11,12,12,14,14,11,12,
+ 12,14,14,13,14,14,15,16,13,14,14,15,15,11,12,12,
+ 14,14,12,13,13,14,15,12,13,13,14,14,14,14,15,15,
+ 16,14,14,14,16,16,11,12,12,14,14,12,13,13,14,15,
+ 11,13,12,14,14,13,14,14,16,16,13,14,14,16,15,13,
+ 14,14,15,15,14,14,15,15,16,14,15,14,16,16,15,15,
+ 16,16,17,15,16,16,17,17,12,13,13,15,15,13,14,14,
+ 16,15,12,14,13,16,15,15,16,15,17,17,14,15,15,17,
+ 15,10,12,12,14,14,12,12,13,14,15,12,13,12,14,14,
+ 14,14,15,15,16,13,14,14,16,16,12,13,13,14,14,13,
+ 13,14,14,15,13,14,13,15,15,14,15,15,15,17,14,15,
+ 15,16,16,11,12,12,14,14,13,13,14,15,15,12,13,13,
+ 15,14,14,15,15,16,17,14,15,14,16,15,14,14,14,16,
+ 16,14,15,15,16,16,15,15,15,16,16,15,16,16,16,18,
+ 16,17,16,18,17,13,13,14,15,15,14,14,15,16,16,13,
+ 14,14,16,15,16,16,17,17,17,15,15,15,17,15,10,12,
+ 12,14,13,12,12,13,14,14,11,13,12,14,14,13,14,14,
+ 16,16,13,14,14,16,15,12,12,13,14,14,12,13,13,14,
+ 15,13,13,13,15,15,14,14,15,16,16,14,15,15,16,16,
+ 11,12,12,14,14,12,13,13,15,15,12,13,12,15,14,14,
+ 15,14,16,16,13,15,13,16,15,13,14,14,15,16,14,15,
+ 15,15,17,14,15,15,16,16,16,15,16,16,17,16,16,16,
+ 17,17,13,14,12,16,13,14,15,13,16,15,13,15,13,16,
+ 14,15,16,15,17,16,15,16,14,17,15,11,12,12,14,15,
+ 13,13,14,14,16,13,14,13,15,14,15,15,16,16,17,15,
+ 15,15,16,16,12,13,13,15,15,13,13,14,15,16,14,15,
+ 14,16,15,15,15,16,15,17,16,16,16,17,17,12,13,13,
+ 14,15,14,14,15,15,16,13,14,13,15,15,16,16,16,17,
+ 17,15,16,15,16,15,15,15,15,16,16,14,15,15,16,17,
+ 16,16,16,17,17,16,15,17,15,18,17,18,17,18,18,14,
+ 14,15,15,17,15,15,16,16,17,14,15,15,16,16,17,17,
+ 17,17,18,16,16,15,17,15,11,12,12,14,14,12,13,13,
+ 15,15,12,13,13,15,15,14,15,15,16,16,14,15,14,17,
+ 16,13,13,13,15,15,13,14,14,15,16,13,14,14,16,16,
+ 15,15,16,16,17,15,16,16,17,17,12,13,13,15,14,13,
+ 14,14,16,15,13,14,13,16,14,15,16,16,17,16,15,16,
+ 14,17,15,14,15,15,16,17,15,15,16,16,17,15,16,16,
+ 17,17,16,15,17,16,18,16,17,17,18,18,14,15,14,16,
+ 13,15,16,15,17,14,15,16,14,17,14,16,17,16,18,16,
+ 16,17,15,18,15,
+};
+
+static const static_codebook _44p9_p5_0 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p9_p5_0,
+ 1, -528744448, 1616642048, 3, 0,
+ (long *)_vq_quantlist__44p9_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44p9_p5_1[] = {
+ 3,
+ 2,
+ 4,
+ 1,
+ 5,
+ 0,
+ 6,
+};
+
+static const long _vq_lengthlist__44p9_p5_1[] = {
+ 2, 3, 3, 3, 3, 3, 3,
+};
+
+static const static_codebook _44p9_p5_1 = {
+ 1, 7,
+ (long *)_vq_lengthlist__44p9_p5_1,
+ 1, -533200896, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44p9_p5_1,
+ 0
+};
+
+static const long _vq_quantlist__44p9_p6_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p9_p6_0[] = {
+ 2, 5, 5, 5, 7, 7, 5, 7, 7, 5, 7, 7, 7, 8, 9, 7,
+ 9, 9, 5, 7, 7, 7, 9, 9, 7, 9, 8, 5, 7, 8, 8, 9,
+ 10, 8, 9,10, 8, 9,10,10,10,12,10,11,11, 8,10,10,
+ 10,11,12,10,11,10, 5, 8, 7, 8,10,10, 8,10, 9, 8,
+ 10,10,10,10,11,10,12,11, 8,10, 9,10,11,11,10,12,
+ 10, 5, 8, 8, 7, 9,10, 8,10, 9, 7, 9,10, 9,10,11,
+ 9,11,11, 8,10, 9,10,11,11, 9,11,10, 7, 9, 9, 9,
+ 10,11, 9,11,11, 9, 9,11,10,10,13,11,12,12, 9,11,
+ 11,11,12,13,11,13,11, 7, 9, 9, 9,10,11, 9,11,10,
+ 9,11,10,10,10,12,11,13,12, 9,11,11,11,12,12,10,
+ 12,10, 5, 8, 8, 8, 9,10, 7,10, 9, 8, 9,10, 9,10,
+ 11,10,11,11, 7,10, 9, 9,11,11, 9,11,10, 7, 9, 9,
+ 9,10,11, 9,11,10, 9,11,11,10,10,12,11,12,12, 9,
+ 10,11,11,12,13,10,12,10, 7, 9, 9, 9,11,11, 9,11,
+ 10, 9,11,11,11,11,13,11,13,12, 9,11, 9,11,12,12,
+ 10,13,10,
+};
+
+static const static_codebook _44p9_p6_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p9_p6_0,
+ 1, -527106048, 1620377600, 2, 0,
+ (long *)_vq_quantlist__44p9_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44p9_p6_1[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44p9_p6_1[] = {
+ 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 7, 8, 8, 7,
+ 8, 8, 7, 8, 7, 7, 8, 8, 7, 8, 8, 7, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 8, 8, 9, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9,
+ 8, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 8, 8, 9, 8, 8,
+ 8, 8, 9, 9, 8, 9, 9, 7, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 9, 8, 8, 8, 8, 8, 9, 9, 8,
+ 9, 8, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 9, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 7, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 8, 9, 9, 8,
+ 8, 8, 8, 8, 9, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 9, 9, 8, 9, 9, 8, 8, 8, 8, 9, 8,
+ 8, 9, 8,
+};
+
+static const static_codebook _44p9_p6_1 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44p9_p6_1,
+ 1, -530841600, 1616642048, 2, 0,
+ (long *)_vq_quantlist__44p9_p6_1,
+ 0
+};
+
+static const long _vq_quantlist__44p9_p7_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p9_p7_0[] = {
+ 1,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,
+};
+
+static const static_codebook _44p9_p7_0 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p9_p7_0,
+ 1, -510105088, 1635281408, 3, 0,
+ (long *)_vq_quantlist__44p9_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44p9_p7_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44p9_p7_1[] = {
+ 1, 4, 4,16,16, 4, 9,11,15,16, 4,12, 8,16,16,12,
+ 16,16,16,16,13,16,16,16,16, 5, 8,10,16,16, 9, 9,
+ 14,15,16,12,14,14,16,16,16,16,16,16,16,16,16,16,
+ 16,16, 5,11, 8,16,15,12,14,16,16,16, 9,15, 9,16,
+ 16,16,16,16,16,16,16,16,16,16,16,15,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16, 6,11,11,
+ 16,16,12,13,16,16,16,12,16,14,16,16,16,16,16,16,
+ 16,16,16,16,16,16,11,15,15,16,16,14,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,12,
+ 15,16,16,16,16,16,16,16,16,14,16,15,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16, 5,11,11,16,16,12,
+ 15,16,16,16,12,16,14,16,16,16,16,16,16,16,16,16,
+ 16,16,16,12,15,15,16,16,14,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,11,15,15,16,
+ 16,16,16,16,16,16,15,16,14,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16, 6,11,12,16,16,11,15,16,16,16,13,16,14,16,16,
+ 16,16,16,16,16,16,16,16,16,16,11,16,14,16,16,14,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,12,14,14,16,16,16,16,16,16,16,15,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,15,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16, 8,13,
+ 15,16,16,15,15,16,16,16,14,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,14,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 15,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16, 7,12,12,16,16,
+ 13,12,16,16,16,14,16,14,16,16,16,16,16,16,16,16,
+ 16,16,16,16,13,16,16,16,16,14,14,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,12,14,16,
+ 16,16,16,16,16,16,16,14,16,14,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16, 6,11,11,16,16,13,15,16,16,16,11,15,14,16,
+ 16,16,16,16,16,16,14,16,16,16,16,11,16,16,16,16,
+ 16,16,16,16,16,15,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,11,16,14,16,16,14,16,16,16,16,13,15,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16, 7,
+ 11,11,16,16,13,13,16,16,16,13,16,13,16,16,16,16,
+ 16,16,16,16,16,16,16,16,12,16,15,16,16,14,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,12,14,16,16,16,16,16,16,16,16,14,16,13,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16, 8,13,14,16,
+ 16,15,16,16,16,16,14,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,15,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,15,16,
+ 15,16,16,16,16,16,16,16,16,16,15,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,15,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,15,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,
+};
+
+static const static_codebook _44p9_p7_1 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44p9_p7_1,
+ 1, -514619392, 1630767104, 3, 0,
+ (long *)_vq_quantlist__44p9_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44p9_p7_2[] = {
+ 12,
+ 11,
+ 13,
+ 10,
+ 14,
+ 9,
+ 15,
+ 8,
+ 16,
+ 7,
+ 17,
+ 6,
+ 18,
+ 5,
+ 19,
+ 4,
+ 20,
+ 3,
+ 21,
+ 2,
+ 22,
+ 1,
+ 23,
+ 0,
+ 24,
+};
+
+static const long _vq_lengthlist__44p9_p7_2[] = {
+ 1, 3, 2, 5, 4, 7, 7, 8, 8, 9,10,10,10,11,11,11,
+ 12,12,12,13,13,13,13,13,13,
+};
+
+static const static_codebook _44p9_p7_2 = {
+ 1, 25,
+ (long *)_vq_lengthlist__44p9_p7_2,
+ 1, -518864896, 1620639744, 5, 0,
+ (long *)_vq_quantlist__44p9_p7_2,
+ 0
+};
+
+static const long _vq_quantlist__44p9_p7_3[] = {
+ 12,
+ 11,
+ 13,
+ 10,
+ 14,
+ 9,
+ 15,
+ 8,
+ 16,
+ 7,
+ 17,
+ 6,
+ 18,
+ 5,
+ 19,
+ 4,
+ 20,
+ 3,
+ 21,
+ 2,
+ 22,
+ 1,
+ 23,
+ 0,
+ 24,
+};
+
+static const long _vq_lengthlist__44p9_p7_3[] = {
+ 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5,
+};
+
+static const static_codebook _44p9_p7_3 = {
+ 1, 25,
+ (long *)_vq_lengthlist__44p9_p7_3,
+ 1, -529006592, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44p9_p7_3,
+ 0
+};
+
+static const long _huff_lengthlist__44p9_short[] = {
+ 3, 3, 3, 3, 3, 3, 3, 3,
+};
+
+static const static_codebook _huff_book__44p9_short = {
+ 1, 8,
+ (long *)_huff_lengthlist__44p9_short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44pn1_l0_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44pn1_l0_0[] = {
+ 1, 3, 3, 8, 8,10,10,10,10,10,10,10,10, 5, 7, 5,
+ 9, 8,10,10,10,10,11,10,11,10, 5, 5, 7, 8, 9,10,
+ 10,11,10,10,11,10,11,10,10,10,11,11,11,11,11,11,
+ 11,10,11,11,10,10,10,10,11,11,11,11,11,10,11,11,
+ 11,11,11,11,11,11,12,11,10,11,11,11,11,11,11,11,
+ 11,11,11,11,11,10,10,11,11,12,11,11,11,11,11,11,
+ 12,11,11,11,10,11,11,11,11,11,11,11,11,10,11,11,
+ 10,11,10,11,11,11,11,11,11,11,11,11,11,12,11,11,
+ 12,12,11,11,11,11,11,11,11,11,11,11,11,11,12,11,
+ 10,11,11,11,11,11,11,11,12,11,13,11,11,11,11,11,
+ 11,11,11,11,11,11,12,11,13,
+};
+
+static const static_codebook _44pn1_l0_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44pn1_l0_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44pn1_l0_0,
+ 0
+};
+
+static const long _vq_quantlist__44pn1_l0_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44pn1_l0_1[] = {
+ 1, 4, 4, 7, 7, 4, 5, 6, 7, 7, 4, 6, 5, 7, 7, 7,
+ 6, 7, 6, 7, 7, 7, 6, 7, 6,
+};
+
+static const static_codebook _44pn1_l0_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44pn1_l0_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44pn1_l0_1,
+ 0
+};
+
+static const long _vq_quantlist__44pn1_l1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44pn1_l1_0[] = {
+ 1, 4, 4, 4, 4, 4, 4, 4, 4,
+};
+
+static const static_codebook _44pn1_l1_0 = {
+ 2, 9,
+ (long *)_vq_lengthlist__44pn1_l1_0,
+ 1, -516716544, 1630767104, 2, 0,
+ (long *)_vq_quantlist__44pn1_l1_0,
+ 0
+};
+
+static const long _huff_lengthlist__44pn1_lfe[] = {
+ 1, 3, 2, 3,
+};
+
+static const static_codebook _huff_book__44pn1_lfe = {
+ 2, 4,
+ (long *)_huff_lengthlist__44pn1_lfe,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44pn1_long[] = {
+ 2, 3, 6, 7, 9,13,17, 3, 2, 5, 7, 9,13,17, 6, 5,
+ 5, 6, 9,12,16, 7, 7, 6, 6, 7,10,13,10,10, 9, 7,
+ 6,10,13,13,13,12,10,10,11,15,17,17,17,14,14,15,
+ 17,
+};
+
+static const static_codebook _huff_book__44pn1_long = {
+ 2, 49,
+ (long *)_huff_lengthlist__44pn1_long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44pn1_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44pn1_p1_0[] = {
+ 1, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0,
+};
+
+static const static_codebook _44pn1_p1_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44pn1_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44pn1_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44pn1_p2_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44pn1_p2_0[] = {
+ 1, 5, 5, 0, 7, 7, 0, 8, 8, 0, 9, 9, 0,12,12, 0,
+ 8, 8, 0, 9, 9, 0,13,13, 0, 8, 8, 0, 6, 6, 0,11,
+ 11, 0,12,12, 0,12,12, 0,14,14, 0,11,12, 0,12,12,
+ 0,15,15, 0,12,12, 0, 5, 5, 0, 5, 5, 0, 6, 6, 0,
+ 7, 7, 0,10,10, 0, 6, 6, 0, 7, 7, 0,11,11, 0, 6,
+ 6, 0, 7, 7, 0,11,11, 0,12,11, 0,11,11, 0,14,14,
+ 0,10,10, 0,12,12, 0,15,15, 0,12,12, 0, 6, 6, 0,
+ 12,12, 0,12,12, 0,12,12, 0,14,14, 0,11,11, 0,12,
+ 12, 0,16,16, 0,12,12, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 8, 8, 0,12,12, 0,12,12, 0,12,12, 0,15,
+ 15, 0,12,12, 0,11,11, 0,16,16, 0,11,11, 0, 6, 6,
+ 0,12,12, 0,12,12, 0,13,13, 0,15,15, 0,12,12, 0,
+ 13,13, 0,15,15, 0,12,12, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0,
+};
+
+static const static_codebook _44pn1_p2_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44pn1_p2_0,
+ 1, -533200896, 1614282752, 2, 0,
+ (long *)_vq_quantlist__44pn1_p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44pn1_p2_1[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44pn1_p2_1[] = {
+ 1, 3, 3, 0, 9, 9, 0, 9, 9, 0,10,10, 0, 9, 9, 0,
+ 10,10, 0,10,10, 0,10,10, 0,10,10, 0, 7, 7, 0, 7,
+ 7, 0, 6, 6, 0, 8, 8, 0, 7, 7, 0, 8, 8, 0, 8, 8,
+ 0, 7, 7, 0, 8, 8, 0, 7, 7, 0, 9, 9, 0, 8, 9, 0,
+ 10,10, 0, 9, 9, 0,10,10, 0,10,11, 0, 9, 9, 0,10,
+ 10, 0, 9, 9, 0,11,11, 0,12,12, 0,12,12, 0,11,11,
+ 0,12,12, 0,13,13, 0,12,12, 0,13,13, 0, 8, 8, 0,
+ 12,12, 0,12,12, 0,13,13, 0,13,13, 0,13,13, 0,13,
+ 13, 0,13,13, 0,13,13, 0, 7, 7, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 9, 9, 0,11,11, 0,12,12, 0,13,13, 0,12,
+ 12, 0,13,13, 0,13,13, 0,12,12, 0,12,12, 0, 9, 9,
+ 0,12,12, 0,13,13, 0,14,14, 0,13,13, 0,14,14, 0,
+ 14,14, 0,13,13, 0,14,14, 0, 7, 7, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0,
+};
+
+static const static_codebook _44pn1_p2_1 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44pn1_p2_1,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44pn1_p2_1,
+ 0
+};
+
+static const long _vq_quantlist__44pn1_p3_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44pn1_p3_0[] = {
+ 1, 6, 6, 6, 8, 8, 6, 8, 8, 7, 9, 9,10,11,11, 8,
+ 8, 8, 7, 9, 9,11,12,12, 9, 9, 9, 6, 7, 7,10,11,
+ 11,10,11,11,10,11,11,13,13,13,12,12,12,10,12,11,
+ 14,14,14,12,12,12, 6, 5, 5, 9, 6, 6, 9, 6, 6, 9,
+ 7, 7,12,10,10,11, 7, 6, 9, 7, 7,13,11,11,12, 7,
+ 7, 7, 8, 8,12,10,10,12,10,10,11,10,10,15,13,13,
+ 13, 9, 9,12,11,11,15,14,14,15,11,11, 8, 7, 7,12,
+ 11,11,12,11,11,11,11,11,14,13,14,14,12,12,12,11,
+ 11,16,15,15,14,12,12, 0,10,10, 0,12,12, 0,12,12,
+ 0,11,11, 0,14,14, 0,11,11, 0,11,11, 0,15,15, 0,
+ 11,11, 7, 8, 8,13,11,11,12,10,10,12,11,11,15,13,
+ 13,14,11,11,12,10,10,16,14,14,15,10,10, 9, 7, 7,
+ 13,11,12,13,12,11,12,11,11,15,14,14,14,12,12,13,
+ 12,12,16,15,15,15,12,12, 0,11,11, 0,12,12, 0,12,
+ 13, 0,12,12, 0,15,15, 0,12,12, 0,12,12, 0,16,15,
+ 0,12,12,
+};
+
+static const static_codebook _44pn1_p3_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44pn1_p3_0,
+ 1, -531365888, 1616117760, 2, 0,
+ (long *)_vq_quantlist__44pn1_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44pn1_p3_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44pn1_p3_1[] = {
+ 2, 3, 4, 9, 9,10,12,12,12,11,10,12,12,13,12,11,
+ 13,12,11,11,11,12,12,12,11,11,13,13,13,13,11,12,
+ 12,14,14,12,13,13,13,13,11,13,13,13,13,11,13,13,
+ 13,13,11,13,13,13,13,11,12,12,14,14,12,13,13,12,
+ 12,11,13,13,13,13,11,13,13,12,12,11,13,13,13,13,
+ 12,12,13,14,14,12,13,13,12,12,11,13,13,13,13,11,
+ 13,13,12,12,11,13,13,13,13,12,13,13,14,14,12,13,
+ 13,12,12,11,13,13,13,13,11,13,13,12,12,11,10,10,
+ 10,10,12,10,10,11,11,12, 9, 9,11,11,13,11,11,10,
+ 10,13,10,10,10,10,13,11,11,12,12,13,10,10,12,12,
+ 14,12,11,12,12,13,11,11,11,12,13,12,12,12,12,13,
+ 11,11,12,12,13,10,10,12,12,14,11,11,12,12,13,11,
+ 11,12,12,13,11,11,12,12,14,12,12,12,12,14,10,10,
+ 11,11,14,12,11,11,11,13,11,11,11,11,13,12,12,11,
+ 11,14,12,12,12,11,14,10,10,11,11,14,12,11,11,11,
+ 13,11,11,11,11,13,12,12,11,11,11,11,11,10,10,12,
+ 10,11, 9, 9,12,12,12,11,11,13,12,12, 9, 9,13,13,
+ 13,10,10,13,13,13,12,12,13,13,13,14,14,13,12,12,
+ 11,11,14,13,13,12,12,14,13,13,11,11,13,13,13,12,
+ 11,13,13,13,14,14,13,12,12,10,10,14,13,13,11,11,
+ 13,13,13,10,10,13,13,13,11,11,14,13,13,14,14,14,
+ 12,12,10,10,13,13,13,11,11,13,13,13,10,10,13,13,
+ 13,11,11,14,13,13,14,14,14,13,13,10,10,13,13,13,
+ 11,11,13,13,13,10,10,14,12,12, 8, 8,14,12,12, 9,
+ 9,14,11,11, 9, 9,14,12,12, 8, 8,14,12,12, 7, 7,
+ 15,13,13,10,10,15,12,12,10,10,15,13,13,10,10,15,
+ 12,13, 9, 9,15,13,13,10,10,15,13,13,10,10,15,12,
+ 12,10,10,15,13,13,10,10,15,13,13, 9, 9,15,13,13,
+ 10,10,15,13,13,10,10,15,12,12,10,10,15,13,13, 9,
+ 9,14,13,12, 9, 9,14,13,13, 9, 9,15,13,13,10,10,
+ 15,12,12,10,10,15,13,13, 9, 9,15,13,13, 9, 9,14,
+ 13,13, 9, 9,14,12,12, 8, 8,13,13,13, 8, 8,14,14,
+ 13, 9, 9,14,14,13, 7, 7,14,14,14, 8, 8,14,14,14,
+ 10,10,15,14,14,12,12,14,14,14, 9, 9,15,14,14,10,
+ 10,14,14,14, 9, 9,14,14,14,10, 9,15,14,14,12,12,
+ 14,14,14, 9, 9,15,14,14,10,10,14,14,14, 9, 9,15,
+ 14,15, 9, 9,15,14,14,11,11,14,14,14, 8, 8,14,14,
+ 14, 9, 9,14,14,14, 8, 8,14,15,14,10,10,15,14,14,
+ 11,11,14,14,14, 8, 8,15,14,14, 9, 9,14,14,14, 8,
+ 8,12,12,12,13,13,16,16,15,12,12,17,16,16,13,13,
+ 17,16,16,11,11,17,16,16,12,12,17,16,17,13,13,17,
+ 16,16,14,14,17,17,16,12,12,18,16,16,13,13,17,16,
+ 17,12,12,17,17,17,13,13,18,16,16,14,14,18,17,17,
+ 12,12,17,17,17,13,13,18,17,17,13,13,17,17,17,13,
+ 13,17,16,16,14,14,17,17,17,12,12,16,16,17,13,13,
+ 17,17,16,12,12,18,17,17,13,13,18,16,16,14,14,18,
+ 17,17,12,12,19,16,17,13,13,17,16,17,12,12,13,14,
+ 14,10,10,16,14,14,13,13,17,15,15,14,14,17,14,14,
+ 13,13,16,14,14,13,13,17,16,15,14,14,16,16,16,15,
+ 15,17,15,15,14,14,17,15,15,14,14,17,15,15,14,14,
+ 17,16,15,14,14,16,16,16,15,15,18,15,15,13,13,16,
+ 16,15,14,14,17,15,15,14,13,17,15,15,14,14,16,16,
+ 16,15,15,18,15,14,13,13,17,15,15,14,14,18,14,15,
+ 13,13,18,15,15,14,14,16,16,16,15,15,17,15,15,13,
+ 13,17,15,15,14,14,17,15,15,13,13,13,11,11,10,10,
+ 16,14,14,13,13,17,14,15,14,14,17,15,15,12,12,17,
+ 14,14,12,12,16,15,15,14,14,16,14,14,14,14,16,15,
+ 15,14,14,16,15,15,14,14,16,15,15,14,14,16,15,15,
+ 14,14,16,15,14,15,15,17,15,15,14,14,17,15,15,14,
+ 14,17,15,15,14,14,17,15,16,14,14,16,14,14,14,14,
+ 17,15,15,13,13,17,15,15,13,13,16,15,15,13,13,17,
+ 16,16,14,14,17,15,14,15,14,17,15,15,13,13,17,15,
+ 15,13,13,17,15,15,13,13,14,14,14, 9, 9,14,14,14,
+ 18,19,14,15,15,19,18,14,14,14,19,19,15,14,14,19,
+ 19,15,16,16,19,19,15,16,16,19,19,15,15,15,19,19,
+ 15,16,16,19,20,15,15,15,19,19,15,15,15,19,19,15,
+ 16,16,20,20,15,15,15,18,19,15,15,16,19,20,15,15,
+ 15,19,18,15,15,15,18,18,15,16,16,21,20,15,15,15,
+ 19,19,15,15,15,19,19,15,15,14,19,20,15,15,15,20,
+ 19,15,16,16,19,20,15,15,15,19,19,15,15,15,20,21,
+ 15,14,15,19,19,14,12,12, 9, 9,14,14,15,21,19,14,
+ 14,14,18,19,14,15,15,19,20,14,14,14,19,19,15,15,
+ 15,19,20,15,15,14,21,19,15,15,15,20,19,15,14,15,
+ 20,21,15,15,15,18,18,15,15,15,20,21,16,14,14,18,
+ 19,15,15,15,20,19,15,15,15,18,21,15,15,15,19,19,
+ 15,15,15,19,20,16,15,14,20,19,15,16,15,19,19,15,
+ 15,15,19, 0,14,15,15,19,19,15,15,15,19,19,15,15,
+ 14,20,19,15,15,15,20,19,15,15,15,19,19,15,15,15,
+ 20,19,12,12,12,13,13,16,15,16,11,11,16,16,16,12,
+ 12,17,16,16,11,11,17,16,16,12,11,17,17,17,13,13,
+ 18,16,16,14,14,18,18,17,13,13,17,16,16,13,13,17,
+ 17,17,13,13,17,16,17,12,12,17,15,16,13,13,17,16,
+ 17,12,12,17,16,16,13,12,17,16,16,12,12,18,17,17,
+ 13,13,18,16,16,13,14,18,17,17,12,12,17,16,16,12,
+ 12,17,17,17,12,12,18,17,17,13,13,17,16,16,14,14,
+ 17,17,17,12,12,17,16,16,12,12,18,17,17,12,12,13,
+ 14,14, 9, 9,16,14,14,13,13,16,15,15,14,14,16,14,
+ 14,13,13,16,14,14,13,13,17,16,15,15,15,16,15,16,
+ 16,15,17,15,15,14,14,17,15,15,15,15,17,15,15,14,
+ 14,17,15,15,14,14,16,15,16,16,16,17,15,15,14,14,
+ 16,15,15,14,15,16,15,15,14,14,17,15,15,15,15,16,
+ 16,16,15,16,18,15,14,13,14,17,15,15,14,14,17,14,
+ 14,13,13,17,15,15,14,14,16,15,15,15,15,17,15,14,
+ 14,14,17,15,15,14,14,17,14,14,13,13,13,11,11,11,
+ 11,16,14,14,12,12,16,14,14,13,13,16,14,14,12,12,
+ 16,14,14,12,12,16,15,15,13,13,17,14,14,14,14,17,
+ 15,15,13,13,16,15,15,14,13,16,15,15,13,13,16,15,
+ 15,13,13,16,14,14,14,14,16,15,15,13,13,16,14,15,
+ 13,13,17,15,15,13,13,17,15,15,13,13,16,14,14,14,
+ 14,17,15,15,12,12,17,14,15,13,13,17,15,15,12,12,
+ 16,15,15,13,13,17,14,14,14,14,17,15,15,12,12,17,
+ 15,15,13,13,16,15,15,12,12,14,15,15, 8, 8,14,14,
+ 14,19,18,14,15,15,19,20,14,14,14,19,19,14,14,15,
+ 19,20,15,16,15,19,21,15,16,16,21,19,15,15,15,20,
+ 19,15,16,16,19,20,15,15,15,19,18,15,16,15,20,19,
+ 15,16,16,19,20,15,15,15,19,19,15,16,15,20,20,14,
+ 15,15,19,19,15,15,15,21,19,15,17,16,19,20,15,14,
+ 15, 0,21,15,15,15,19,20,14,14,14,19,19,15,15,15,
+ 20,19,15,16,16,19,19,15,15,15,19,18,15,15,15,20,
+ 19,14,14,15,18,18,14,12,12, 9, 9,14,14,14,18,18,
+ 14,14,14,18,18,14,15,14,19,18,14,14,14,19,18,15,
+ 15,15,19,20,15,14,14,18,18,15,15,15,20,19,15,15,
+ 15,18,20,15,15,15,19,18,15,15,15,19,19,15,14,14,
+ 19,21,15,15,15,20,20,15,15,15,18,19,14,15,15,19,
+ 20,15,15,15,20,19,15,14,14,19,21,15,15,15,18,19,
+ 15,14,15,20,19,14,15,15,21,21,14,15,15,19,20,15,
+ 14,14,19,20,15,15,15,19,20,15,15,14,20,20,14,15,
+ 15,20,19,13,12,12,13,13,17,16,16,11,11,17,16,16,
+ 12,12,18,17,16,11,11,18,16,16,11,11,17,17,17,13,
+ 13,18,16,16,13,13,18,17,17,12,12,18,16,16,13,13,
+ 18,17,17,12,12,18,17,17,13,13,18,16,16,14,14,18,
+ 16,17,12,12,18,17,17,13,13,17,17,17,12,12,17,17,
+ 17,12,12,17,16,15,13,13,18,16,16,11,11,17,16,16,
+ 12,12,17,16,17,11,11,18,17,17,13,12,17,16,16,13,
+ 13,17,17,17,12,12,17,16,17,12,12,18,17,17,11,11,
+ 14,14,14, 9, 9,16,14,14,13,13,17,15,15,14,14,17,
+ 14,14,13,13,16,14,14,13,13,17,15,15,14,14,16,16,
+ 16,16,15,18,15,15,14,14,17,16,15,15,15,17,15,15,
+ 14,14,17,15,15,14,15,16,16,16,15,16,18,15,15,14,
+ 14,17,15,15,14,15,17,15,15,14,14,17,15,15,14,14,
+ 16,16,16,15,16,17,14,14,13,13,17,15,15,14,14,18,
+ 15,15,13,13,17,15,15,14,14,16,16,16,15,15,17,14,
+ 14,13,13,17,15,15,14,14,17,14,14,13,13,13,11,11,
+ 11,11,16,14,14,12,12,16,14,14,12,13,17,15,14,11,
+ 11,17,14,14,11,11,17,15,15,13,14,17,14,14,14,14,
+ 17,15,15,13,13,17,14,14,13,13,17,15,15,13,13,17,
+ 15,15,13,13,17,14,14,14,14,17,15,15,13,13,18,14,
+ 15,13,13,17,15,15,13,13,16,15,15,13,13,17,14,14,
+ 13,13,17,15,15,12,12,16,14,14,12,12,16,15,15,12,
+ 12,17,16,15,13,13,17,14,14,13,13,17,15,15,12,12,
+ 16,15,15,12,12,16,15,15,12,12,13,15,15, 8, 8,14,
+ 14,14,18,19,14,15,15,19,20,14,14,14,18,18,14,15,
+ 15,18,18,15,16,16,19,19,15,16,17,20,20,15,15,15,
+ 19,19,15,16,16,18,20,15,15,15,19,19,15,15,16,18,
+ 18,15,17,16,19,19,15,15,15,18,21,15,16,16,21,20,
+ 15,15,15,19,21,15,16,15,20,19,15,16,17,20,20,15,
+ 15,15,19,19,15,16,16,21,20,15,15,15,19,20,15,15,
+ 15,19,19,15,16,16,20,19,15,15,15,19,19,15,16,15,
+ 20,21,15,15,15,21,19,14,12,12, 8, 8,14,14,14,20,
+ 18,14,13,13,19,19,14,14,14,19,18,15,14,14,19,20,
+ 14,15,15,20,20,15,14,14,21,20,15,15,15,20,20,15,
+ 15,14,21,19,15,15,15,19,19,15,15,15,19,20,15,14,
+ 14,20,20,15,15,15,19,20,15,14,14,19,20,15,15,15,
+ 20,20,15,15,15,20,19,15,14,14,20,21,15,15,15,20,
+ 21,15,14,14,20, 0,15,16,15,20,21,15,15,15,19,20,
+ 15,14,14,19,19,15,15,15,19,20,15,15,15,19,19,15,
+ 15,15,18,20,13,12,12,13,13,18,16,17,12,12,17,16,
+ 16,12,12,17,17,16,11,11,18,16,16,11,11,17,17,18,
+ 13,13,18,16,16,14,14,18,17,17,13,13,18,16,16,13,
+ 13,18,17,17,12,12,17,17,16,13,13,17,16,16,13,14,
+ 18,17,17,12,12,18,16,16,12,13,17,16,17,12,12,17,
+ 18,17,13,13,18,16,16,13,13,18,17,17,12,12,17,16,
+ 16,12,12,17,17,17,11,11,17,16,17,12,12,17,16,16,
+ 13,13,17,16,16,11,11,17,16,16,12,12,18,16,17,11,
+ 11,14,14,14, 9, 9,16,14,15,13,13,17,15,15,14,14,
+ 17,14,14,12,12,16,14,14,13,13,18,15,15,15,15,17,
+ 15,16,15,16,18,15,15,14,14,17,15,16,15,15,17,15,
+ 15,14,14,18,15,15,14,14,16,16,16,16,15,17,15,15,
+ 14,14,16,15,15,14,14,17,15,15,14,14,17,15,15,14,
+ 14,17,16,16,15,15,17,15,14,13,13,17,15,15,14,14,
+ 17,15,15,13,13,17,15,15,14,14,16,16,16,15,15,18,
+ 15,14,14,14,17,15,15,14,14,18,15,15,13,13,13,12,
+ 12,11,11,16,14,14,12,12,16,14,14,13,13,17,15,15,
+ 12,12,17,14,14,12,12,17,15,15,14,14,17,14,14,14,
+ 14,17,15,15,13,13,17,15,14,13,13,17,15,15,13,13,
+ 17,15,15,13,13,16,14,14,14,14,17,15,15,13,13,16,
+ 14,14,13,13,16,15,15,13,13,17,15,16,13,13,17,14,
+ 14,14,13,17,15,15,12,12,16,15,14,12,12,17,15,15,
+ 12,12,16,15,16,13,13,16,14,14,14,13,17,15,15,12,
+ 12,16,14,14,12,12,17,15,15,12,12,14,15,15, 8, 8,
+ 14,14,14,18,18,14,15,15,19,18,14,14,14,18,18,14,
+ 15,15,19,20,15,16,15,21,18,15,16,16,18, 0,15,15,
+ 15,19,20,15,16,16,20, 0,15,16,15,19,18,15,15,15,
+ 19,19,15,16,16,21,19,15,15,15,19,19,15,16,16,20,
+ 20,15,15,15,19,19,15,15,15,19,18,15,16,16,20,20,
+ 15,14,15,20,19,15,15,15,19,20,15,15,15,19,19,15,
+ 16,15,19,20,15,16,16,19,20,15,15,15,19,19,15,16,
+ 15,20,20,15,15,15,20,18,13,12,12, 8, 8,14,14,14,
+ 19,20,14,14,14,19,19,14,15,15,20,20,14,14,14,18,
+ 19,15,15,15,20, 0,15,14,14,18,20,15,15,15,19,19,
+ 15,15,15,21,19,15,15,15,19,20,15,15,15,20,21,15,
+ 14,14,20,19,15,15,15,20,19,15,15,14,21,19,15,15,
+ 15,19,18,15,15,15,20,19,15,14,14,19,19,15,15,16,
+ 20,19,15,15,15,20, 0,15,15,15,19,21,15,15,15,22,
+ 20,15,14,14,22,19,15,15,15,19,20,15,14,14,20,19,
+ 14,15,15,19,21,
+};
+
+static const static_codebook _44pn1_p3_1 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44pn1_p3_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44pn1_p3_1,
+ 0
+};
+
+static const long _vq_quantlist__44pn1_p4_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44pn1_p4_0[] = {
+ 1, 7, 7,14,14, 6, 8, 8,15,16, 7, 8, 8,16,15, 0,
+ 14,14,17,17, 0,14,14,16,16, 7, 9, 9,16,16,10,11,
+ 11,17,18, 9, 8, 8,16,16, 0,14,14,19,19, 0,14,14,
+ 17,16, 8, 9, 9,16,16,12,12,12,17,17,10, 9, 9,16,
+ 16, 0,15,14,18,20, 0,14,14,17,17, 0,15,15,18,17,
+ 0,21, 0, 0,21, 0,13,13,17,17, 0,17,17, 0, 0, 0,
+ 15,15,17,17, 0,15,15,17,18, 0, 0, 0, 0,21, 0,13,
+ 13,17,17, 0,18,18, 0,21, 0,16,15,17,18, 6, 7, 7,
+ 14,14, 9,10,10,16,16,11,10,10,15,15, 0,21, 0,20,
+ 21, 0, 0, 0,18,20,10,10,10,15,16,12,13,13,18,18,
+ 12,11,11,15,15, 0, 0, 0,20,20, 0, 0,21,19,19,12,
+ 11,11,15,15,15,14,14,18,18,13,11,11,15,16, 0, 0,
+ 0,20,19, 0, 0, 0,20,21, 0, 0,20,19,19, 0, 0, 0,
+ 0, 0, 0,20, 0,17,18, 0, 0,21, 0, 0, 0, 0, 0,21,
+ 0, 0,21, 0,20,19, 0, 0, 0, 0, 0, 0,21, 0,18,18,
+ 0, 0, 0,21, 0, 0, 0, 0, 0,20, 7, 6, 6,13,13, 9,
+ 6, 6,12,12, 9, 7, 7,14,14, 0,10,10,12,12, 0,11,
+ 11,15,15, 9, 7, 7,14,14,12, 9, 9,14,14,10, 7, 7,
+ 14,13, 0,11,11,16,15, 0,11,11,14,14, 9, 7, 7,14,
+ 14,13,10,10,14,14,11, 7, 7,14,13, 0,11,11,16,16,
+ 0,11,11,14,14, 0,12,12,16,16, 0,19, 0,17,18, 0,
+ 10,10,14,14, 0,15,14, 0, 0, 0,12,12,14,14, 0,12,
+ 12,15,15, 0,20, 0,18,19, 0,10,10,14,14, 0,16,15,
+ 0,20, 0,13,13,14,14, 0,11,11,13,13, 0,12,13,16,
+ 16, 0,12,12,16,16, 0,16,16, 0,21, 0,17,18, 0, 0,
+ 0,12,12,16,16, 0,15,15,18, 0, 0,12,12,16,16, 0,
+ 17,16,21,21, 0,16,17, 0, 0, 0,13,13,17,16, 0,16,
+ 16,20,21, 0,12,12,17,16, 0,17,17, 0,21, 0,17,17,
+ 21,21, 0,17,18, 0, 0, 0, 0, 0, 0, 0, 0,15,15, 0,
+ 0, 0,18,21, 0, 0, 0,18,19, 0, 0, 0,18,17,21,21,
+ 0, 0, 0, 0, 0, 0,16,16, 0, 0, 0, 0, 0, 0, 0, 0,
+ 19,19, 0, 0, 0,11,11,12,12, 0,11,11,10,10, 0,12,
+ 12,13,13, 0,12,12, 9, 9, 0,14,14,13,13, 0,12,12,
+ 13,13, 0,14,14,12,13, 0,11,11,12,12, 0,13,13,13,
+ 13, 0,13,13,13,13, 0,12,12,13,13, 0,14,14,12,12,
+ 0,11,11,12,12, 0,14,13,14,14, 0,13,13,13,13, 0,
+ 15,15,14,15, 0, 0, 0,16,16, 0,12,12,13,13, 0,16,
+ 17,20,21, 0,14,13,12,12, 0,14,14,14,14, 0,21, 0,
+ 16,16, 0,12,12,13,13, 0,18,17,21, 0, 0,14,14,13,
+ 13, 7, 8, 8,17,17,11,10,10,18,18,12,10,10,17,17,
+ 0,15,15,20,18, 0,15,15,17,17,11, 9, 9,17,17,14,
+ 12,12,19,19,13, 9, 9,16,16, 0,15,14, 0,19, 0,14,
+ 14,16,16,12,10,10,20,18,16,13,13,21,20,14,10,10,
+ 17,17, 0,15,15,21,20, 0,15,14,17,17, 0,15,15,21,
+ 21, 0, 0,21, 0, 0, 0,13,13,18,18, 0,19,16, 0, 0,
+ 0,15,15,17,16, 0,16,16, 0,21, 0, 0, 0, 0,21, 0,
+ 13,14,18,17, 0,20,19, 0, 0, 0,15,15,18,18, 8, 7,
+ 7,15,15,12,11,11,17,16,13,11,11,16,16, 0, 0, 0,
+ 21,20, 0, 0, 0, 0,20,11,10,10,17,17,14,13,13,19,
+ 18,14,11,11,16,16, 0,20, 0,21,19, 0, 0,21, 0,20,
+ 12,11,11,17,17,16,15,15, 0,19,14,11,11,17,16, 0,
+ 21, 0, 0,19, 0, 0, 0,21,20, 0, 0,21,20, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,19,21, 0, 0, 0, 0, 0, 0, 0, 0,
+ 19,20, 0, 0, 0,20,21, 0, 0, 0, 0, 0, 0,20, 0,19,
+ 21, 0, 0, 0, 0, 0, 0, 0, 0,21,20,11,10, 9,15,15,
+ 14,11,11,15,15,14,11,11,16,16, 0,14,14,14,14, 0,
+ 16,15,17,16,13,11,11,16,16,16,13,13,16,16,15,10,
+ 10,15,15, 0,14,15,17,17, 0,14,14,16,15,13,11,11,
+ 16,16,17,15,14,16,16,15,10,10,15,15, 0,15,15,17,
+ 18, 0,15,15,16,16, 0,16,16,17,17, 0,21, 0,21,20,
+ 0,13,13,15,15, 0,18,18, 0,21, 0,15,15,15,15, 0,
+ 16,16,17,17, 0, 0, 0, 0,18, 0,13,13,15,15, 0,19,
+ 18, 0, 0, 0,15,15,16,16, 0,12,12,15,15, 0,13,13,
+ 17,17, 0,13,13,17,18, 0,16,17,21, 0, 0,20,18, 0,
+ 0, 0,13,13,17,17, 0,15,15, 0,18, 0,12,12,17,18,
+ 0,16,16, 0, 0, 0,17,17,21, 0, 0,13,13,18,18, 0,
+ 16,16,21,21, 0,12,12,17,18, 0,16,17,21, 0, 0,17,
+ 17, 0,21, 0,17,18, 0, 0, 0, 0, 0, 0, 0, 0,16,15,
+ 0,21, 0,21,19, 0, 0, 0,18,18, 0, 0, 0,18,19, 0,
+ 0, 0, 0, 0, 0, 0, 0,16,16,21,21, 0,20,19, 0, 0,
+ 0,19,21, 0,21, 0,12,12,15,15, 0,12,12,15,16, 0,
+ 13,13,16,16, 0,14,14,15,15, 0,16,15,17,17, 0,13,
+ 13,17,17, 0,15,15,16,18, 0,12,12,16,16, 0,14,14,
+ 17,17, 0,15,14,16,16, 0,13,13,16,16, 0,16,15,17,
+ 17, 0,12,12,16,16, 0,15,15,18,18, 0,14,14,17,16,
+ 0,16,16,17,18, 0, 0, 0,20,21, 0,13,13,16,17, 0,
+ 17,17, 0, 0, 0,15,15,16,16, 0,15,16,17,17, 0, 0,
+ 0,19, 0, 0,13,13,15,16, 0,19,18, 0, 0, 0,16,15,
+ 16,17, 8, 8, 8,17,17,13,11,10,17,18,13,10,10,17,
+ 17, 0,15,15,20,19, 0,15,15,17,17,12,10,10,19,18,
+ 15,12,12,20,18,14,10,10,17,16, 0,15,15,20,20, 0,
+ 14,15,16,16,13,10,10,17,17,17,14,14, 0,18,15,10,
+ 10,17,17, 0,16,15,20,20, 0,14,14,17,17, 0,15,16,
+ 20,20, 0, 0,21, 0, 0, 0,13,13,17,17, 0,18,17, 0,
+ 0, 0,15,16,17,18, 0,15,15,18,21, 0, 0, 0,21, 0,
+ 0,13,13,18,18, 0,19,19, 0, 0, 0,16,16,18,17, 9,
+ 8, 8,15,15,12,11,11,16,16,13,11,11,16,15, 0, 0,
+ 0, 0,21, 0,21, 0,19,19,12,11,11,17,18,15,13,13,
+ 18,19,14,11,11,16,16, 0, 0,21,21,19, 0, 0, 0,21,
+ 20,13,11,11,18,17,17,14,15,20,21,15,11,12,16,16,
+ 0, 0, 0,20, 0, 0, 0,21, 0,19, 0, 0, 0, 0,19, 0,
+ 0, 0, 0, 0, 0,21,21,19,19, 0, 0, 0,21, 0, 0, 0,
+ 0,19,21, 0, 0, 0,19,20, 0, 0, 0,21, 0, 0, 0,21,
+ 19,19, 0, 0, 0, 0, 0, 0, 0, 0,21,20, 0,11,11,15,
+ 15, 0,12,12,15,16, 0,12,12,16,16, 0,15,15,16,15,
+ 0,16,16,17,17, 0,12,12,17,17, 0,14,14,17,17, 0,
+ 11,11,16,16, 0,15,15,19,18, 0,15,15,16,16, 0,12,
+ 12,17,16, 0,14,15,16,16, 0,11,11,15,15, 0,16,16,
+ 18,19, 0,15,15,15,16, 0,17,17,18,20, 0,21, 0,21,
+ 19, 0,14,14,16,16, 0,18,18, 0, 0, 0,16,16,15,15,
+ 0,16,16,18,17, 0, 0, 0,19,20, 0,14,14,16,16, 0,
+ 19,19, 0, 0, 0,16,17,15,15, 0,12,12,14,15, 0,13,
+ 13,16,17, 0,12,12,17,17, 0,17,16, 0, 0, 0,18,17,
+ 21, 0, 0,13,13,19,17, 0,15,15,20,21, 0,12,12,17,
+ 17, 0,17,17, 0, 0, 0,17,17, 0, 0, 0,13,13,17,18,
+ 0,16,16,21, 0, 0,12,12,17,17, 0,17,17, 0, 0, 0,
+ 17,17, 0, 0, 0,18,21, 0, 0, 0, 0, 0, 0, 0, 0,15,
+ 15,21, 0, 0,20,21, 0, 0, 0,18,19, 0, 0, 0,18,17,
+ 0, 0, 0, 0, 0, 0, 0, 0,16,16,21, 0, 0,21,21, 0,
+ 0, 0,18,19, 0, 0, 0,12,12,16,16, 0,13,13,16,17,
+ 0,13,13,17,16, 0,14,14,16,16, 0,16,15,19,18, 0,
+ 13,13,17,17, 0,15,15,18,18, 0,12,12,16,16, 0,15,
+ 15,18,19, 0,15,15,17,16, 0,13,13,17,17, 0,16,16,
+ 18,17, 0,12,12,17,16, 0,15,15,18,18, 0,15,15,17,
+ 17, 0,16,16, 0,19, 0, 0, 0, 0, 0, 0,14,14,16,17,
+ 0,18,18, 0, 0, 0,15,15,17,17, 0,16,16,21,19, 0,
+ 21, 0,21,21, 0,13,14,16,16, 0,19,19, 0, 0, 0,15,
+ 16,16,16, 0,11,11,17,16, 0,15,14,19,18, 0,14,14,
+ 19,19, 0,18,17,18,20, 0,17,17,18,19, 0,13,13,17,
+ 17, 0,16,17,21,18, 0,13,13,17,16, 0,18,17,19, 0,
+ 0,16,17,18,18, 0,12,12,19,18, 0,18,18,20,20, 0,
+ 13,13,17,17, 0,17,17,21, 0, 0,16,17,17,18, 0,18,
+ 17,19,18, 0, 0, 0, 0, 0, 0,14,14,17,17, 0,19,19,
+ 21, 0, 0,16,16,16,17, 0,17,17,19,20, 0, 0, 0, 0,
+ 21, 0,15,15,17,18, 0,21,21, 0, 0, 0,17,17,17,18,
+ 0,10,10,15,15, 0,15,14,17,18, 0,14,14,16,16, 0,
+ 0, 0,18, 0, 0,21, 0,19, 0, 0,13,13,17,16, 0,17,
+ 17,18, 0, 0,14,14,16,15, 0, 0, 0,21, 0, 0,21, 0,
+ 19,18, 0,13,13,17,17, 0,18,18,20,20, 0,15,15,16,
+ 16, 0, 0, 0,21,21, 0, 0, 0,20,20, 0, 0, 0,19, 0,
+ 0, 0, 0, 0, 0, 0,21,20,18,18, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0,20, 0, 0, 0, 0,20, 0, 0, 0, 0, 0, 0, 0,
+ 0,19,18, 0, 0, 0, 0,21, 0, 0, 0,18,20, 0,18,19,
+ 16,17, 0,21,19,17,17, 0, 0,21,18,18, 0, 0,21,20,
+ 19, 0, 0, 0,20,20, 0, 0,21,17,17, 0, 0, 0,19,19,
+ 0,20,20,17,17, 0, 0, 0, 0,20, 0, 0,20,18,18, 0,
+ 21,20,17,17, 0, 0, 0,20,21, 0,19, 0,17,17, 0, 0,
+ 21, 0, 0, 0,20, 0,18,19, 0, 0, 0,21,21, 0, 0, 0,
+ 0,21, 0,20,20,17,17, 0, 0, 0, 0, 0, 0,21, 0,18,
+ 17, 0, 0, 0,20,19, 0, 0, 0, 0,21, 0,20,20,17,17,
+ 0, 0, 0, 0, 0, 0,21,21,18,18, 0,12,12,15,14, 0,
+ 14,14,17,17, 0,14,14,17,16, 0,18,18,21, 0, 0,19,
+ 20, 0, 0, 0,13,13,18,17, 0,16,16,19,18, 0,13,13,
+ 17,17, 0,17,17, 0, 0, 0,17,17,21, 0, 0,13,13,17,
+ 17, 0,17,17,21,20, 0,13,13,18,17, 0,18,19,21,21,
+ 0,19,18, 0, 0, 0,18,17, 0, 0, 0, 0, 0, 0, 0, 0,
+ 15,16, 0, 0, 0,21,21, 0, 0, 0,20,18,21, 0, 0,17,
+ 18, 0, 0, 0, 0, 0, 0, 0, 0,15,16, 0, 0, 0, 0,20,
+ 0, 0, 0, 0,19, 0, 0, 0,15,15,18,19, 0,18,17,21,
+ 0, 0,16,18, 0,20, 0,17,18,21, 0, 0,18,20, 0, 0,
+ 0,16,16,21,21, 0,19,20,21, 0, 0,16,15, 0,21, 0,
+ 18,20, 0, 0, 0,18,19, 0, 0, 0,16,15,21,21, 0,21,
+ 0, 0, 0, 0,16,15,21, 0, 0,20,19, 0, 0, 0,18,21,
+ 21, 0, 0,20,18, 0, 0, 0, 0, 0, 0, 0, 0,16,16, 0,
+ 20, 0,21, 0, 0, 0, 0,17,18,20,21, 0,18,18,21,21,
+ 0, 0, 0, 0, 0, 0,16,16,20, 0, 0, 0,21, 0, 0, 0,
+ 21,18, 0, 0, 0,12,12,20,17, 0,15,15,19,18, 0,14,
+ 14,19,18, 0,18,17,21,19, 0,17,17,21,17, 0,13,13,
+ 21,19, 0,16,17,20,19, 0,13,13,16,16, 0,17,17,20,
+ 21, 0,16,16,19,17, 0,13,13,18,18, 0,17,19,19,19,
+ 0,13,13,17,17, 0,18,18, 0,19, 0,16,17,18,18, 0,
+ 16,17,19,21, 0, 0, 0, 0, 0, 0,15,15,16,17, 0,20,
+ 19,21, 0, 0,17,17,17,17, 0,17,17,21,19, 0, 0, 0,
+ 0, 0, 0,15,15,17,17, 0,21, 0, 0, 0, 0,18,18,17,
+ 17, 0,10,10,15,15, 0,15,15,17,17, 0,15,14,16,16,
+ 0, 0, 0,21,19, 0,21,21,19,21, 0,13,13,17,16, 0,
+ 17,17,18,19, 0,14,15,16,15, 0, 0, 0,21,19, 0,21,
+ 21,18,19, 0,14,14,16,17, 0,18,18,18,19, 0,15,15,
+ 15,16, 0, 0,21, 0,21, 0, 0, 0,19,20, 0, 0, 0,21,
+ 19, 0, 0, 0, 0, 0, 0,21,21,19,17, 0, 0, 0, 0, 0,
+ 0, 0, 0,21,21, 0,21, 0, 0,21, 0, 0, 0, 0, 0, 0,
+ 21,21,19,18, 0, 0, 0, 0, 0, 0, 0, 0, 0,19, 0,21,
+ 18,18,17, 0,21, 0,20,20, 0, 0, 0,18,20, 0, 0,21,
+ 18,21, 0, 0, 0,21,18, 0, 0, 0, 0,19, 0, 0, 0,21,
+ 21, 0,20,21,17,19, 0,21, 0,21, 0, 0,21, 0,18,18,
+ 0,20,21,17,18, 0, 0, 0,21,19, 0,20,21,17,18, 0,
+ 0, 0,21,21, 0, 0, 0,20,19, 0, 0, 0,21,21, 0, 0,
+ 0, 0, 0, 0,21,21,19,18, 0, 0, 0, 0, 0, 0, 0,21,
+ 19,18, 0,21,21,19, 0, 0, 0, 0,21, 0, 0,21,21,18,
+ 17, 0, 0, 0, 0, 0, 0,21, 0,21,18, 0,12,12,14,14,
+ 0,15,14,17,17, 0,14,14,17,16, 0,19,17, 0, 0, 0,
+ 19,19, 0, 0, 0,13,13,17,17, 0,17,17,20,20, 0,13,
+ 13,18,18, 0,18,17, 0, 0, 0,18,21, 0, 0, 0,13,13,
+ 17,17, 0,18,18,21,20, 0,14,14,18,19, 0,19,18,21,
+ 0, 0,19,19, 0, 0, 0,20,18,20, 0, 0, 0, 0, 0, 0,
+ 0,15,16, 0, 0, 0,21,21, 0, 0, 0,19,19, 0, 0, 0,
+ 18,18, 0, 0, 0, 0, 0, 0, 0, 0,16,16, 0,21, 0, 0,
+ 0, 0, 0, 0,19,20, 0, 0, 0,15,15,20,21, 0,17,17,
+ 21,21, 0,17,17, 0, 0, 0,19,18, 0, 0, 0,18,19, 0,
+ 0, 0,17,16, 0,21, 0, 0,20, 0, 0, 0,16,16, 0,20,
+ 0,19,19, 0,21, 0,19,18, 0,21, 0,16,16, 0, 0, 0,
+ 21,21, 0, 0, 0,16,16, 0, 0, 0,21,21, 0, 0, 0,19,
+ 19, 0, 0, 0,20, 0, 0, 0, 0, 0, 0, 0, 0, 0,17,17,
+ 0,21, 0, 0,20, 0, 0, 0,20,18,21,21, 0,19,18, 0,
+ 20, 0, 0, 0, 0, 0, 0,16,17,21, 0, 0, 0,21, 0, 0,
+ 0,19,20,21,20,
+};
+
+static const static_codebook _44pn1_p4_0 = {
+ 5, 3125,
+ (long *)_vq_lengthlist__44pn1_p4_0,
+ 1, -528744448, 1616642048, 3, 0,
+ (long *)_vq_quantlist__44pn1_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44pn1_p4_1[] = {
+ 3,
+ 2,
+ 4,
+ 1,
+ 5,
+ 0,
+ 6,
+};
+
+static const long _vq_lengthlist__44pn1_p4_1[] = {
+ 2, 3, 3, 3, 3, 3, 3,
+};
+
+static const static_codebook _44pn1_p4_1 = {
+ 1, 7,
+ (long *)_vq_lengthlist__44pn1_p4_1,
+ 1, -533200896, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44pn1_p4_1,
+ 0
+};
+
+static const long _vq_quantlist__44pn1_p5_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44pn1_p5_0[] = {
+ 1, 7, 7, 6, 8, 8, 7, 8, 8, 7, 9, 9,11,11,11, 9,
+ 8, 8, 7, 9, 9,11,12,11, 9, 9, 9, 6, 7, 7,10,11,
+ 11,10,10,10,10,11,11,15,14,14,12,12,12,11,11,11,
+ 14,14,14,12,12,12, 5, 6, 6, 8, 5, 5, 8, 7, 7, 8,
+ 8, 8,12,10,10,10, 7, 7, 8, 7, 7,12,10,10,10, 7,
+ 7, 6, 7, 7,12,11,11,12,10,10,11,10,10,14,14,13,
+ 13,10,10,11,10,10,16,14,14,14,11,10, 7, 7, 7,13,
+ 12,12,12,12,11,11,11,11,15,14,17,13,12,12,12,11,
+ 11,15,15,15,14,13,13,10, 9, 9,14,12,11,13,11,11,
+ 12,11,11,16,15,14,14,11,11,12,11,11,17,14,14,15,
+ 11,11, 7, 8, 8,12,11,11,13,10,10,11,10,10,17,14,
+ 13,14,10,10,12,10,10,18,15,15,14,10,10, 8, 7, 7,
+ 13,12,12,13,11,11,12,11,11,16,14,15,14,12,12,12,
+ 11,11,18,16,16,14,12,12,11,10,10,13,12,11,13,11,
+ 11,13,12,12, 0,15,14,14,11,11,13,11,11,16,15,15,
+ 15,11,11,
+};
+
+static const static_codebook _44pn1_p5_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44pn1_p5_0,
+ 1, -527106048, 1620377600, 2, 0,
+ (long *)_vq_quantlist__44pn1_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44pn1_p5_1[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44pn1_p5_1[] = {
+ 2, 6, 7, 6, 8, 8, 7, 7, 8, 7, 8, 8, 9, 9, 9, 8,
+ 7, 7, 8, 8, 8, 9, 9, 9, 9, 8, 8, 6, 6, 6, 9, 7,
+ 7, 9, 7, 7, 9, 8, 8,10, 8, 8,10, 8, 8,10, 8, 8,
+ 10, 9, 8,10, 8, 8, 7, 6, 6, 9, 6, 6, 9, 6, 6, 9,
+ 7, 7,10, 8, 8,10, 6, 6, 9, 7, 7,10, 8, 8,10, 6,
+ 6, 7, 7, 7,11, 9, 9,11, 9, 9,10, 9, 9,12,10,10,
+ 12, 8, 8,11, 9, 9,13, 9,10,12, 8, 8, 8, 7, 7,11,
+ 9,10,11,10,10,10, 9, 9,11,11,11,11, 9, 9,11,10,
+ 9,12,11,11,11, 9,10,10, 8, 8,11, 9,10,11, 9, 9,
+ 11, 9, 9,12,10,10,11, 9, 9,11, 9, 9,12,10,11,11,
+ 9, 9, 8, 8, 8,12, 9, 9,12, 9, 9,11, 9, 9,13, 9,
+ 9,13, 8, 8,12, 9, 9,13,10,10,12, 8, 8, 9, 7, 7,
+ 11,10,10,11,10,10,11,10,10,12,11,11,11,10, 9,11,
+ 10,10,11,11,11,11, 9, 9,11, 9, 9,12,10,10,11,10,
+ 10,12,10,10,11,11,11,11, 9, 9,11,10,10,12,11,11,
+ 11, 9, 9,
+};
+
+static const static_codebook _44pn1_p5_1 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44pn1_p5_1,
+ 1, -530841600, 1616642048, 2, 0,
+ (long *)_vq_quantlist__44pn1_p5_1,
+ 0
+};
+
+static const long _vq_quantlist__44pn1_p6_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44pn1_p6_0[] = {
+ 1, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9,
+};
+
+static const static_codebook _44pn1_p6_0 = {
+ 5, 243,
+ (long *)_vq_lengthlist__44pn1_p6_0,
+ 1, -516716544, 1630767104, 2, 0,
+ (long *)_vq_quantlist__44pn1_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44pn1_p6_1[] = {
+ 12,
+ 11,
+ 13,
+ 10,
+ 14,
+ 9,
+ 15,
+ 8,
+ 16,
+ 7,
+ 17,
+ 6,
+ 18,
+ 5,
+ 19,
+ 4,
+ 20,
+ 3,
+ 21,
+ 2,
+ 22,
+ 1,
+ 23,
+ 0,
+ 24,
+};
+
+static const long _vq_lengthlist__44pn1_p6_1[] = {
+ 1, 3, 2, 5, 4, 7, 7, 8, 8, 9, 9,10,10,11,11,12,
+ 12,13,13,14,14,15,15,15,15,
+};
+
+static const static_codebook _44pn1_p6_1 = {
+ 1, 25,
+ (long *)_vq_lengthlist__44pn1_p6_1,
+ 1, -518864896, 1620639744, 5, 0,
+ (long *)_vq_quantlist__44pn1_p6_1,
+ 0
+};
+
+static const long _vq_quantlist__44pn1_p6_2[] = {
+ 12,
+ 11,
+ 13,
+ 10,
+ 14,
+ 9,
+ 15,
+ 8,
+ 16,
+ 7,
+ 17,
+ 6,
+ 18,
+ 5,
+ 19,
+ 4,
+ 20,
+ 3,
+ 21,
+ 2,
+ 22,
+ 1,
+ 23,
+ 0,
+ 24,
+};
+
+static const long _vq_lengthlist__44pn1_p6_2[] = {
+ 3, 5, 4, 5, 4, 5, 4, 5, 5, 5, 4, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5,
+};
+
+static const static_codebook _44pn1_p6_2 = {
+ 1, 25,
+ (long *)_vq_lengthlist__44pn1_p6_2,
+ 1, -529006592, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44pn1_p6_2,
+ 0
+};
+
+static const long _huff_lengthlist__44pn1_short[] = {
+ 4, 3, 7, 9,12,16,16, 3, 2, 5, 7,11,14,15, 7, 4,
+ 5, 6, 9,12,15, 8, 5, 5, 5, 8,10,14, 9, 7, 6, 6,
+ 8,10,12,12,10,10, 7, 6, 8,10,15,12,10, 6, 4, 7,
+ 9,
+};
+
+static const static_codebook _huff_book__44pn1_short = {
+ 2, 49,
+ (long *)_huff_lengthlist__44pn1_short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2007 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: static codebooks autogenerated by huff/huffbuld
+ last modified: $Id: res_books_stereo.h 17025 2010-03-25 04:56:56Z xiphmont $
+
+ ********************************************************************/
+
+#include "codebook.h"
+
+static const long _vq_quantlist__16c0_s_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__16c0_s_p1_0[] = {
+ 1, 4, 4, 0, 0, 0, 0, 0, 0, 5, 7, 7, 0, 0, 0, 0,
+ 0, 0, 5, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 5, 8, 8, 0, 0, 0, 0, 0, 0, 8, 9,10, 0, 0, 0,
+ 0, 0, 0, 7, 9,10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 5, 8, 8, 0, 0, 0, 0, 0, 0, 7, 9, 9, 0, 0,
+ 0, 0, 0, 0, 7, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 8, 8, 0, 0, 0, 0,
+ 0, 0, 8,10,10, 0, 0, 0, 0, 0, 0, 8,10,10, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7,10,10, 0, 0, 0,
+ 0, 0, 0, 9, 9,12, 0, 0, 0, 0, 0, 0,10,12,11, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7,10,10, 0, 0,
+ 0, 0, 0, 0, 9,12,10, 0, 0, 0, 0, 0, 0,10,11,12,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 5, 8, 8, 0, 0, 0, 0, 0, 0, 8,10,10, 0, 0,
+ 0, 0, 0, 0, 8,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 7,10,10, 0, 0, 0, 0, 0, 0,10,12,11, 0,
+ 0, 0, 0, 0, 0, 9,10,12, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 7,10,10, 0, 0, 0, 0, 0, 0,10,11,12,
+ 0, 0, 0, 0, 0, 0, 9,12, 9, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _16c0_s_p1_0 = {
+ 8, 6561,
+ (long *)_vq_lengthlist__16c0_s_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__16c0_s_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__16c0_s_p3_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__16c0_s_p3_0[] = {
+ 1, 4, 4, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 6, 6, 7, 6, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 4, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 9, 9,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 6, 6, 6, 9, 9, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _16c0_s_p3_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__16c0_s_p3_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__16c0_s_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__16c0_s_p4_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__16c0_s_p4_0[] = {
+ 1, 3, 2, 7, 8, 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0,
+ 0, 0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0, 0, 7, 7,
+ 0, 0, 0, 0, 0, 0, 0, 7, 7, 0, 0, 0, 0, 0, 0, 0,
+ 8, 8, 0, 0, 0, 0, 0, 0, 0, 8, 8, 0, 0, 0, 0, 0,
+ 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _16c0_s_p4_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__16c0_s_p4_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__16c0_s_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__16c0_s_p5_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__16c0_s_p5_0[] = {
+ 1, 3, 3, 6, 6, 6, 6, 8, 8, 0, 0, 0, 7, 7, 7, 7,
+ 8, 8, 0, 0, 0, 7, 7, 7, 7, 8, 8, 0, 0, 0, 7, 7,
+ 8, 8, 9, 9, 0, 0, 0, 7, 7, 8, 8, 9, 9, 0, 0, 0,
+ 8, 9, 8, 8,10,10, 0, 0, 0, 8, 8, 8, 8,10,10, 0,
+ 0, 0,10,10, 9, 9,10,10, 0, 0, 0, 0, 0, 9, 9,10,
+ 10,
+};
+
+static const static_codebook _16c0_s_p5_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__16c0_s_p5_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__16c0_s_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__16c0_s_p6_0[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__16c0_s_p6_0[] = {
+ 1, 3, 4, 6, 6, 7, 7, 8, 8, 8, 8, 9, 9,10,10,11,
+ 11, 0, 0, 0, 7, 7, 8, 8, 9, 9, 9, 9,10,10,10,11,
+ 11,11, 0, 0, 0, 6, 6, 8, 8, 9, 9, 9, 9,10,10,11,
+ 11,11,11, 0, 0, 0, 7, 7, 8, 8, 9, 9, 9, 9,10,10,
+ 11,11,12,12, 0, 0, 0, 7, 7, 8, 8, 9, 9, 9, 9,10,
+ 10,11,11,12,12, 0, 0, 0, 8, 8, 9, 9,10,10,10,10,
+ 11,11,12,12,12,12, 0, 0, 0, 8, 8, 9, 9,10,10,10,
+ 10,11,11,12,12,12,13, 0, 0, 0, 9, 9, 9, 9,10,10,
+ 10,10,11,11,12,12,13,13, 0, 0, 0, 0, 0,10,10,10,
+ 10,10,10,11,11,12,12,13,13, 0, 0, 0, 0, 0, 9, 9,
+ 10,10,11,11,12,12,13,13,13,13, 0, 0, 0, 0, 0, 9,
+ 9,10,10,11,11,12,12,13,13,13,14, 0, 0, 0, 0, 0,
+ 10,10,10,11,11,11,12,12,13,13,13,14, 0, 0, 0, 0,
+ 0, 0, 0,10,10,11,11,12,12,13,13,14,14, 0, 0, 0,
+ 0, 0, 0, 0,11,11,12,12,13,13,13,13,14,14, 0, 0,
+ 0, 0, 0, 0, 0,11,11,12,12,12,13,13,14,15,14, 0,
+ 0, 0, 0, 0, 0, 0,12,12,12,12,13,13,13,14,14,15,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,12,12,13,13,14,13,14,
+ 14,
+};
+
+static const static_codebook _16c0_s_p6_0 = {
+ 2, 289,
+ (long *)_vq_lengthlist__16c0_s_p6_0,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__16c0_s_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__16c0_s_p7_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__16c0_s_p7_0[] = {
+ 1, 4, 4, 6, 6, 6, 7, 6, 6, 4, 7, 7,11,10,10,11,
+ 11,10, 4, 7, 7,10,10,10,11,10,10, 6,10,10,11,11,
+ 11,11,11,10, 6, 9, 9,11,12,12,11, 9, 9, 6, 9,10,
+ 11,12,12,11, 9,10, 7,11,11,11,11,11,12,13,12, 6,
+ 9,10,11,10,10,12,13,13, 6,10, 9,11,10,10,11,12,
+ 13,
+};
+
+static const static_codebook _16c0_s_p7_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__16c0_s_p7_0,
+ 1, -529137664, 1618345984, 2, 0,
+ (long *)_vq_quantlist__16c0_s_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__16c0_s_p7_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__16c0_s_p7_1[] = {
+ 1, 3, 4, 6, 6, 7, 7, 8, 8, 8, 8,10,10,10, 7, 7,
+ 8, 8, 8, 9, 9, 9,10,10,10, 6, 7, 8, 8, 8, 8, 9,
+ 8,10,10,10, 7, 7, 8, 8, 9, 9, 9, 9,10,10,10, 7,
+ 7, 8, 8, 9, 9, 8, 9,10,10,10, 8, 8, 9, 9, 9, 9,
+ 9, 9,11,11,11, 8, 8, 9, 9, 9, 9, 9,10,10,11,11,
+ 9, 9, 9, 9, 9, 9, 9,10,11,11,11,10,11, 9, 9, 9,
+ 9,10, 9,11,11,11,10,11,10,10, 9, 9,10,10,11,11,
+ 11,11,11, 9, 9, 9, 9,10,10,
+};
+
+static const static_codebook _16c0_s_p7_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__16c0_s_p7_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__16c0_s_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__16c0_s_p8_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__16c0_s_p8_0[] = {
+ 1, 4, 4, 7, 7, 7, 7, 7, 6, 8, 8,10,10, 6, 5, 6,
+ 8, 8, 8, 8, 8, 8, 8, 9,10,10, 7, 6, 6, 8, 8, 8,
+ 8, 8, 8, 8, 8,10,10, 0, 8, 8, 8, 8, 9, 8, 9, 9,
+ 9,10,10,10, 0, 9, 8, 8, 8, 9, 9, 8, 8, 9, 9,10,
+ 10, 0,12,11, 8, 8, 9, 9, 9, 9,10,10,11,10, 0,12,
+ 13, 8, 8, 9,10, 9, 9,11,11,11,12, 0, 0, 0, 8, 8,
+ 8, 8,10, 9,12,13,12,14, 0, 0, 0, 8, 8, 8, 9,10,
+ 10,12,12,13,14, 0, 0, 0,13,13, 9, 9,11,11, 0, 0,
+ 14, 0, 0, 0, 0,14,14,10,10,12,11,12,14,14,14, 0,
+ 0, 0, 0, 0,11,11,13,13,14,13,14,14, 0, 0, 0, 0,
+ 0,12,13,13,12,13,14,14,14,
+};
+
+static const static_codebook _16c0_s_p8_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__16c0_s_p8_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__16c0_s_p8_0,
+ 0
+};
+
+static const long _vq_quantlist__16c0_s_p8_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__16c0_s_p8_1[] = {
+ 1, 4, 3, 5, 5, 7, 7, 7, 6, 6, 7, 7, 7, 5, 5, 7,
+ 7, 7, 6, 6, 7, 7, 7, 6, 6,
+};
+
+static const static_codebook _16c0_s_p8_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__16c0_s_p8_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__16c0_s_p8_1,
+ 0
+};
+
+static const long _vq_quantlist__16c0_s_p9_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__16c0_s_p9_0[] = {
+ 1, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7,
+};
+
+static const static_codebook _16c0_s_p9_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__16c0_s_p9_0,
+ 1, -518803456, 1628680192, 2, 0,
+ (long *)_vq_quantlist__16c0_s_p9_0,
+ 0
+};
+
+static const long _vq_quantlist__16c0_s_p9_1[] = {
+ 7,
+ 6,
+ 8,
+ 5,
+ 9,
+ 4,
+ 10,
+ 3,
+ 11,
+ 2,
+ 12,
+ 1,
+ 13,
+ 0,
+ 14,
+};
+
+static const long _vq_lengthlist__16c0_s_p9_1[] = {
+ 1, 5, 5, 5, 5, 9,11,11,10,10,10,10,10,10,10, 7,
+ 6, 6, 6, 6,10,10,10,10,10,10,10,10,10,10, 7, 6,
+ 6, 6, 6,10, 9,10,10,10,10,10,10,10,10,10, 7, 7,
+ 8, 9,10,10,10,10,10,10,10,10,10,10,10, 8, 7,10,
+ 10,10, 9,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,
+};
+
+static const static_codebook _16c0_s_p9_1 = {
+ 2, 225,
+ (long *)_vq_lengthlist__16c0_s_p9_1,
+ 1, -520986624, 1620377600, 4, 0,
+ (long *)_vq_quantlist__16c0_s_p9_1,
+ 0
+};
+
+static const long _vq_quantlist__16c0_s_p9_2[] = {
+ 10,
+ 9,
+ 11,
+ 8,
+ 12,
+ 7,
+ 13,
+ 6,
+ 14,
+ 5,
+ 15,
+ 4,
+ 16,
+ 3,
+ 17,
+ 2,
+ 18,
+ 1,
+ 19,
+ 0,
+ 20,
+};
+
+static const long _vq_lengthlist__16c0_s_p9_2[] = {
+ 1, 5, 5, 7, 8, 8, 7, 9, 9, 9,12,12,11,12,12,10,
+ 10,11,12,12,12,11,12,12, 8, 9, 8, 7, 9,10,10,11,
+ 11,10,11,12,10,12,10,12,12,12,11,12,11, 9, 8, 8,
+ 9,10, 9, 8, 9,10,12,12,11,11,12,11,10,11,12,11,
+ 12,12, 8, 9, 9, 9,10,11,12,11,12,11,11,11,11,12,
+ 12,11,11,12,12,11,11, 9, 9, 8, 9, 9,11, 9, 9,10,
+ 9,11,11,11,11,12,11,11,10,12,12,12, 9,12,11,10,
+ 11,11,11,11,12,12,12,11,11,11,12,10,12,12,12,10,
+ 10, 9,10, 9,10,10, 9, 9, 9,10,10,12,10,11,11, 9,
+ 11,11,10,11,11,11,10,10,10, 9, 9,10,10, 9, 9,10,
+ 11,11,10,11,10,11,10,11,11,10,11,11,11,10, 9,10,
+ 10, 9,10, 9, 9,11, 9, 9,11,10,10,11,11,10,10,11,
+ 10,11, 8, 9,11,11,10, 9,10,11,11,10,11,11,10,10,
+ 10,11,10, 9,10,10,11, 9,10,10, 9,11,10,10,10,10,
+ 11,10,11,11, 9,11,10,11,10,10,11,11,10,10,10, 9,
+ 10,10,11,11,11, 9,10,10,10,10,10,11,10,10,10, 9,
+ 10,10,11,10,10,10,10,10, 9,10,11,10,10,10,10,11,
+ 11,11,10,10,10,10,10,11,10,11,10,11,10,10,10, 9,
+ 11,11,10,10,10,11,11,10,10,10,10,10,10,10,10,11,
+ 11, 9,10,10,10,11,10,11,10,10,10,11, 9,10,11,10,
+ 11,10,10, 9,10,10,10,11,10,11,10,10,10,10,10,11,
+ 11,10,11,11,10,10,11,11,10, 9, 9,10,10,10,10,10,
+ 9,11, 9,10,10,10,11,11,10,10,10,10,11,11,11,10,
+ 9, 9,10,10,11,10,10,10,10,10,11,11,11,10,10,10,
+ 11,11,11, 9,10,10,10,10, 9,10, 9,10,11,10,11,10,
+ 10,11,11,10,11,11,11,11,11,10,11,10,10,10, 9,11,
+ 11,10,11,11,11,11,11,11,11,11,11,10,11,10,10,10,
+ 10,11,10,10,11, 9,10,10,10,
+};
+
+static const static_codebook _16c0_s_p9_2 = {
+ 2, 441,
+ (long *)_vq_lengthlist__16c0_s_p9_2,
+ 1, -529268736, 1611661312, 5, 0,
+ (long *)_vq_quantlist__16c0_s_p9_2,
+ 0
+};
+
+static const long _huff_lengthlist__16c0_s_single[] = {
+ 3, 4,19, 7, 9, 7, 8,11, 9,12, 4, 1,19, 6, 7, 7,
+ 8,10,11,13,18,18,18,18,18,18,18,18,18,18, 8, 6,
+ 18, 8, 9, 9,11,12,14,18, 9, 6,18, 9, 7, 8, 9,11,
+ 12,18, 7, 6,18, 8, 7, 7, 7, 9,11,17, 8, 8,18, 9,
+ 7, 6, 6, 8,11,17,10,10,18,12, 9, 8, 7, 9,12,18,
+ 13,15,18,15,13,11,10,11,15,18,14,18,18,18,18,18,
+ 16,16,18,18,
+};
+
+static const static_codebook _huff_book__16c0_s_single = {
+ 2, 100,
+ (long *)_huff_lengthlist__16c0_s_single,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__16c1_s_long[] = {
+ 2, 5,20, 7,10, 7, 8,10,11,11, 4, 2,20, 5, 8, 6,
+ 7, 9,10,10,20,20,20,20,19,19,19,19,19,19, 7, 5,
+ 19, 6,10, 7, 9,11,13,17,11, 8,19,10, 7, 7, 8,10,
+ 11,15, 7, 5,19, 7, 7, 5, 6, 9,11,16, 7, 6,19, 8,
+ 7, 6, 6, 7, 9,13, 9, 9,19,11, 9, 8, 6, 7, 8,13,
+ 12,14,19,16,13,10, 9, 8, 9,13,14,17,19,18,18,17,
+ 12,11,11,13,
+};
+
+static const static_codebook _huff_book__16c1_s_long = {
+ 2, 100,
+ (long *)_huff_lengthlist__16c1_s_long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__16c1_s_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__16c1_s_p1_0[] = {
+ 1, 5, 5, 0, 0, 0, 0, 0, 0, 5, 7, 7, 0, 0, 0, 0,
+ 0, 0, 5, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 5, 8, 7, 0, 0, 0, 0, 0, 0, 7, 9, 9, 0, 0, 0,
+ 0, 0, 0, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 5, 7, 8, 0, 0, 0, 0, 0, 0, 7, 9, 8, 0, 0,
+ 0, 0, 0, 0, 7, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 8, 7, 0, 0, 0, 0,
+ 0, 0, 8, 9, 9, 0, 0, 0, 0, 0, 0, 7, 9, 9, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 9, 9, 0, 0, 0,
+ 0, 0, 0, 9, 9,11, 0, 0, 0, 0, 0, 0, 9,11,10, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 9, 9, 0, 0,
+ 0, 0, 0, 0, 8,11, 9, 0, 0, 0, 0, 0, 0, 9,10,11,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 5, 7, 8, 0, 0, 0, 0, 0, 0, 7, 9, 9, 0, 0,
+ 0, 0, 0, 0, 8, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 7, 9, 9, 0, 0, 0, 0, 0, 0, 9,11,10, 0,
+ 0, 0, 0, 0, 0, 8, 9,11, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 7, 9, 9, 0, 0, 0, 0, 0, 0, 9,10,11,
+ 0, 0, 0, 0, 0, 0, 9,11, 9, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _16c1_s_p1_0 = {
+ 8, 6561,
+ (long *)_vq_lengthlist__16c1_s_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__16c1_s_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__16c1_s_p3_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__16c1_s_p3_0[] = {
+ 1, 4, 4, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 5, 5, 7, 7, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 4, 5, 5, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7, 7, 9, 9,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 6, 7, 7, 9, 9, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _16c1_s_p3_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__16c1_s_p3_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__16c1_s_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__16c1_s_p4_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__16c1_s_p4_0[] = {
+ 1, 2, 3, 7, 7, 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0,
+ 0, 0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0, 0, 7, 7,
+ 0, 0, 0, 0, 0, 0, 0, 7, 7, 0, 0, 0, 0, 0, 0, 0,
+ 8, 8, 0, 0, 0, 0, 0, 0, 0, 8, 9, 0, 0, 0, 0, 0,
+ 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _16c1_s_p4_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__16c1_s_p4_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__16c1_s_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__16c1_s_p5_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__16c1_s_p5_0[] = {
+ 1, 3, 3, 5, 5, 6, 6, 8, 8, 0, 0, 0, 7, 7, 7, 7,
+ 9, 9, 0, 0, 0, 7, 7, 7, 7, 9, 9, 0, 0, 0, 8, 8,
+ 8, 8, 9, 9, 0, 0, 0, 8, 8, 8, 8,10,10, 0, 0, 0,
+ 9, 9, 8, 8,10,10, 0, 0, 0, 9, 9, 8, 8,10,10, 0,
+ 0, 0,10,10, 9, 9,10,10, 0, 0, 0, 0, 0, 9, 9,10,
+ 10,
+};
+
+static const static_codebook _16c1_s_p5_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__16c1_s_p5_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__16c1_s_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__16c1_s_p6_0[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__16c1_s_p6_0[] = {
+ 1, 3, 3, 6, 6, 8, 8, 9, 9, 9, 9,10,10,11,11,12,
+ 12, 0, 0, 0, 7, 7, 8, 8, 9, 9, 9, 9,10,10,11,11,
+ 12,12, 0, 0, 0, 7, 7, 8, 8, 9, 9, 9, 9,10,10,11,
+ 11,12,12, 0, 0, 0, 8, 8, 8, 9,10, 9,10,10,10,10,
+ 11,11,12,12, 0, 0, 0, 8, 8, 9, 9,10,10,10,10,11,
+ 11,11,12,12,12, 0, 0, 0, 8, 8, 9, 9,10,10,10,10,
+ 11,11,12,12,12,12, 0, 0, 0, 8, 8, 9, 9,10,10,10,
+ 10,11,11,12,12,13,13, 0, 0, 0, 9, 9, 9, 9,10,10,
+ 10,10,11,11,12,12,13,13, 0, 0, 0, 0, 0, 9, 9,10,
+ 10,10,10,11,11,12,12,13,13, 0, 0, 0, 0, 0, 9, 9,
+ 10,10,11,11,12,12,12,12,13,13, 0, 0, 0, 0, 0, 9,
+ 9,10,10,11,11,12,12,12,12,13,13, 0, 0, 0, 0, 0,
+ 10,10,11,10,11,11,12,12,13,13,13,13, 0, 0, 0, 0,
+ 0, 0, 0,10,10,11,11,12,12,13,13,13,13, 0, 0, 0,
+ 0, 0, 0, 0,11,11,12,12,12,12,13,13,14,14, 0, 0,
+ 0, 0, 0, 0, 0,11,11,12,12,12,12,13,13,14,14, 0,
+ 0, 0, 0, 0, 0, 0,12,12,12,12,13,13,13,13,14,14,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,12,12,13,13,13,13,14,
+ 14,
+};
+
+static const static_codebook _16c1_s_p6_0 = {
+ 2, 289,
+ (long *)_vq_lengthlist__16c1_s_p6_0,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__16c1_s_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__16c1_s_p7_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__16c1_s_p7_0[] = {
+ 1, 4, 4, 6, 6, 6, 7, 6, 6, 4, 7, 7,10, 9,10,10,
+ 10, 9, 4, 7, 7,10,10,10,11,10,10, 6,10,10,11,11,
+ 11,11,10,10, 6,10, 9,11,11,11,11,10,10, 6,10,10,
+ 11,11,11,11,10,10, 7,11,11,11,11,11,12,12,11, 6,
+ 10,10,11,10,10,11,11,11, 6,10,10,10,11,10,11,11,
+ 11,
+};
+
+static const static_codebook _16c1_s_p7_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__16c1_s_p7_0,
+ 1, -529137664, 1618345984, 2, 0,
+ (long *)_vq_quantlist__16c1_s_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__16c1_s_p7_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__16c1_s_p7_1[] = {
+ 2, 3, 3, 5, 6, 7, 7, 7, 7, 8, 8,10,10,10, 6, 6,
+ 7, 7, 8, 8, 8, 8,10,10,10, 6, 6, 7, 7, 8, 8, 8,
+ 8,10,10,10, 7, 7, 7, 7, 8, 8, 8, 8,10,10,10, 7,
+ 7, 7, 7, 8, 8, 8, 8,10,10,10, 7, 7, 8, 8, 8, 8,
+ 8, 8,10,10,10, 7, 7, 8, 8, 8, 8, 8, 8,10,10,10,
+ 8, 8, 8, 8, 8, 8, 9, 9,10,10,10,10,10, 8, 8, 8,
+ 8, 9, 9,10,10,10,10,10, 9, 9, 8, 8, 9, 9,10,10,
+ 10,10,10, 8, 8, 8, 8, 9, 9,
+};
+
+static const static_codebook _16c1_s_p7_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__16c1_s_p7_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__16c1_s_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__16c1_s_p8_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__16c1_s_p8_0[] = {
+ 1, 4, 4, 6, 6, 7, 7, 7, 7, 8, 8, 9, 9, 6, 5, 5,
+ 7, 8, 8, 9, 8, 8, 9, 9,10,11, 6, 5, 5, 8, 8, 9,
+ 9, 8, 8, 9,10,10,11, 0, 8, 8, 8, 9, 9, 9, 9, 9,
+ 10,10,11,11, 0, 9, 9, 9, 8, 9, 9, 9, 9,10,10,11,
+ 11, 0,13,13, 9, 9,10,10,10,10,11,11,12,12, 0,14,
+ 13, 9, 9,10,10,10,10,11,11,12,12, 0, 0, 0,10,10,
+ 9, 9,11,11,12,12,13,12, 0, 0, 0,10,10, 9, 9,10,
+ 10,12,12,13,13, 0, 0, 0,13,14,11,10,11,11,12,12,
+ 13,14, 0, 0, 0,14,14,10,10,11,11,12,12,13,13, 0,
+ 0, 0, 0, 0,12,12,12,12,13,13,14,15, 0, 0, 0, 0,
+ 0,12,12,12,12,13,13,14,15,
+};
+
+static const static_codebook _16c1_s_p8_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__16c1_s_p8_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__16c1_s_p8_0,
+ 0
+};
+
+static const long _vq_quantlist__16c1_s_p8_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__16c1_s_p8_1[] = {
+ 2, 3, 3, 5, 5, 6, 6, 6, 5, 5, 6, 6, 6, 5, 5, 6,
+ 6, 6, 5, 5, 6, 6, 6, 5, 5,
+};
+
+static const static_codebook _16c1_s_p8_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__16c1_s_p8_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__16c1_s_p8_1,
+ 0
+};
+
+static const long _vq_quantlist__16c1_s_p9_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__16c1_s_p9_0[] = {
+ 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8,
+};
+
+static const static_codebook _16c1_s_p9_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__16c1_s_p9_0,
+ 1, -513964032, 1628680192, 4, 0,
+ (long *)_vq_quantlist__16c1_s_p9_0,
+ 0
+};
+
+static const long _vq_quantlist__16c1_s_p9_1[] = {
+ 7,
+ 6,
+ 8,
+ 5,
+ 9,
+ 4,
+ 10,
+ 3,
+ 11,
+ 2,
+ 12,
+ 1,
+ 13,
+ 0,
+ 14,
+};
+
+static const long _vq_lengthlist__16c1_s_p9_1[] = {
+ 1, 4, 4, 4, 4, 8, 8,12,13,14,14,14,14,14,14, 6,
+ 6, 6, 6, 6,10, 9,14,14,14,14,14,14,14,14, 7, 6,
+ 5, 6, 6,10, 9,12,13,13,13,13,13,13,13,13, 7, 7,
+ 9, 9,11,11,12,13,13,13,13,13,13,13,13, 7, 7, 8,
+ 8,11,12,13,13,13,13,13,13,13,13,13,12,12,10,10,
+ 13,12,13,13,13,13,13,13,13,13,13,12,12,10,10,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,12,13,12,
+ 13,13,13,13,13,13,13,13,13,13,13,13,12,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,12,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,12,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,
+};
+
+static const static_codebook _16c1_s_p9_1 = {
+ 2, 225,
+ (long *)_vq_lengthlist__16c1_s_p9_1,
+ 1, -520986624, 1620377600, 4, 0,
+ (long *)_vq_quantlist__16c1_s_p9_1,
+ 0
+};
+
+static const long _vq_quantlist__16c1_s_p9_2[] = {
+ 10,
+ 9,
+ 11,
+ 8,
+ 12,
+ 7,
+ 13,
+ 6,
+ 14,
+ 5,
+ 15,
+ 4,
+ 16,
+ 3,
+ 17,
+ 2,
+ 18,
+ 1,
+ 19,
+ 0,
+ 20,
+};
+
+static const long _vq_lengthlist__16c1_s_p9_2[] = {
+ 1, 4, 4, 6, 6, 7, 7, 8, 7, 8, 8, 9, 9, 9, 9,10,
+ 10,10, 9,10,10,11,12,12, 8, 8, 8, 8, 9, 9, 9, 9,
+ 10,10,10,10,10,11,11,10,12,11,11,13,11, 7, 7, 8,
+ 8, 8, 8, 9, 9, 9,10,10,10,10, 9,10,10,11,11,12,
+ 11,11, 8, 8, 8, 8, 9, 9,10,10,10,10,11,11,11,11,
+ 11,11,11,12,11,12,12, 8, 8, 9, 9, 9, 9, 9,10,10,
+ 10,10,10,10,11,11,11,11,11,11,12,11, 9, 9, 9, 9,
+ 10,10,10,10,11,10,11,11,11,11,11,11,12,12,12,12,
+ 11, 9, 9, 9, 9,10,10,10,10,11,11,11,11,11,11,11,
+ 11,11,12,12,12,13, 9,10,10, 9,11,10,10,10,10,11,
+ 11,11,11,11,10,11,12,11,12,12,11,12,11,10, 9,10,
+ 10,11,10,11,11,11,11,11,11,11,11,11,12,12,11,12,
+ 12,12,10,10,10,11,10,11,11,11,11,11,11,11,11,11,
+ 11,11,12,13,12,12,11, 9,10,10,11,11,10,11,11,11,
+ 12,11,11,11,11,11,12,12,13,13,12,13,10,10,12,10,
+ 11,11,11,11,11,11,11,11,11,12,12,11,13,12,12,12,
+ 12,13,12,11,11,11,11,11,11,12,11,12,11,11,11,11,
+ 12,12,13,12,11,12,12,11,11,11,11,11,12,11,11,11,
+ 11,12,11,11,12,11,12,13,13,12,12,12,12,11,11,11,
+ 11,11,12,11,11,12,11,12,11,11,11,11,13,12,12,12,
+ 12,13,11,11,11,12,12,11,11,11,12,11,12,12,12,11,
+ 12,13,12,11,11,12,12,11,12,11,11,11,12,12,11,12,
+ 11,11,11,12,12,12,12,13,12,13,12,12,12,12,11,11,
+ 12,11,11,11,11,11,11,12,12,12,13,12,11,13,13,12,
+ 12,11,12,10,11,11,11,11,12,11,12,12,11,12,12,13,
+ 12,12,13,12,12,12,12,12,11,12,12,12,11,12,11,11,
+ 11,12,13,12,13,13,13,13,13,12,13,13,12,12,13,11,
+ 11,11,11,11,12,11,11,12,11,
+};
+
+static const static_codebook _16c1_s_p9_2 = {
+ 2, 441,
+ (long *)_vq_lengthlist__16c1_s_p9_2,
+ 1, -529268736, 1611661312, 5, 0,
+ (long *)_vq_quantlist__16c1_s_p9_2,
+ 0
+};
+
+static const long _huff_lengthlist__16c1_s_short[] = {
+ 5, 6,17, 8,12, 9,10,10,12,13, 5, 2,17, 4, 9, 5,
+ 7, 8,11,13,16,16,16,16,16,16,16,16,16,16, 6, 4,
+ 16, 5,10, 5, 7,10,14,16,13, 9,16,11, 8, 7, 8, 9,
+ 13,16, 7, 4,16, 5, 7, 4, 6, 8,11,13, 8, 6,16, 7,
+ 8, 5, 5, 7, 9,13, 9, 8,16, 9, 8, 6, 6, 7, 9,13,
+ 11,11,16,10,10, 7, 7, 7, 9,13,13,13,16,13,13, 9,
+ 9, 9,10,13,
+};
+
+static const static_codebook _huff_book__16c1_s_short = {
+ 2, 100,
+ (long *)_huff_lengthlist__16c1_s_short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__16c2_s_long[] = {
+ 4, 7, 9, 9, 9, 8, 9,10,13,16, 5, 4, 5, 6, 7, 7,
+ 8, 9,12,16, 6, 5, 5, 5, 7, 7, 9,10,12,15, 7, 6,
+ 5, 4, 5, 6, 8, 9,10,13, 8, 7, 7, 5, 5, 5, 7, 9,
+ 10,12, 7, 7, 7, 6, 5, 5, 6, 7,10,12, 8, 8, 8, 7,
+ 7, 5, 5, 6, 9,11, 8, 9, 9, 8, 8, 6, 6, 5, 8,11,
+ 10,11,12,12,11, 9, 9, 8, 9,12,13,14,15,15,14,12,
+ 12,11,11,13,
+};
+
+static const static_codebook _huff_book__16c2_s_long = {
+ 2, 100,
+ (long *)_huff_lengthlist__16c2_s_long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__16c2_s_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__16c2_s_p1_0[] = {
+ 1, 3, 3, 0, 0, 0, 0, 0, 0, 4, 5, 5, 0, 0, 0, 0,
+ 0, 0, 4, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _16c2_s_p1_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__16c2_s_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__16c2_s_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__16c2_s_p2_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__16c2_s_p2_0[] = {
+ 2, 4, 4, 7, 7, 0, 0, 0, 8, 8, 0, 0, 0, 8, 8, 0,
+ 0, 0, 8, 8, 0, 0, 0, 8, 8, 4, 4, 4, 8, 7, 0, 0,
+ 0, 8, 8, 0, 0, 0, 8, 8, 0, 0, 0, 9, 9, 0, 0, 0,
+ 9, 9, 4, 4, 4, 7, 8, 0, 0, 0, 8, 8, 0, 0, 0, 8,
+ 8, 0, 0, 0, 9, 9, 0, 0, 0, 9, 9, 7, 8, 8,10, 9,
+ 0, 0, 0,12,11, 0, 0, 0,11,12, 0, 0, 0,14,13, 0,
+ 0, 0,14,14, 7, 8, 8, 9,10, 0, 0, 0,11,12, 0, 0,
+ 0,11,11, 0, 0, 0,14,14, 0, 0, 0,14,14, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8,11,11, 0, 0, 0,
+ 12,11, 0, 0, 0,12,12, 0, 0, 0,13,12, 0, 0, 0,13,
+ 13, 8, 8, 8,11,11, 0, 0, 0,11,11, 0, 0, 0,12,12,
+ 0, 0, 0,13,13, 0, 0, 0,13,13, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 8, 9, 8,12,11, 0, 0, 0,12,12, 0,
+ 0, 0,12,11, 0, 0, 0,13,13, 0, 0, 0,13,13, 8, 8,
+ 8,11,12, 0, 0, 0,11,12, 0, 0, 0,11,12, 0, 0, 0,
+ 13,14, 0, 0, 0,13,13, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 8, 9, 9,14,14, 0, 0, 0,13,13, 0, 0, 0,13,
+ 13, 0, 0, 0,13,12, 0, 0, 0,13,13, 8, 9, 9,14,14,
+ 0, 0, 0,13,13, 0, 0, 0,13,13, 0, 0, 0,12,13, 0,
+ 0, 0,13,13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8,
+ 9, 9,14,14, 0, 0, 0,13,13, 0, 0, 0,13,13, 0, 0,
+ 0,13,13, 0, 0, 0,13,12, 8, 9, 9,14,14, 0, 0, 0,
+ 13,13, 0, 0, 0,13,13, 0, 0, 0,13,13, 0, 0, 0,12,
+ 12,
+};
+
+static const static_codebook _16c2_s_p2_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__16c2_s_p2_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__16c2_s_p2_0,
+ 0
+};
+
+static const long _vq_quantlist__16c2_s_p3_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__16c2_s_p3_0[] = {
+ 1, 3, 3, 5, 5, 7, 7, 8, 8, 0, 0, 0, 6, 6, 8, 8,
+ 9, 9, 0, 0, 0, 6, 6, 8, 8, 9, 9, 0, 0, 0, 7, 7,
+ 8, 9,10,10, 0, 0, 0, 7, 7, 9, 9,10,10, 0, 0, 0,
+ 8, 8, 9, 9,11,11, 0, 0, 0, 7, 7, 9, 9,11,11, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _16c2_s_p3_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__16c2_s_p3_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__16c2_s_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__16c2_s_p4_0[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__16c2_s_p4_0[] = {
+ 2, 3, 3, 5, 5, 6, 6, 6, 6, 7, 7, 8, 8, 8, 8, 9,
+ 9, 0, 0, 0, 6, 6, 7, 7, 8, 8, 8, 8, 9, 9,10,10,
+ 11,10, 0, 0, 0, 6, 6, 7, 7, 8, 8, 8, 8, 9, 9,10,
+ 10,10,10, 0, 0, 0, 6, 6, 8, 8, 9, 9, 9, 9,10,10,
+ 11,11,11,11, 0, 0, 0, 7, 6, 8, 8, 9, 9, 9, 9,10,
+ 10,11,11,11,11, 0, 0, 0, 7, 7, 8, 8, 9, 9,10,10,
+ 11,11,11,11,12,12, 0, 0, 0, 7, 7, 8, 8, 9, 9,10,
+ 10,11,11,11,11,12,12, 0, 0, 0, 7, 8, 8, 8, 9, 9,
+ 10,10,11,11,12,12,13,13, 0, 0, 0, 0, 0, 8, 8, 9,
+ 9,10,10,11,11,12,12,13,13, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _16c2_s_p4_0 = {
+ 2, 289,
+ (long *)_vq_lengthlist__16c2_s_p4_0,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__16c2_s_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__16c2_s_p5_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__16c2_s_p5_0[] = {
+ 1, 4, 4, 5, 7, 7, 6, 7, 7, 4, 6, 6,10,11,10,10,
+ 10,11, 4, 6, 6,10,10,11,10,11,10, 5,10,10, 9,12,
+ 11,10,12,12, 7,10,10,12,12,12,12,13,13, 7,11,10,
+ 11,12,12,12,13,13, 6,11,10,10,12,12,11,12,12, 7,
+ 11,10,12,13,13,12,12,12, 7,10,11,12,13,13,12,12,
+ 12,
+};
+
+static const static_codebook _16c2_s_p5_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__16c2_s_p5_0,
+ 1, -529137664, 1618345984, 2, 0,
+ (long *)_vq_quantlist__16c2_s_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__16c2_s_p5_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__16c2_s_p5_1[] = {
+ 2, 3, 3, 6, 6, 6, 6, 7, 7, 7, 7,11,10,10, 6, 6,
+ 7, 7, 8, 8, 8, 8,10,10,10, 6, 6, 7, 7, 8, 8, 8,
+ 8,11,11,11, 7, 7, 8, 8, 8, 8, 9, 9,11,11,11, 6,
+ 7, 8, 8, 8, 8, 9, 9,11,11,11, 7, 7, 8, 8, 8, 8,
+ 8, 8,11,11,11, 7, 7, 8, 8, 8, 8, 9, 9,11,11,11,
+ 8, 8, 8, 8, 8, 8, 8, 8,11,11,11,11,11, 8, 8, 8,
+ 8, 8, 8,12,11,11,11,11, 8, 8, 8, 8, 8, 8,12,11,
+ 11,11,11, 7, 7, 8, 8, 8, 8,
+};
+
+static const static_codebook _16c2_s_p5_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__16c2_s_p5_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__16c2_s_p5_1,
+ 0
+};
+
+static const long _vq_quantlist__16c2_s_p6_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__16c2_s_p6_0[] = {
+ 1, 4, 4, 6, 6, 8, 7, 8, 8, 9, 9,10,10, 5, 5, 5,
+ 7, 7, 9, 9, 9, 9,11,11,12,12, 6, 5, 5, 7, 7, 9,
+ 9,10, 9,11,11,12,12, 0, 7, 7, 7, 7, 9, 9,10,10,
+ 11,11,12,12, 0, 7, 7, 7, 7, 9, 9,10,10,11,11,12,
+ 12, 0,11,11, 8, 8,10,10,11,11,12,12,13,13, 0,12,
+ 12, 9, 9,10,10,11,11,12,12,13,13, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+static const static_codebook _16c2_s_p6_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__16c2_s_p6_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__16c2_s_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__16c2_s_p6_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__16c2_s_p6_1[] = {
+ 2, 3, 3, 5, 5, 6, 6, 6, 5, 5, 6, 6, 6, 5, 5, 6,
+ 6, 6, 5, 5, 6, 6, 6, 5, 5,
+};
+
+static const static_codebook _16c2_s_p6_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__16c2_s_p6_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__16c2_s_p6_1,
+ 0
+};
+
+static const long _vq_quantlist__16c2_s_p7_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__16c2_s_p7_0[] = {
+ 1, 4, 4, 7, 7, 8, 8, 8, 8,10, 9,10,10, 5, 5, 5,
+ 7, 7, 9, 9,10,10,11,10,12,11, 6, 5, 5, 7, 7, 9,
+ 9,10,10,11,11,12,12,20, 7, 7, 7, 7, 9, 9,10,10,
+ 11,11,12,12,20, 7, 7, 7, 7, 9, 9,11,10,12,11,12,
+ 12,20,11,11, 8, 8,10,10,11,11,12,12,13,13,20,12,
+ 12, 8, 8, 9, 9,11,11,12,12,13,13,20,20,21,10,10,
+ 10,10,11,11,12,12,13,13,21,21,21,10,10,10,10,11,
+ 11,12,12,13,13,21,21,21,14,14,11,11,12,12,13,13,
+ 13,14,21,21,21,16,15,11,11,12,11,13,13,14,14,21,
+ 21,21,21,21,13,13,12,12,13,13,14,14,21,21,21,21,
+ 21,13,13,12,12,13,13,14,14,
+};
+
+static const static_codebook _16c2_s_p7_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__16c2_s_p7_0,
+ 1, -523206656, 1618345984, 4, 0,
+ (long *)_vq_quantlist__16c2_s_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__16c2_s_p7_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__16c2_s_p7_1[] = {
+ 2, 4, 4, 6, 6, 7, 7, 7, 7, 7, 7, 9, 9, 9, 6, 7,
+ 7, 7, 7, 7, 8, 8, 9, 9, 9, 6, 6, 7, 7, 7, 7, 8,
+ 8, 9, 9, 9, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 7,
+ 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 7, 7, 7, 7, 8, 8,
+ 8, 8, 9, 9, 9, 7, 7, 7, 7, 7, 7, 8, 8, 9, 9, 9,
+ 7, 7, 8, 8, 7, 7, 8, 8, 9, 9, 9, 9, 9, 8, 8, 7,
+ 7, 8, 8, 9, 9, 9, 9, 9, 8, 8, 7, 7, 8, 8, 9, 9,
+ 9, 9, 9, 7, 7, 7, 7, 8, 8,
+};
+
+static const static_codebook _16c2_s_p7_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__16c2_s_p7_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__16c2_s_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__16c2_s_p8_0[] = {
+ 7,
+ 6,
+ 8,
+ 5,
+ 9,
+ 4,
+ 10,
+ 3,
+ 11,
+ 2,
+ 12,
+ 1,
+ 13,
+ 0,
+ 14,
+};
+
+static const long _vq_lengthlist__16c2_s_p8_0[] = {
+ 1, 4, 4, 6, 6, 7, 7, 7, 7, 8, 8, 9, 9,10,10, 6,
+ 6, 6, 8, 8, 9, 9, 8, 8, 9, 9,10,10,11,11, 6, 5,
+ 5, 8, 7, 9, 9, 8, 8, 9, 9,10,10,11,11,20, 8, 8,
+ 8, 8, 9, 9, 9, 9,10,10,11,10,12,11,20, 8, 8, 8,
+ 8, 9, 9, 9, 9,10,10,11,11,12,12,20,12,12, 9, 9,
+ 10,10,10,10,11,11,12,12,13,12,20,13,13, 9, 9,10,
+ 10,10,10,11,11,12,12,13,13,20,20,20, 9, 9, 9, 9,
+ 10,10,11,11,12,12,13,12,20,20,20, 9, 9, 9, 8,10,
+ 10,12,11,12,12,13,13,20,20,20,13,13,10,10,11,11,
+ 12,12,13,13,13,13,20,20,20,13,13,10,10,11,10,12,
+ 11,13,13,14,14,20,20,20,20,20,11,11,11,11,12,12,
+ 13,13,14,14,20,20,20,20,20,11,10,11,11,13,11,13,
+ 13,14,14,20,20,21,21,21,14,14,11,12,13,13,13,13,
+ 14,14,21,21,21,21,21,15,15,12,11,13,12,14,13,15,
+ 14,
+};
+
+static const static_codebook _16c2_s_p8_0 = {
+ 2, 225,
+ (long *)_vq_lengthlist__16c2_s_p8_0,
+ 1, -520986624, 1620377600, 4, 0,
+ (long *)_vq_quantlist__16c2_s_p8_0,
+ 0
+};
+
+static const long _vq_quantlist__16c2_s_p8_1[] = {
+ 10,
+ 9,
+ 11,
+ 8,
+ 12,
+ 7,
+ 13,
+ 6,
+ 14,
+ 5,
+ 15,
+ 4,
+ 16,
+ 3,
+ 17,
+ 2,
+ 18,
+ 1,
+ 19,
+ 0,
+ 20,
+};
+
+static const long _vq_lengthlist__16c2_s_p8_1[] = {
+ 2, 4, 4, 6, 6, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8,11,11,11, 7, 7, 8, 8, 8, 8, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,10,11,10, 7, 7, 8,
+ 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,11,
+ 11,11, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9,11,11,11, 8, 8, 8, 8, 9, 9, 9, 9, 9,
+ 9, 9, 9,10, 9,10,10,10,10,11,11,11, 8, 8, 9, 9,
+ 9, 9, 9, 9, 9, 9,10,10,10,10,10,10,10,10,11,11,
+ 11, 8, 8, 9, 9, 9, 9, 9, 9, 9,10,10,10,10,10,10,
+ 10,10,10,11,11,11, 9, 9, 9, 9, 9, 9, 9, 9,10,10,
+ 10,10,10,10,10,10,10,10,11,11,11,11,11, 9, 9, 9,
+ 9, 9, 9,10,10,10,10,10,10,10,10,10,10,11,11,11,
+ 11,11, 9, 9, 9, 9,10,10,10,10,10,10,10,10,10,10,
+ 10,10,11,11,11,11,11, 9, 9, 9, 9,10,10,10,10,10,
+ 10,10,10,10,10,10,10,11,11,11,11,11,10, 9,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,11,11,11,11,
+ 11,11,11,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,11,11,11,11,11,11,11,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,11,11,11,11,11,11,11,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,11,11,11,11,11,
+ 11,11,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 11,11,11,11,11,11,11,11,11,10,10,10,10,10,10,10,
+ 10,10,10,10,10,11,11,11,11,11,11,11,11,11,10,10,
+ 10,10,10,10,10,10,10,10,10,10,11,11,11,11,11,11,
+ 11,11,11,10,10,10,10,10,10,10,10,10,10,10,10,11,
+ 11,11,11,11,11,11,11,11,10,10,10,10,10,10,10,10,
+ 10,10,10,10,11,11,11,11,11,11,11,11,11,11,11,10,
+ 10,10,10,10,10,10,10,10,10,
+};
+
+static const static_codebook _16c2_s_p8_1 = {
+ 2, 441,
+ (long *)_vq_lengthlist__16c2_s_p8_1,
+ 1, -529268736, 1611661312, 5, 0,
+ (long *)_vq_quantlist__16c2_s_p8_1,
+ 0
+};
+
+static const long _vq_quantlist__16c2_s_p9_0[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__16c2_s_p9_0[] = {
+ 1, 4, 3,10, 8,10,10,10,10,10,10,10,10,10,10,10,
+ 10, 6,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10, 6,10, 9,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,
+};
+
+static const static_codebook _16c2_s_p9_0 = {
+ 2, 289,
+ (long *)_vq_lengthlist__16c2_s_p9_0,
+ 1, -509798400, 1631393792, 5, 0,
+ (long *)_vq_quantlist__16c2_s_p9_0,
+ 0
+};
+
+static const long _vq_quantlist__16c2_s_p9_1[] = {
+ 9,
+ 8,
+ 10,
+ 7,
+ 11,
+ 6,
+ 12,
+ 5,
+ 13,
+ 4,
+ 14,
+ 3,
+ 15,
+ 2,
+ 16,
+ 1,
+ 17,
+ 0,
+ 18,
+};
+
+static const long _vq_lengthlist__16c2_s_p9_1[] = {
+ 1, 4, 4, 7, 7, 7, 7, 7, 7, 8, 8,10, 9,11,10,13,
+ 11,14,13, 6, 6, 6, 8, 8, 8, 8, 8, 7, 9, 8,11, 9,
+ 13,11,14,12,14,13, 5, 6, 6, 8, 8, 8, 8, 8, 8, 9,
+ 9,11,11,13,11,14,13,15,15,17, 8, 8, 8, 8, 9, 9,
+ 9, 8,11, 9,12,10,13,11,14,12,14,13,17, 8, 8, 8,
+ 8, 9, 9, 9, 9,10,10,11,11,13,13,13,14,16,15,17,
+ 12,12, 8, 8, 9, 9,10,10,11,11,12,11,13,12,13,12,
+ 14,13,16,12,12, 8, 8, 9, 9,10,10,11,11,12,12,13,
+ 13,14,14,15,15,17,17,17, 9, 9, 9, 9,11,11,12,12,
+ 12,13,13,13,16,14,14,14,17,17,17, 9, 8, 9, 8,11,
+ 10,12,12,13,13,14,14,15,15,16,16,17,17,17,12,12,
+ 10,10,11,12,12,13,13,14,13,15,15,14,16,15,17,17,
+ 17,12,12,10, 8,12, 9,13,12,14,14,15,14,15,16,16,
+ 16,17,17,17,17,17,11,11,12,12,14,14,14,16,15,16,
+ 15,16,15,17,17,17,17,17,17,11, 9,12,10,13,11,15,
+ 14,16,16,17,16,16,15,17,17,17,17,17,15,15,12,12,
+ 14,14,15,16,16,15,16,16,17,17,17,17,17,17,17,14,
+ 14,12,10,14,11,15,12,17,16,15,16,17,16,17,17,17,
+ 17,17,17,17,13,13,14,14,14,16,17,17,16,17,17,17,
+ 17,17,17,17,17,17,17,13, 9,13,12,15,13,16,16,17,
+ 17,17,17,17,17,17,17,17,17,17,15,17,14,14,15,16,
+ 16,17,16,17,16,17,17,17,17,17,17,17,17,17,17,14,
+ 13,15,16,16,17,16,17,17,17,
+};
+
+static const static_codebook _16c2_s_p9_1 = {
+ 2, 361,
+ (long *)_vq_lengthlist__16c2_s_p9_1,
+ 1, -518287360, 1622704128, 5, 0,
+ (long *)_vq_quantlist__16c2_s_p9_1,
+ 0
+};
+
+static const long _vq_quantlist__16c2_s_p9_2[] = {
+ 24,
+ 23,
+ 25,
+ 22,
+ 26,
+ 21,
+ 27,
+ 20,
+ 28,
+ 19,
+ 29,
+ 18,
+ 30,
+ 17,
+ 31,
+ 16,
+ 32,
+ 15,
+ 33,
+ 14,
+ 34,
+ 13,
+ 35,
+ 12,
+ 36,
+ 11,
+ 37,
+ 10,
+ 38,
+ 9,
+ 39,
+ 8,
+ 40,
+ 7,
+ 41,
+ 6,
+ 42,
+ 5,
+ 43,
+ 4,
+ 44,
+ 3,
+ 45,
+ 2,
+ 46,
+ 1,
+ 47,
+ 0,
+ 48,
+};
+
+static const long _vq_lengthlist__16c2_s_p9_2[] = {
+ 2, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6,
+ 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7,
+};
+
+static const static_codebook _16c2_s_p9_2 = {
+ 1, 49,
+ (long *)_vq_lengthlist__16c2_s_p9_2,
+ 1, -526909440, 1611661312, 6, 0,
+ (long *)_vq_quantlist__16c2_s_p9_2,
+ 0
+};
+
+static const long _huff_lengthlist__16c2_s_short[] = {
+ 7,10,12,11,12,13,15,16,18,15,10, 8, 8, 8, 9,10,
+ 12,13,14,17,10, 7, 7, 7, 7, 8,10,12,15,18,10, 7,
+ 7, 5, 5, 6, 8,10,13,15,10, 7, 6, 5, 4, 4, 6, 9,
+ 12,15,11, 7, 7, 5, 4, 3, 4, 7,11,13,12, 9, 8, 7,
+ 5, 4, 4, 5,10,13,11,11,11, 9, 7, 5, 5, 5, 9,12,
+ 13,12,13,12,10, 8, 8, 7, 9,13,14,14,14,14,13,11,
+ 11,10,10,13,
+};
+
+static const static_codebook _huff_book__16c2_s_short = {
+ 2, 100,
+ (long *)_huff_lengthlist__16c2_s_short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__8c0_s_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__8c0_s_p1_0[] = {
+ 1, 5, 4, 0, 0, 0, 0, 0, 0, 5, 7, 7, 0, 0, 0, 0,
+ 0, 0, 5, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 5, 8, 8, 0, 0, 0, 0, 0, 0, 7, 8, 9, 0, 0, 0,
+ 0, 0, 0, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 5, 8, 8, 0, 0, 0, 0, 0, 0, 7, 9, 9, 0, 0,
+ 0, 0, 0, 0, 7, 9, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 8, 8, 0, 0, 0, 0,
+ 0, 0, 8,10,10, 0, 0, 0, 0, 0, 0, 8, 9, 9, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7,10, 9, 0, 0, 0,
+ 0, 0, 0, 8, 9,11, 0, 0, 0, 0, 0, 0, 9,11,11, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 9,10, 0, 0,
+ 0, 0, 0, 0, 9,11,10, 0, 0, 0, 0, 0, 0, 9,11,11,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 5, 8, 8, 0, 0, 0, 0, 0, 0, 8, 9, 9, 0, 0,
+ 0, 0, 0, 0, 8, 9,10, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 7, 9, 9, 0, 0, 0, 0, 0, 0, 9,11,11, 0,
+ 0, 0, 0, 0, 0, 9,10,11, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 7, 9,10, 0, 0, 0, 0, 0, 0, 9,11,11,
+ 0, 0, 0, 0, 0, 0, 8,11, 9, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _8c0_s_p1_0 = {
+ 8, 6561,
+ (long *)_vq_lengthlist__8c0_s_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__8c0_s_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__8c0_s_p3_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__8c0_s_p3_0[] = {
+ 1, 4, 4, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 5, 6, 7, 7, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 4, 5, 5, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 7, 7, 8, 8,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 6, 7, 7, 8, 8, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _8c0_s_p3_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__8c0_s_p3_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__8c0_s_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__8c0_s_p4_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__8c0_s_p4_0[] = {
+ 1, 2, 3, 7, 7, 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0,
+ 0, 0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0, 0, 7, 7,
+ 0, 0, 0, 0, 0, 0, 0, 7, 7, 0, 0, 0, 0, 0, 0, 0,
+ 8, 8, 0, 0, 0, 0, 0, 0, 0, 9, 8, 0, 0, 0, 0, 0,
+ 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _8c0_s_p4_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__8c0_s_p4_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__8c0_s_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__8c0_s_p5_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__8c0_s_p5_0[] = {
+ 1, 3, 3, 5, 5, 7, 6, 8, 8, 0, 0, 0, 7, 7, 7, 7,
+ 8, 8, 0, 0, 0, 7, 7, 7, 7, 8, 9, 0, 0, 0, 8, 8,
+ 8, 8, 9, 9, 0, 0, 0, 8, 8, 8, 8, 9, 9, 0, 0, 0,
+ 9, 9, 8, 8,10,10, 0, 0, 0, 9, 9, 8, 8,10,10, 0,
+ 0, 0,10,10, 9, 9,10,10, 0, 0, 0, 0, 0, 9, 9,10,
+ 10,
+};
+
+static const static_codebook _8c0_s_p5_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__8c0_s_p5_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__8c0_s_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__8c0_s_p6_0[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__8c0_s_p6_0[] = {
+ 1, 3, 3, 6, 6, 8, 8, 9, 9, 8, 8,10, 9,10,10,11,
+ 11, 0, 0, 0, 7, 7, 8, 8, 9, 9, 9, 9,10,10,11,11,
+ 11,12, 0, 0, 0, 7, 7, 8, 8, 9, 9, 9, 9,10,10,11,
+ 11,12,11, 0, 0, 0, 8, 8, 9, 9,10,10, 9, 9,10,10,
+ 11,11,12,12, 0, 0, 0, 8, 8, 9, 9,10,10, 9, 9,11,
+ 10,11,11,12,12, 0, 0, 0, 9, 9, 9, 9,10,10,10,10,
+ 11,11,11,12,12,12, 0, 0, 0, 9, 9, 9, 9,10,10,10,
+ 10,11,11,12,12,13,13, 0, 0, 0,10,10,10,10,11,11,
+ 10,10,11,11,12,12,13,13, 0, 0, 0, 0, 0,10, 9,10,
+ 11,10,10,11,11,12,12,13,13, 0, 0, 0, 0, 0, 9, 9,
+ 10, 9,10,11,12,12,13,13,14,13, 0, 0, 0, 0, 0, 9,
+ 9, 9,10,10,10,11,11,13,12,13,13, 0, 0, 0, 0, 0,
+ 10,10,10,10,11,11,12,12,13,13,14,14, 0, 0, 0, 0,
+ 0, 0, 0,10,10,11,11,12,12,13,13,13,14, 0, 0, 0,
+ 0, 0, 0, 0,11,11,11,11,12,12,13,14,14,14, 0, 0,
+ 0, 0, 0, 0, 0,11,11,11,11,12,12,13,13,14,13, 0,
+ 0, 0, 0, 0, 0, 0,11,11,12,12,13,13,14,14,14,14,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,12,12,12,12,13,13,14,
+ 14,
+};
+
+static const static_codebook _8c0_s_p6_0 = {
+ 2, 289,
+ (long *)_vq_lengthlist__8c0_s_p6_0,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__8c0_s_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__8c0_s_p7_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__8c0_s_p7_0[] = {
+ 1, 4, 4, 7, 6, 6, 7, 6, 6, 4, 7, 7,11, 9,10,12,
+ 9,10, 4, 7, 7,10,10,10,11, 9, 9, 6,11,10,11,11,
+ 12,11,11,11, 6,10,10,11,11,12,11,10,10, 6, 9,10,
+ 11,11,11,11,10,10, 7,10,11,12,11,11,12,11,12, 6,
+ 9, 9,10, 9, 9,11,10,10, 6, 9, 9,10,10,10,11,10,
+ 10,
+};
+
+static const static_codebook _8c0_s_p7_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__8c0_s_p7_0,
+ 1, -529137664, 1618345984, 2, 0,
+ (long *)_vq_quantlist__8c0_s_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__8c0_s_p7_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__8c0_s_p7_1[] = {
+ 1, 3, 3, 6, 6, 8, 8, 9, 9, 9, 9,10,10,10, 7, 7,
+ 8, 8, 9, 9, 9, 9,10,10, 9, 7, 7, 8, 8, 9, 9, 9,
+ 9,10,10,10, 8, 8, 9, 9, 9, 9, 9, 9,10,10,10, 8,
+ 8, 9, 9, 9, 9, 8, 9,10,10,10, 8, 8, 9, 9, 9,10,
+ 10,10,10,10,10, 9, 9, 9, 9, 9, 9,10,10,11,10,11,
+ 9, 9, 9, 9,10,10,10,10,11,11,11,10,10, 9, 9,10,
+ 10,10, 9,11,10,10,10,10,10,10, 9, 9,10,10,11,11,
+ 10,10,10, 9, 9, 9,10,10,10,
+};
+
+static const static_codebook _8c0_s_p7_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__8c0_s_p7_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__8c0_s_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__8c0_s_p8_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__8c0_s_p8_0[] = {
+ 1, 4, 4, 7, 6, 7, 7, 7, 7, 8, 8, 9, 9, 7, 6, 6,
+ 7, 7, 8, 8, 7, 7, 8, 9,10,10, 7, 6, 6, 7, 7, 8,
+ 7, 7, 7, 9, 9,10,12, 0, 8, 8, 8, 8, 8, 9, 8, 8,
+ 9, 9,10,10, 0, 8, 8, 8, 8, 8, 9, 8, 9, 9, 9,11,
+ 10, 0, 0,13, 9, 8, 9, 9, 9, 9,10,10,11,11, 0,13,
+ 0, 9, 9, 9, 9, 9, 9,11,10,11,11, 0, 0, 0, 8, 9,
+ 10, 9,10,10,13,11,12,12, 0, 0, 0, 8, 9, 9, 9,10,
+ 10,13,12,12,13, 0, 0, 0,12, 0,10,10,12,11,10,11,
+ 12,12, 0, 0, 0,13,13,10,10,10,11,12, 0,13, 0, 0,
+ 0, 0, 0, 0,13,11, 0,12,12,12,13,12, 0, 0, 0, 0,
+ 0, 0,13,13,11,13,13,11,12,
+};
+
+static const static_codebook _8c0_s_p8_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__8c0_s_p8_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__8c0_s_p8_0,
+ 0
+};
+
+static const long _vq_quantlist__8c0_s_p8_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__8c0_s_p8_1[] = {
+ 1, 3, 4, 5, 5, 7, 6, 6, 6, 5, 7, 7, 7, 6, 6, 7,
+ 7, 7, 6, 6, 7, 7, 7, 6, 6,
+};
+
+static const static_codebook _8c0_s_p8_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__8c0_s_p8_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__8c0_s_p8_1,
+ 0
+};
+
+static const long _vq_quantlist__8c0_s_p9_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__8c0_s_p9_0[] = {
+ 1, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7,
+};
+
+static const static_codebook _8c0_s_p9_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__8c0_s_p9_0,
+ 1, -518803456, 1628680192, 2, 0,
+ (long *)_vq_quantlist__8c0_s_p9_0,
+ 0
+};
+
+static const long _vq_quantlist__8c0_s_p9_1[] = {
+ 7,
+ 6,
+ 8,
+ 5,
+ 9,
+ 4,
+ 10,
+ 3,
+ 11,
+ 2,
+ 12,
+ 1,
+ 13,
+ 0,
+ 14,
+};
+
+static const long _vq_lengthlist__8c0_s_p9_1[] = {
+ 1, 4, 4, 5, 5,10, 8,11,11,11,11,11,11,11,11, 6,
+ 6, 6, 7, 6,11,10,11,11,11,11,11,11,11,11, 7, 5,
+ 6, 6, 6, 8, 7,11,11,11,11,11,11,11,11,11, 7, 8,
+ 8, 8, 9, 9,11,11,11,11,11,11,11,11,11, 9, 8, 7,
+ 8, 9,11,11,11,11,11,11,11,11,11,11,11,10,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,10,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,
+};
+
+static const static_codebook _8c0_s_p9_1 = {
+ 2, 225,
+ (long *)_vq_lengthlist__8c0_s_p9_1,
+ 1, -520986624, 1620377600, 4, 0,
+ (long *)_vq_quantlist__8c0_s_p9_1,
+ 0
+};
+
+static const long _vq_quantlist__8c0_s_p9_2[] = {
+ 10,
+ 9,
+ 11,
+ 8,
+ 12,
+ 7,
+ 13,
+ 6,
+ 14,
+ 5,
+ 15,
+ 4,
+ 16,
+ 3,
+ 17,
+ 2,
+ 18,
+ 1,
+ 19,
+ 0,
+ 20,
+};
+
+static const long _vq_lengthlist__8c0_s_p9_2[] = {
+ 1, 5, 5, 7, 7, 8, 7, 8, 8,10,10, 9, 9,10,10,10,
+ 11,11,10,12,11,12,12,12, 9, 8, 8, 8, 8, 8, 9,10,
+ 10,10,10,11,11,11,10,11,11,12,12,11,12, 8, 8, 7,
+ 7, 8, 9,10,10,10, 9,10,10, 9,10,10,11,11,11,11,
+ 11,11, 9, 9, 9, 9, 8, 9,10,10,11,10,10,11,11,12,
+ 10,10,12,12,11,11,10, 9, 9,10, 8, 9,10,10,10, 9,
+ 10,10,11,11,10,11,10,10,10,12,12,12, 9,10, 9,10,
+ 9, 9,10,10,11,11,11,11,10,10,10,11,12,11,12,11,
+ 12,10,11,10,11, 9,10, 9,10, 9,10,10, 9,10,10,11,
+ 10,11,11,11,11,12,11, 9,10,10,10,10,11,11,11,11,
+ 11,10,11,11,11,11,10,12,10,12,12,11,12,10,10,11,
+ 10, 9,11,10,11, 9,10,11,10,10,10,11,11,11,11,12,
+ 12,10, 9, 9,11,10, 9,12,11,10,12,12,11,11,11,11,
+ 10,11,11,12,11,10,12, 9,11,10,11,10,10,11,10,11,
+ 9,10,10,10,11,12,11,11,12,11,10,10,11,11, 9,10,
+ 10,12,10,11,10,10,10, 9,10,10,10,10, 9,10,10,11,
+ 11,11,11,12,11,10,10,10,10,11,11,10,11,11, 9,11,
+ 10,12,10,12,11,10,11,10,10,10,11,10,10,11,11,10,
+ 11,10,10,10,10,11,11,12,10,10,10,11,10,11,12,11,
+ 10,11,10,10,11,11,10,12,10, 9,10,10,11,11,11,10,
+ 12,10,10,11,11,11,10,10,11,10,10,10,11,10,11,10,
+ 12,11,11,10,10,10,12,10,10,11, 9,10,11,11,11,10,
+ 10,11,10,10, 9,11,11,12,12,11,12,11,11,11,11,11,
+ 11, 9,10,11,10,12,10,10,10,10,11,10,10,11,10,10,
+ 12,10,10,10,10,10, 9,12,10,10,10,10,12, 9,11,10,
+ 10,11,10,12,12,10,12,12,12,10,10,10,10, 9,10,11,
+ 10,10,12,10,10,12,11,10,11,10,10,12,11,10,12,10,
+ 10,11, 9,11,10, 9,10, 9,10,
+};
+
+static const static_codebook _8c0_s_p9_2 = {
+ 2, 441,
+ (long *)_vq_lengthlist__8c0_s_p9_2,
+ 1, -529268736, 1611661312, 5, 0,
+ (long *)_vq_quantlist__8c0_s_p9_2,
+ 0
+};
+
+static const long _huff_lengthlist__8c0_s_single[] = {
+ 4, 5,18, 7,10, 6, 7, 8, 9,10, 5, 2,18, 5, 7, 5,
+ 6, 7, 8,11,17,17,17,17,17,17,17,17,17,17, 7, 4,
+ 17, 6, 9, 6, 8,10,12,15,11, 7,17, 9, 6, 6, 7, 9,
+ 11,15, 6, 4,17, 6, 6, 4, 5, 8,11,16, 6, 6,17, 8,
+ 6, 5, 6, 9,13,16, 8, 9,17,11, 9, 8, 8,11,13,17,
+ 9,12,17,15,14,13,12,13,14,17,12,15,17,17,17,17,
+ 17,16,17,17,
+};
+
+static const static_codebook _huff_book__8c0_s_single = {
+ 2, 100,
+ (long *)_huff_lengthlist__8c0_s_single,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__8c1_s_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__8c1_s_p1_0[] = {
+ 1, 5, 5, 0, 0, 0, 0, 0, 0, 5, 7, 7, 0, 0, 0, 0,
+ 0, 0, 5, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 5, 8, 7, 0, 0, 0, 0, 0, 0, 7, 8, 9, 0, 0, 0,
+ 0, 0, 0, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 5, 7, 8, 0, 0, 0, 0, 0, 0, 7, 9, 8, 0, 0,
+ 0, 0, 0, 0, 7, 9, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 8, 8, 0, 0, 0, 0,
+ 0, 0, 8, 9, 9, 0, 0, 0, 0, 0, 0, 8, 9, 9, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 9, 9, 0, 0, 0,
+ 0, 0, 0, 8, 8,10, 0, 0, 0, 0, 0, 0, 9,10,10, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 9, 9, 0, 0,
+ 0, 0, 0, 0, 8,10, 9, 0, 0, 0, 0, 0, 0, 9,10,10,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 5, 8, 8, 0, 0, 0, 0, 0, 0, 8, 9, 9, 0, 0,
+ 0, 0, 0, 0, 8, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 7, 9, 9, 0, 0, 0, 0, 0, 0, 9,10,10, 0,
+ 0, 0, 0, 0, 0, 8, 9,10, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 7, 9, 9, 0, 0, 0, 0, 0, 0, 9,10,10,
+ 0, 0, 0, 0, 0, 0, 8,10, 8, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _8c1_s_p1_0 = {
+ 8, 6561,
+ (long *)_vq_lengthlist__8c1_s_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__8c1_s_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__8c1_s_p3_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__8c1_s_p3_0[] = {
+ 2, 4, 4, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 6, 6, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 4, 4, 4, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 7, 7,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 6, 6, 6, 7, 7, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _8c1_s_p3_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__8c1_s_p3_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__8c1_s_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__8c1_s_p4_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__8c1_s_p4_0[] = {
+ 1, 2, 3, 7, 7, 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0,
+ 0, 0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0, 0, 7, 7,
+ 0, 0, 0, 0, 0, 0, 0, 7, 7, 0, 0, 0, 0, 0, 0, 0,
+ 8, 8, 0, 0, 0, 0, 0, 0, 0, 9, 8, 0, 0, 0, 0, 0,
+ 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _8c1_s_p4_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__8c1_s_p4_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__8c1_s_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__8c1_s_p5_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__8c1_s_p5_0[] = {
+ 1, 3, 3, 4, 5, 6, 6, 8, 8, 0, 0, 0, 8, 8, 7, 7,
+ 9, 9, 0, 0, 0, 8, 8, 7, 7, 9, 9, 0, 0, 0, 9,10,
+ 8, 8, 9, 9, 0, 0, 0,10,10, 8, 8, 9, 9, 0, 0, 0,
+ 11,10, 8, 8,10,10, 0, 0, 0,11,11, 8, 8,10,10, 0,
+ 0, 0,12,12, 9, 9,10,10, 0, 0, 0, 0, 0, 9, 9,10,
+ 10,
+};
+
+static const static_codebook _8c1_s_p5_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__8c1_s_p5_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__8c1_s_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__8c1_s_p6_0[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__8c1_s_p6_0[] = {
+ 1, 3, 3, 5, 5, 8, 8, 8, 8, 9, 9,10,10,11,11,11,
+ 11, 0, 0, 0, 8, 8, 8, 8, 9, 9, 9, 9,10,10,11,11,
+ 12,12, 0, 0, 0, 8, 8, 8, 8, 9, 9, 9, 9,10,10,11,
+ 11,12,12, 0, 0, 0, 9, 9, 8, 8,10,10,10,10,11,11,
+ 12,12,12,12, 0, 0, 0, 9, 9, 8, 8,10,10,10,10,11,
+ 11,12,12,12,12, 0, 0, 0,10,10, 9, 9,10,10,10,10,
+ 11,11,12,12,13,13, 0, 0, 0,10,10, 9, 9,10,10,10,
+ 10,11,11,12,12,13,13, 0, 0, 0,11,11, 9, 9,10,10,
+ 10,10,11,11,12,12,13,13, 0, 0, 0, 0, 0, 9, 9,10,
+ 10,10,10,11,11,12,12,13,13, 0, 0, 0, 0, 0, 9, 9,
+ 10,10,11,11,12,12,12,12,13,13, 0, 0, 0, 0, 0, 9,
+ 9,10,10,11,11,12,11,12,12,13,13, 0, 0, 0, 0, 0,
+ 10,10,11,11,11,11,12,12,13,12,13,13, 0, 0, 0, 0,
+ 0, 0, 0,11,10,11,11,12,12,13,13,13,13, 0, 0, 0,
+ 0, 0, 0, 0,11,11,12,12,12,12,13,13,13,14, 0, 0,
+ 0, 0, 0, 0, 0,11,11,12,12,12,12,13,13,14,13, 0,
+ 0, 0, 0, 0, 0, 0,12,12,12,12,13,13,13,13,14,14,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,12,12,13,13,13,13,14,
+ 14,
+};
+
+static const static_codebook _8c1_s_p6_0 = {
+ 2, 289,
+ (long *)_vq_lengthlist__8c1_s_p6_0,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__8c1_s_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__8c1_s_p7_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__8c1_s_p7_0[] = {
+ 1, 4, 4, 6, 6, 6, 7, 6, 6, 4, 7, 7,10, 9, 9,10,
+ 9, 9, 5, 7, 7,10, 9, 9,10, 9, 9, 6,10,10,10,10,
+ 10,11,10,10, 6, 9, 9,10, 9,10,11,10,10, 6, 9, 9,
+ 10, 9, 9,11, 9,10, 7,10,10,11,11,11,11,10,10, 6,
+ 9, 9,10,10,10,11, 9, 9, 6, 9, 9,10,10,10,10, 9,
+ 9,
+};
+
+static const static_codebook _8c1_s_p7_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__8c1_s_p7_0,
+ 1, -529137664, 1618345984, 2, 0,
+ (long *)_vq_quantlist__8c1_s_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__8c1_s_p7_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__8c1_s_p7_1[] = {
+ 2, 3, 3, 5, 5, 7, 7, 7, 7, 7, 7,10,10, 9, 7, 7,
+ 7, 7, 8, 8, 8, 8, 9, 9, 9, 7, 7, 7, 7, 8, 8, 8,
+ 8,10,10,10, 7, 7, 7, 7, 8, 8, 8, 8,10,10,10, 7,
+ 7, 7, 7, 8, 8, 8, 8,10,10,10, 8, 8, 8, 8, 8, 8,
+ 8, 8,10,10,10, 8, 8, 8, 8, 8, 8, 8, 8,10,10,10,
+ 8, 8, 8, 8, 8, 8, 8, 8,10,10,10,10,10, 8, 8, 8,
+ 8, 8, 8,10,10,10,10,10, 8, 8, 8, 8, 8, 8,10,10,
+ 10,10,10, 8, 8, 8, 8, 8, 8,
+};
+
+static const static_codebook _8c1_s_p7_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__8c1_s_p7_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__8c1_s_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__8c1_s_p8_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__8c1_s_p8_0[] = {
+ 1, 4, 4, 6, 6, 8, 8, 8, 8, 9, 9,10,10, 7, 5, 5,
+ 7, 7, 8, 8, 8, 8, 9,10,11,11, 7, 5, 5, 7, 7, 8,
+ 8, 9, 9,10,10,11,11, 0, 8, 8, 8, 8, 9, 9, 9, 9,
+ 9,10,11,11, 0, 8, 8, 8, 8, 9, 9, 9, 9,10,10,11,
+ 11, 0,12,12, 9, 9, 9, 9,10, 9,10,11,11,11, 0,13,
+ 12, 9, 8, 9, 9,10,10,11,11,12,11, 0, 0, 0, 9, 9,
+ 9, 9,10,10,11,11,12,12, 0, 0, 0,10,10, 9, 9,10,
+ 10,11,11,12,12, 0, 0, 0,13,13,10,10,11,11,12,11,
+ 13,12, 0, 0, 0,14,14,10,10,11,10,11,11,12,12, 0,
+ 0, 0, 0, 0,12,12,11,11,12,12,13,13, 0, 0, 0, 0,
+ 0,12,12,11,10,12,11,13,12,
+};
+
+static const static_codebook _8c1_s_p8_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__8c1_s_p8_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__8c1_s_p8_0,
+ 0
+};
+
+static const long _vq_quantlist__8c1_s_p8_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__8c1_s_p8_1[] = {
+ 2, 3, 3, 5, 5, 6, 6, 6, 5, 5, 6, 6, 6, 5, 5, 6,
+ 6, 6, 5, 5, 6, 6, 6, 5, 5,
+};
+
+static const static_codebook _8c1_s_p8_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__8c1_s_p8_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__8c1_s_p8_1,
+ 0
+};
+
+static const long _vq_quantlist__8c1_s_p9_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__8c1_s_p9_0[] = {
+ 1, 3, 3,10,10,10,10,10,10,10,10,10,10, 5, 6, 6,
+ 10,10,10,10,10,10,10,10,10,10, 6, 7, 8,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10, 9, 9, 9, 9,
+};
+
+static const static_codebook _8c1_s_p9_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__8c1_s_p9_0,
+ 1, -513964032, 1628680192, 4, 0,
+ (long *)_vq_quantlist__8c1_s_p9_0,
+ 0
+};
+
+static const long _vq_quantlist__8c1_s_p9_1[] = {
+ 7,
+ 6,
+ 8,
+ 5,
+ 9,
+ 4,
+ 10,
+ 3,
+ 11,
+ 2,
+ 12,
+ 1,
+ 13,
+ 0,
+ 14,
+};
+
+static const long _vq_lengthlist__8c1_s_p9_1[] = {
+ 1, 4, 4, 5, 5, 7, 7, 9, 9,11,11,12,12,13,13, 6,
+ 5, 5, 6, 6, 9, 9,10,10,12,12,12,13,15,14, 6, 5,
+ 5, 7, 7, 9, 9,10,10,12,12,12,13,14,13,17, 7, 7,
+ 8, 8,10,10,11,11,12,13,13,13,13,13,17, 7, 7, 8,
+ 8,10,10,11,11,13,13,13,13,14,14,17,11,11, 9, 9,
+ 11,11,12,12,12,13,13,14,15,13,17,12,12, 9, 9,11,
+ 11,12,12,13,13,13,13,14,16,17,17,17,11,12,12,12,
+ 13,13,13,14,15,14,15,15,17,17,17,12,12,11,11,13,
+ 13,14,14,15,14,15,15,17,17,17,15,15,13,13,14,14,
+ 15,14,15,15,16,15,17,17,17,15,15,13,13,13,14,14,
+ 15,15,15,15,16,17,17,17,17,16,14,15,14,14,15,14,
+ 14,15,15,15,17,17,17,17,17,14,14,16,14,15,15,15,
+ 15,15,15,17,17,17,17,17,17,16,16,15,17,15,15,14,
+ 17,15,17,16,17,17,17,17,16,15,14,15,15,15,15,15,
+ 15,
+};
+
+static const static_codebook _8c1_s_p9_1 = {
+ 2, 225,
+ (long *)_vq_lengthlist__8c1_s_p9_1,
+ 1, -520986624, 1620377600, 4, 0,
+ (long *)_vq_quantlist__8c1_s_p9_1,
+ 0
+};
+
+static const long _vq_quantlist__8c1_s_p9_2[] = {
+ 10,
+ 9,
+ 11,
+ 8,
+ 12,
+ 7,
+ 13,
+ 6,
+ 14,
+ 5,
+ 15,
+ 4,
+ 16,
+ 3,
+ 17,
+ 2,
+ 18,
+ 1,
+ 19,
+ 0,
+ 20,
+};
+
+static const long _vq_lengthlist__8c1_s_p9_2[] = {
+ 2, 4, 4, 6, 6, 7, 7, 8, 8, 8, 8, 9, 8, 9, 9, 9,
+ 9, 9, 9, 9, 9,11,11,12, 7, 7, 7, 7, 8, 8, 9, 9,
+ 9, 9,10,10,10,10,10,10,10,10,11,11,11, 7, 7, 7,
+ 7, 8, 8, 9, 8, 9, 9, 9, 9, 9, 9,10,10,10,10,11,
+ 11,12, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9,10,10,10,10,
+ 10,10,10,10,11,11,11, 7, 7, 8, 8, 8, 8, 9, 9, 9,
+ 9,10,10,10,10,10,10,10,10,11,11,11, 8, 8, 8, 8,
+ 9, 9, 9, 9, 9, 9,10,10,10,10,10,10,10,10,11,11,
+ 11, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9,10,10,10,10,10,
+ 10,10,10,11,12,11, 9, 9, 8, 9, 9, 9, 9, 9,10,10,
+ 10,10,10,10,10,10,10,10,11,11,11,11,11, 8, 8, 9,
+ 9, 9, 9,10,10,10,10,10,10,10,10,10,10,11,12,11,
+ 12,11, 9, 9, 9, 9, 9,10,10,10,10,10,10,10,10,10,
+ 10,10,11,11,11,11,11, 9, 9, 9, 9,10,10,10,10,10,
+ 10,10,10,10,10,10,10,12,11,12,11,11, 9, 9, 9,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,12,11,11,11,
+ 11,11,11,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 11,11,11,12,11,11,12,11,10,10,10,10,10,10,10,10,
+ 10,10,10,10,11,10,11,11,11,11,11,11,11,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,11,11,12,11,12,
+ 11,11,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 11,11,12,11,12,11,11,11,11,10,10,10,10,10,10,10,
+ 10,10,10,10,10,11,11,12,11,11,12,11,11,12,10,10,
+ 11,10,10,10,10,10,10,10,10,10,11,11,11,11,11,11,
+ 11,11,11,10,10,10,10,10,10,10,10,10,10,10,10,12,
+ 12,11,12,11,11,12,12,12,11,11,10,10,10,10,10,10,
+ 10,10,10,11,12,12,11,12,12,11,12,11,11,11,11,10,
+ 10,10,10,10,10,10,10,10,10,
+};
+
+static const static_codebook _8c1_s_p9_2 = {
+ 2, 441,
+ (long *)_vq_lengthlist__8c1_s_p9_2,
+ 1, -529268736, 1611661312, 5, 0,
+ (long *)_vq_quantlist__8c1_s_p9_2,
+ 0
+};
+
+static const long _huff_lengthlist__8c1_s_single[] = {
+ 4, 6,18, 8,11, 8, 8, 9, 9,10, 4, 4,18, 5, 9, 5,
+ 6, 7, 8,10,18,18,18,18,17,17,17,17,17,17, 7, 5,
+ 17, 6,11, 6, 7, 8, 9,12,12, 9,17,12, 8, 8, 9,10,
+ 10,13, 7, 5,17, 6, 8, 4, 5, 6, 8,10, 6, 5,17, 6,
+ 8, 5, 4, 5, 7, 9, 7, 7,17, 8, 9, 6, 5, 5, 6, 8,
+ 8, 8,17, 9,11, 8, 6, 6, 6, 7, 9,10,17,12,12,10,
+ 9, 7, 7, 8,
+};
+
+static const static_codebook _huff_book__8c1_s_single = {
+ 2, 100,
+ (long *)_huff_lengthlist__8c1_s_single,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44c2_s_long[] = {
+ 6, 6,12,10,10,10, 9,10,12,12, 6, 1,10, 5, 6, 6,
+ 7, 9,11,14,12, 9, 8,11, 7, 8, 9,11,13,15,10, 5,
+ 12, 7, 8, 7, 9,12,14,15,10, 6, 7, 8, 5, 6, 7, 9,
+ 12,14, 9, 6, 8, 7, 6, 6, 7, 9,12,12, 9, 7, 9, 9,
+ 7, 6, 6, 7,10,10,10, 9,10,11, 8, 7, 6, 6, 8,10,
+ 12,11,13,13,11,10, 8, 8, 8,10,11,13,15,15,14,13,
+ 10, 8, 8, 9,
+};
+
+static const static_codebook _huff_book__44c2_s_long = {
+ 2, 100,
+ (long *)_huff_lengthlist__44c2_s_long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44c2_s_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44c2_s_p1_0[] = {
+ 2, 4, 4, 0, 0, 0, 0, 0, 0, 5, 6, 6, 0, 0, 0, 0,
+ 0, 0, 5, 6, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 5, 7, 7, 0, 0, 0, 0, 0, 0, 7, 8, 8, 0, 0, 0,
+ 0, 0, 0, 6, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 5, 7, 7, 0, 0, 0, 0, 0, 0, 6, 8, 7, 0, 0,
+ 0, 0, 0, 0, 7, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 7, 7, 0, 0, 0, 0,
+ 0, 0, 7, 8, 8, 0, 0, 0, 0, 0, 0, 7, 8, 8, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 8, 0, 0, 0,
+ 0, 0, 0, 8, 9, 9, 0, 0, 0, 0, 0, 0, 8, 9, 9, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 8, 8, 0, 0,
+ 0, 0, 0, 0, 8, 9, 8, 0, 0, 0, 0, 0, 0, 8, 9, 9,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 4, 7, 7, 0, 0, 0, 0, 0, 0, 7, 8, 8, 0, 0,
+ 0, 0, 0, 0, 7, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 6, 8, 8, 0, 0, 0, 0, 0, 0, 8, 9, 9, 0,
+ 0, 0, 0, 0, 0, 8, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 7, 8, 8, 0, 0, 0, 0, 0, 0, 8, 9, 9,
+ 0, 0, 0, 0, 0, 0, 8, 9, 9, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c2_s_p1_0 = {
+ 8, 6561,
+ (long *)_vq_lengthlist__44c2_s_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44c2_s_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44c2_s_p2_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44c2_s_p2_0[] = {
+ 1, 4, 4, 0, 0, 0, 7, 7, 0, 0, 0, 7, 7, 0, 0, 0,
+ 8, 8, 0, 0, 0, 0, 0, 0, 0, 4, 6, 6, 0, 0, 0, 8,
+ 8, 0, 0, 0, 8, 8, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0,
+ 0, 0, 4, 6, 6, 0, 0, 0, 8, 8, 0, 0, 0, 8, 8, 0,
+ 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 7, 8, 8, 0, 0, 0,11,11, 0, 0,
+ 0,11,11, 0, 0, 0,12,11, 0, 0, 0, 0, 0, 0, 0, 7,
+ 8, 8, 0, 0, 0,10,11, 0, 0, 0,11,11, 0, 0, 0,11,
+ 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 6, 8, 8, 0, 0, 0,11,11, 0, 0, 0,11,11,
+ 0, 0, 0,12,12, 0, 0, 0, 0, 0, 0, 0, 6, 8, 8, 0,
+ 0, 0,10,11, 0, 0, 0,10,11, 0, 0, 0,11,11, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 8, 9, 9, 0, 0, 0,11,12, 0, 0, 0,11,12, 0, 0, 0,
+ 12,11, 0, 0, 0, 0, 0, 0, 0, 8,10, 9, 0, 0, 0,12,
+ 11, 0, 0, 0,12,11, 0, 0, 0,11,12, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c2_s_p2_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44c2_s_p2_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44c2_s_p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44c2_s_p3_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44c2_s_p3_0[] = {
+ 2, 4, 3, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 6, 6, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 4, 4, 4, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 9, 9,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 6, 6, 7, 9, 9, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c2_s_p3_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44c2_s_p3_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44c2_s_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44c2_s_p4_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44c2_s_p4_0[] = {
+ 1, 3, 3, 6, 6, 0, 0, 0, 0, 0, 6, 6, 6, 6, 0, 0,
+ 0, 0, 0, 6, 6, 6, 6, 0, 0, 0, 0, 0, 7, 7, 6, 6,
+ 0, 0, 0, 0, 0, 0, 0, 6, 7, 0, 0, 0, 0, 0, 0, 0,
+ 7, 8, 0, 0, 0, 0, 0, 0, 0, 8, 8, 0, 0, 0, 0, 0,
+ 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c2_s_p4_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44c2_s_p4_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c2_s_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44c2_s_p5_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44c2_s_p5_0[] = {
+ 1, 3, 3, 6, 6, 7, 7, 9, 9, 0, 7, 7, 7, 7, 7, 7,
+ 9, 9, 0, 7, 7, 7, 7, 7, 7, 9, 9, 0, 8, 8, 7, 7,
+ 8, 8,10,10, 0, 0, 0, 7, 7, 8, 8,10,10, 0, 0, 0,
+ 9, 9, 8, 8,10,10, 0, 0, 0, 9, 9, 8, 8,10,10, 0,
+ 0, 0,10,10, 9, 9,11,11, 0, 0, 0, 0, 0, 9, 9,11,
+ 11,
+};
+
+static const static_codebook _44c2_s_p5_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44c2_s_p5_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c2_s_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44c2_s_p6_0[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44c2_s_p6_0[] = {
+ 1, 4, 3, 6, 6, 8, 8, 9, 9, 9, 9, 9, 9,10,10,11,
+ 11, 0, 7, 7, 7, 7, 8, 8, 9, 9, 9, 9,10,10,11,11,
+ 12,11, 0, 7, 7, 7, 7, 8, 8, 9, 9, 9, 9,10,10,11,
+ 11,11,12, 0, 8, 8, 7, 7, 9, 9,10,10, 9, 9,10,10,
+ 11,11,12,12, 0, 0, 0, 7, 7, 9, 9,10,10,10, 9,10,
+ 10,11,11,12,12, 0, 0, 0, 8, 8, 9, 9,10,10,10,10,
+ 11,11,11,11,12,12, 0, 0, 0, 8, 8, 9, 9,10,10,10,
+ 10,11,11,12,12,12,12, 0, 0, 0, 9, 9, 9, 9,10,10,
+ 10,10,11,11,12,12,12,12, 0, 0, 0, 0, 0, 9, 9,10,
+ 10,10,10,11,11,12,12,13,13, 0, 0, 0, 0, 0, 9, 9,
+ 10,10,11,11,11,11,12,12,13,13, 0, 0, 0, 0, 0, 9,
+ 9,10,10,11,11,11,11,12,12,13,13, 0, 0, 0, 0, 0,
+ 10,10,10,10,11,11,12,12,13,12,13,13, 0, 0, 0, 0,
+ 0, 0, 0,10,10,11,11,12,12,13,13,13,13, 0, 0, 0,
+ 0, 0, 0, 0,11,11,12,12,12,12,13,13,13,14, 0, 0,
+ 0, 0, 0, 0, 0,11,11,12,12,12,12,13,13,13,14, 0,
+ 0, 0, 0, 0, 0, 0,12,12,12,12,13,13,13,13,14,14,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,12,12,13,13,13,13,14,
+ 14,
+};
+
+static const static_codebook _44c2_s_p6_0 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44c2_s_p6_0,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44c2_s_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44c2_s_p7_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44c2_s_p7_0[] = {
+ 1, 4, 4, 7, 6, 6, 7, 6, 6, 4, 7, 7,10, 9, 9,11,
+ 9, 9, 4, 7, 7,10, 9, 9,10, 9, 9, 7,10,10,11,10,
+ 11,11,10,11, 6, 9, 9,11,10,10,11,10,10, 6, 9, 9,
+ 11,10,11,11,10,10, 7,11,10,11,11,11,12,11,11, 6,
+ 9, 9,11,10,10,11,11,10, 6, 9, 9,11,10,10,12,10,
+ 11,
+};
+
+static const static_codebook _44c2_s_p7_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44c2_s_p7_0,
+ 1, -529137664, 1618345984, 2, 0,
+ (long *)_vq_quantlist__44c2_s_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44c2_s_p7_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44c2_s_p7_1[] = {
+ 2, 3, 4, 6, 6, 7, 7, 7, 7, 7, 7, 9, 7, 7, 6, 6,
+ 7, 7, 8, 8, 8, 8, 9, 6, 6, 6, 6, 7, 7, 8, 8, 8,
+ 8,10, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8,10,10,10, 7,
+ 7, 7, 7, 8, 8, 8, 8,10,10,10, 7, 7, 8, 8, 8, 8,
+ 8, 8,10,10,10, 7, 8, 8, 8, 8, 8, 8, 8,10,10,10,
+ 8, 8, 8, 8, 8, 8, 8, 8,10,10,10,10,10, 8, 8, 8,
+ 8, 8, 8,10,10,10,10,10, 9, 9, 8, 8, 8, 8,10,10,
+ 10,10,10, 8, 8, 8, 8, 8, 8,
+};
+
+static const static_codebook _44c2_s_p7_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44c2_s_p7_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c2_s_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44c2_s_p8_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c2_s_p8_0[] = {
+ 1, 4, 4, 6, 6, 7, 7, 7, 7, 8, 8, 9, 9, 6, 5, 5,
+ 7, 7, 8, 8, 8, 8, 9, 9,10,10, 7, 6, 5, 7, 7, 8,
+ 8, 8, 8, 9, 9,10,10, 0, 8, 8, 8, 8, 9, 9, 9, 9,
+ 10,10,11,11, 0, 8, 8, 8, 8, 9, 9, 9, 9,10,10,11,
+ 11, 0,12,12, 9, 9,10,10,10,10,11,11,11,11, 0,13,
+ 13, 9, 9,10,10,10,10,11,11,12,12, 0, 0, 0,10,10,
+ 10,10,11,11,12,12,12,13, 0, 0, 0,10,10,10,10,11,
+ 11,12,12,12,12, 0, 0, 0,14,14,10,11,11,11,12,12,
+ 13,13, 0, 0, 0,14,14,11,10,11,11,13,12,13,13, 0,
+ 0, 0, 0, 0,12,12,11,12,13,12,14,14, 0, 0, 0, 0,
+ 0,12,12,12,12,13,12,14,14,
+};
+
+static const static_codebook _44c2_s_p8_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c2_s_p8_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44c2_s_p8_0,
+ 0
+};
+
+static const long _vq_quantlist__44c2_s_p8_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44c2_s_p8_1[] = {
+ 2, 4, 4, 5, 4, 6, 5, 5, 5, 5, 6, 5, 5, 5, 5, 6,
+ 5, 5, 5, 5, 6, 6, 6, 5, 5,
+};
+
+static const static_codebook _44c2_s_p8_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44c2_s_p8_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44c2_s_p8_1,
+ 0
+};
+
+static const long _vq_quantlist__44c2_s_p9_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c2_s_p9_0[] = {
+ 1, 5, 4,12,12,12,12,12,12,12,12,12,12, 4, 9, 8,
+ 11,11,11,11,11,11,11,11,11,11, 2, 8, 7,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,10,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,
+};
+
+static const static_codebook _44c2_s_p9_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c2_s_p9_0,
+ 1, -514541568, 1627103232, 4, 0,
+ (long *)_vq_quantlist__44c2_s_p9_0,
+ 0
+};
+
+static const long _vq_quantlist__44c2_s_p9_1[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c2_s_p9_1[] = {
+ 1, 4, 4, 6, 6, 7, 6, 8, 8,10, 9,10,10, 6, 5, 5,
+ 7, 7, 8, 7,10, 9,11,11,12,13, 6, 5, 5, 7, 7, 8,
+ 8,10,10,11,11,13,13,18, 8, 8, 8, 8, 9, 9,10,10,
+ 12,12,12,13,18, 8, 8, 8, 8, 9, 9,10,10,12,12,13,
+ 13,18,11,11, 8, 8,10,10,11,11,12,11,13,12,18,11,
+ 11, 9, 7,10,10,11,11,11,12,12,13,17,17,17,10,10,
+ 11,11,12,12,12,10,12,12,17,17,17,11,10,11,10,13,
+ 12,11,12,12,12,17,17,17,15,14,11,11,12,11,13,10,
+ 13,12,17,17,17,14,14,12,10,11,11,13,13,13,13,17,
+ 17,16,17,16,13,13,12,10,13,10,14,13,17,16,17,16,
+ 17,13,12,12,10,13,11,14,14,
+};
+
+static const static_codebook _44c2_s_p9_1 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c2_s_p9_1,
+ 1, -522616832, 1620115456, 4, 0,
+ (long *)_vq_quantlist__44c2_s_p9_1,
+ 0
+};
+
+static const long _vq_quantlist__44c2_s_p9_2[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44c2_s_p9_2[] = {
+ 2, 4, 4, 6, 6, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8,
+ 8,10, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9,
+ 9, 9,10, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9,
+ 9, 9, 9,10, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9,
+ 9, 9, 9, 9,10,10,10, 8, 7, 8, 8, 8, 8, 9, 9, 9,
+ 9, 9, 9, 9, 9,10,11,11, 8, 8, 8, 8, 9, 9, 9, 9,
+ 9, 9,10, 9, 9, 9,10,11,10, 8, 8, 8, 8, 9, 9, 9,
+ 9, 9, 9, 9,10,10,10,10,11,10, 8, 8, 9, 9, 9, 9,
+ 9, 9,10, 9, 9,10, 9,10,11,10,11,11,11, 8, 8, 9,
+ 9, 9, 9, 9, 9, 9, 9,10,10,11,11,11,11,11, 9, 9,
+ 9, 9, 9, 9,10, 9, 9, 9,10,10,11,11,11,11,11, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9,10, 9,10,11,11,11,11,11,
+ 9, 9, 9, 9,10,10, 9, 9, 9,10,10,10,11,11,11,11,
+ 11,11,11, 9, 9, 9,10, 9, 9,10,10,10,10,11,11,10,
+ 11,11,11,11,10, 9,10,10, 9, 9, 9, 9,10,10,11,10,
+ 11,11,11,11,11, 9, 9, 9, 9,10, 9,10,10,10,10,11,
+ 10,11,11,11,11,11,10,10, 9, 9,10, 9,10,10,10,10,
+ 10,10,10,11,11,11,11,11,11, 9, 9,10, 9,10, 9,10,
+ 10,
+};
+
+static const static_codebook _44c2_s_p9_2 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44c2_s_p9_2,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44c2_s_p9_2,
+ 0
+};
+
+static const long _huff_lengthlist__44c2_s_short[] = {
+ 11, 9,13,12,12,11,12,12,13,15, 8, 2,11, 4, 8, 5,
+ 7,10,12,15,13, 7,10, 9, 8, 8,10,13,17,17,11, 4,
+ 12, 5, 9, 5, 8,11,14,16,12, 6, 8, 7, 6, 6, 8,11,
+ 13,16,11, 4, 9, 5, 6, 4, 6,10,13,16,11, 6,11, 7,
+ 7, 6, 7,10,13,15,13, 9,12, 9, 8, 6, 8,10,12,14,
+ 14,10,10, 8, 6, 5, 6, 9,11,13,15,11,11, 9, 6, 5,
+ 6, 8, 9,12,
+};
+
+static const static_codebook _huff_book__44c2_s_short = {
+ 2, 100,
+ (long *)_huff_lengthlist__44c2_s_short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44c3_s_long[] = {
+ 5, 6,11,11,11,11,10,10,12,11, 5, 2,11, 5, 6, 6,
+ 7, 9,11,13,13,10, 7,11, 6, 7, 8, 9,10,12,11, 5,
+ 11, 6, 8, 7, 9,11,14,15,11, 6, 6, 8, 4, 5, 7, 8,
+ 10,13,10, 5, 7, 7, 5, 5, 6, 8,10,11,10, 7, 7, 8,
+ 6, 5, 5, 7, 9, 9,11, 8, 8,11, 8, 7, 6, 6, 7, 9,
+ 12,11,10,13, 9, 9, 7, 7, 7, 9,11,13,12,15,12,11,
+ 9, 8, 8, 8,
+};
+
+static const static_codebook _huff_book__44c3_s_long = {
+ 2, 100,
+ (long *)_huff_lengthlist__44c3_s_long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44c3_s_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44c3_s_p1_0[] = {
+ 2, 4, 4, 0, 0, 0, 0, 0, 0, 5, 6, 6, 0, 0, 0, 0,
+ 0, 0, 5, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 5, 7, 7, 0, 0, 0, 0, 0, 0, 7, 8, 8, 0, 0, 0,
+ 0, 0, 0, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 5, 7, 7, 0, 0, 0, 0, 0, 0, 6, 8, 7, 0, 0,
+ 0, 0, 0, 0, 7, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 7, 7, 0, 0, 0, 0,
+ 0, 0, 7, 8, 8, 0, 0, 0, 0, 0, 0, 7, 8, 8, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 8, 0, 0, 0,
+ 0, 0, 0, 8, 8, 9, 0, 0, 0, 0, 0, 0, 8, 9, 9, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 8, 8, 0, 0,
+ 0, 0, 0, 0, 7, 9, 8, 0, 0, 0, 0, 0, 0, 8, 9, 9,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 5, 7, 7, 0, 0, 0, 0, 0, 0, 7, 8, 8, 0, 0,
+ 0, 0, 0, 0, 7, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 6, 8, 8, 0, 0, 0, 0, 0, 0, 8, 9, 9, 0,
+ 0, 0, 0, 0, 0, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 6, 8, 8, 0, 0, 0, 0, 0, 0, 8, 9, 9,
+ 0, 0, 0, 0, 0, 0, 8, 9, 8, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c3_s_p1_0 = {
+ 8, 6561,
+ (long *)_vq_lengthlist__44c3_s_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44c3_s_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44c3_s_p2_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44c3_s_p2_0[] = {
+ 2, 5, 5, 0, 0, 0, 5, 5, 0, 0, 0, 5, 5, 0, 0, 0,
+ 7, 8, 0, 0, 0, 0, 0, 0, 0, 5, 6, 6, 0, 0, 0, 7,
+ 7, 0, 0, 0, 7, 7, 0, 0, 0,10,10, 0, 0, 0, 0, 0,
+ 0, 0, 5, 6, 6, 0, 0, 0, 7, 7, 0, 0, 0, 7, 7, 0,
+ 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 5, 7, 7, 0, 0, 0, 7, 7, 0, 0,
+ 0, 7, 7, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 5,
+ 7, 7, 0, 0, 0, 7, 7, 0, 0, 0, 7, 7, 0, 0, 0, 9,
+ 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 5, 7, 7, 0, 0, 0, 7, 7, 0, 0, 0, 7, 7,
+ 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 5, 7, 7, 0,
+ 0, 0, 7, 7, 0, 0, 0, 7, 7, 0, 0, 0, 9, 9, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 8,10,10, 0, 0, 0, 9, 9, 0, 0, 0, 9, 9, 0, 0, 0,
+ 10,10, 0, 0, 0, 0, 0, 0, 0, 8,10,10, 0, 0, 0, 9,
+ 9, 0, 0, 0, 9, 9, 0, 0, 0,10,10, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c3_s_p2_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44c3_s_p2_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44c3_s_p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44c3_s_p3_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44c3_s_p3_0[] = {
+ 2, 4, 3, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 6, 6, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 4, 4, 4, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 9, 9,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 6, 6, 7, 9, 9, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c3_s_p3_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44c3_s_p3_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44c3_s_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44c3_s_p4_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44c3_s_p4_0[] = {
+ 2, 3, 3, 6, 6, 0, 0, 0, 0, 0, 4, 4, 6, 6, 0, 0,
+ 0, 0, 0, 4, 4, 6, 6, 0, 0, 0, 0, 0, 5, 5, 6, 6,
+ 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0, 0,
+ 7, 8, 0, 0, 0, 0, 0, 0, 0, 7, 7, 0, 0, 0, 0, 0,
+ 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c3_s_p4_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44c3_s_p4_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c3_s_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44c3_s_p5_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44c3_s_p5_0[] = {
+ 1, 3, 4, 6, 6, 7, 7, 9, 9, 0, 5, 5, 7, 7, 7, 8,
+ 9, 9, 0, 5, 5, 7, 7, 8, 8, 9, 9, 0, 7, 7, 8, 8,
+ 8, 8,10,10, 0, 0, 0, 8, 8, 8, 8,10,10, 0, 0, 0,
+ 9, 9, 9, 9,10,10, 0, 0, 0, 9, 9, 9, 9,10,10, 0,
+ 0, 0,10,10,10,10,11,11, 0, 0, 0, 0, 0,10,10,11,
+ 11,
+};
+
+static const static_codebook _44c3_s_p5_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44c3_s_p5_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c3_s_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44c3_s_p6_0[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44c3_s_p6_0[] = {
+ 2, 3, 3, 6, 6, 7, 7, 8, 8, 8, 8, 9, 9,10,10,11,
+ 10, 0, 5, 5, 7, 7, 8, 8, 9, 9, 9, 9,10,10,10,10,
+ 11,11, 0, 5, 5, 7, 7, 8, 8, 9, 9, 9, 9,10,10,10,
+ 10,11,11, 0, 6, 6, 7, 7, 8, 8, 9, 9, 9, 9,10,10,
+ 11,11,11,11, 0, 0, 0, 7, 7, 8, 8, 9, 9, 9, 9,10,
+ 10,11,11,11,12, 0, 0, 0, 8, 8, 8, 8, 9, 9, 9, 9,
+ 10,10,11,11,12,12, 0, 0, 0, 8, 8, 8, 8, 9, 9, 9,
+ 9,10,10,11,11,12,12, 0, 0, 0, 9, 9, 9, 9,10,10,
+ 10,10,11,10,11,11,12,12, 0, 0, 0, 0, 0, 9, 9,10,
+ 10,10,10,11,11,11,11,12,12, 0, 0, 0, 0, 0, 9, 8,
+ 9, 9,10,10,11,11,12,12,12,12, 0, 0, 0, 0, 0, 8,
+ 8, 9, 9,10,10,11,11,12,11,12,12, 0, 0, 0, 0, 0,
+ 9,10,10,10,11,11,11,11,12,12,13,13, 0, 0, 0, 0,
+ 0, 0, 0,10,10,10,10,11,11,12,12,13,13, 0, 0, 0,
+ 0, 0, 0, 0,11,11,11,11,12,12,12,12,13,13, 0, 0,
+ 0, 0, 0, 0, 0,11,11,11,11,12,12,12,12,13,13, 0,
+ 0, 0, 0, 0, 0, 0,11,11,12,12,12,12,13,13,13,13,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,12,12,12,12,13,13,13,
+ 13,
+};
+
+static const static_codebook _44c3_s_p6_0 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44c3_s_p6_0,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44c3_s_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44c3_s_p7_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44c3_s_p7_0[] = {
+ 1, 4, 4, 7, 6, 6, 7, 6, 6, 4, 7, 7,10, 9, 9,11,
+ 9, 9, 4, 7, 7,10, 9, 9,11, 9, 9, 7,10,10,11,11,
+ 10,12,11,11, 6, 9, 9,11,10,10,11,10,10, 6, 9, 9,
+ 11,10,10,11,10,10, 7,11,11,11,11,11,12,11,11, 6,
+ 9, 9,11,10,10,11,10,10, 6, 9, 9,11,10,10,11,10,
+ 10,
+};
+
+static const static_codebook _44c3_s_p7_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44c3_s_p7_0,
+ 1, -529137664, 1618345984, 2, 0,
+ (long *)_vq_quantlist__44c3_s_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44c3_s_p7_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44c3_s_p7_1[] = {
+ 2, 4, 4, 6, 6, 7, 7, 7, 7, 8, 8,10, 5, 5, 6, 6,
+ 7, 7, 8, 8, 8, 8,10, 5, 5, 6, 6, 7, 7, 8, 8, 8,
+ 8,10, 6, 6, 7, 7, 8, 8, 8, 8, 8, 8,10,10,10, 7,
+ 7, 8, 7, 8, 8, 8, 8,10,10,10, 8, 8, 8, 8, 8, 8,
+ 8, 8,10,10,10, 7, 8, 8, 8, 8, 8, 8, 8,10,10,10,
+ 8, 8, 8, 8, 8, 8, 8, 8,10,10,10,10,10, 8, 8, 8,
+ 8, 8, 8,10,10,10,10,10, 9, 9, 8, 8, 9, 8,10,10,
+ 10,10,10, 8, 8, 8, 8, 8, 8,
+};
+
+static const static_codebook _44c3_s_p7_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44c3_s_p7_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c3_s_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44c3_s_p8_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c3_s_p8_0[] = {
+ 1, 4, 4, 6, 6, 7, 7, 8, 8, 9, 9,10,10, 6, 5, 5,
+ 7, 7, 8, 8, 8, 8, 9, 9,10,10, 7, 5, 5, 7, 7, 8,
+ 8, 8, 8, 9, 9,11,10, 0, 8, 8, 8, 8, 9, 9, 9, 9,
+ 10,10,11,11, 0, 8, 8, 8, 8, 9, 9, 9, 9,10,10,11,
+ 11, 0,12,12, 9, 9,10,10,10,10,11,11,11,12, 0,13,
+ 13, 9, 9,10,10,10,10,11,11,12,12, 0, 0, 0,10,10,
+ 10,10,11,11,12,12,12,12, 0, 0, 0,10,10,10,10,11,
+ 11,12,12,12,12, 0, 0, 0,14,14,11,11,11,11,12,12,
+ 13,13, 0, 0, 0,14,14,11,11,11,11,12,12,13,13, 0,
+ 0, 0, 0, 0,12,12,12,12,13,13,14,13, 0, 0, 0, 0,
+ 0,13,13,12,12,13,12,14,13,
+};
+
+static const static_codebook _44c3_s_p8_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c3_s_p8_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44c3_s_p8_0,
+ 0
+};
+
+static const long _vq_quantlist__44c3_s_p8_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44c3_s_p8_1[] = {
+ 2, 4, 4, 5, 5, 6, 5, 5, 5, 5, 6, 4, 5, 5, 5, 6,
+ 5, 5, 5, 5, 6, 6, 6, 5, 5,
+};
+
+static const static_codebook _44c3_s_p8_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44c3_s_p8_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44c3_s_p8_1,
+ 0
+};
+
+static const long _vq_quantlist__44c3_s_p9_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c3_s_p9_0[] = {
+ 1, 4, 4,12,12,12,12,12,12,12,12,12,12, 4, 9, 8,
+ 12,12,12,12,12,12,12,12,12,12, 2, 9, 7,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,11,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,
+};
+
+static const static_codebook _44c3_s_p9_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c3_s_p9_0,
+ 1, -514332672, 1627381760, 4, 0,
+ (long *)_vq_quantlist__44c3_s_p9_0,
+ 0
+};
+
+static const long _vq_quantlist__44c3_s_p9_1[] = {
+ 7,
+ 6,
+ 8,
+ 5,
+ 9,
+ 4,
+ 10,
+ 3,
+ 11,
+ 2,
+ 12,
+ 1,
+ 13,
+ 0,
+ 14,
+};
+
+static const long _vq_lengthlist__44c3_s_p9_1[] = {
+ 1, 4, 4, 6, 6, 7, 7, 8, 7, 9, 9,10,10,10,10, 6,
+ 5, 5, 7, 7, 8, 8,10, 8,11,10,12,12,13,13, 6, 5,
+ 5, 7, 7, 8, 8,10, 9,11,11,12,12,13,12,18, 8, 8,
+ 8, 8, 9, 9,10, 9,11,10,12,12,13,13,18, 8, 8, 8,
+ 8, 9, 9,10,10,11,11,13,12,14,13,18,11,11, 9, 9,
+ 10,10,11,11,11,12,13,12,13,14,18,11,11, 9, 8,11,
+ 10,11,11,11,11,12,12,14,13,18,18,18,10,11,10,11,
+ 12,12,12,12,13,12,14,13,18,18,18,10,11,11, 9,12,
+ 11,12,12,12,13,13,13,18,18,17,14,14,11,11,12,12,
+ 13,12,14,12,14,13,18,18,18,14,14,11,10,12, 9,12,
+ 13,13,13,13,13,18,18,17,16,18,13,13,12,12,13,11,
+ 14,12,14,14,17,18,18,17,18,13,12,13,10,12,11,14,
+ 14,14,14,17,18,18,18,18,15,16,12,12,13,10,14,12,
+ 14,15,18,18,18,16,17,16,14,12,11,13,10,13,13,14,
+ 15,
+};
+
+static const static_codebook _44c3_s_p9_1 = {
+ 2, 225,
+ (long *)_vq_lengthlist__44c3_s_p9_1,
+ 1, -522338304, 1620115456, 4, 0,
+ (long *)_vq_quantlist__44c3_s_p9_1,
+ 0
+};
+
+static const long _vq_quantlist__44c3_s_p9_2[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44c3_s_p9_2[] = {
+ 2, 5, 5, 6, 6, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8,
+ 8,10, 6, 6, 7, 7, 8, 7, 8, 8, 8, 8, 8, 9, 9, 9,
+ 9, 9,10, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9,
+ 9, 9, 9,10, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9,
+ 9, 9, 9, 9,10,10,10, 7, 7, 8, 8, 8, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9,11,11,11, 8, 8, 8, 8, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9,10,10,10, 8, 8, 8, 8, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9,10,10,10, 8, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9,10, 9,10,10,10,11,11, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9,11,10,11,11,11, 9, 9,
+ 9, 9, 9, 9,10,10, 9, 9,10, 9,11,10,11,11,11, 9,
+ 9, 9, 9, 9, 9, 9, 9,10,10,10, 9,11,11,11,11,11,
+ 9, 9, 9, 9,10,10, 9, 9, 9, 9,10, 9,11,11,11,11,
+ 11,11,11, 9, 9, 9, 9, 9, 9,10,10,10,10,11,11,11,
+ 11,11,11,11,10, 9,10,10, 9,10, 9, 9,10, 9,11,10,
+ 10,11,11,11,11, 9,10, 9, 9, 9, 9,10,10,10,10,11,
+ 11,11,11,11,11,10,10,10, 9, 9,10, 9,10, 9,10,10,
+ 10,10,11,11,11,11,11,11,11, 9, 9, 9, 9, 9,10,10,
+ 10,
+};
+
+static const static_codebook _44c3_s_p9_2 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44c3_s_p9_2,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44c3_s_p9_2,
+ 0
+};
+
+static const long _huff_lengthlist__44c3_s_short[] = {
+ 10, 9,13,11,14,10,12,13,13,14, 7, 2,12, 5,10, 5,
+ 7,10,12,14,12, 6, 9, 8, 7, 7, 9,11,13,16,10, 4,
+ 12, 5,10, 6, 8,12,14,16,12, 6, 8, 7, 6, 5, 7,11,
+ 12,16,10, 4, 8, 5, 6, 4, 6, 9,13,16,10, 6,10, 7,
+ 7, 6, 7, 9,13,15,12, 9,11, 9, 8, 6, 7,10,12,14,
+ 14,11,10, 9, 6, 5, 6, 9,11,13,15,13,11,10, 6, 5,
+ 6, 8, 9,11,
+};
+
+static const static_codebook _huff_book__44c3_s_short = {
+ 2, 100,
+ (long *)_huff_lengthlist__44c3_s_short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44c4_s_long[] = {
+ 4, 7,11,11,11,11,10,11,12,11, 5, 2,11, 5, 6, 6,
+ 7, 9,11,12,11, 9, 6,10, 6, 7, 8, 9,10,11,11, 5,
+ 11, 7, 8, 8, 9,11,13,14,11, 6, 5, 8, 4, 5, 7, 8,
+ 10,11,10, 6, 7, 7, 5, 5, 6, 8, 9,11,10, 7, 8, 9,
+ 6, 6, 6, 7, 8, 9,11, 9, 9,11, 7, 7, 6, 6, 7, 9,
+ 12,12,10,13, 9, 8, 7, 7, 7, 8,11,13,11,14,11,10,
+ 9, 8, 7, 7,
+};
+
+static const static_codebook _huff_book__44c4_s_long = {
+ 2, 100,
+ (long *)_huff_lengthlist__44c4_s_long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44c4_s_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44c4_s_p1_0[] = {
+ 2, 4, 4, 0, 0, 0, 0, 0, 0, 5, 6, 6, 0, 0, 0, 0,
+ 0, 0, 5, 6, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 5, 7, 7, 0, 0, 0, 0, 0, 0, 7, 8, 8, 0, 0, 0,
+ 0, 0, 0, 6, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 5, 7, 7, 0, 0, 0, 0, 0, 0, 6, 8, 7, 0, 0,
+ 0, 0, 0, 0, 7, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 7, 7, 0, 0, 0, 0,
+ 0, 0, 7, 8, 8, 0, 0, 0, 0, 0, 0, 7, 8, 8, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 8, 0, 0, 0,
+ 0, 0, 0, 8, 9, 9, 0, 0, 0, 0, 0, 0, 8, 9, 9, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 8, 8, 0, 0,
+ 0, 0, 0, 0, 8, 9, 8, 0, 0, 0, 0, 0, 0, 8, 9, 9,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 4, 7, 7, 0, 0, 0, 0, 0, 0, 7, 8, 8, 0, 0,
+ 0, 0, 0, 0, 7, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 6, 8, 8, 0, 0, 0, 0, 0, 0, 8, 9, 9, 0,
+ 0, 0, 0, 0, 0, 8, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 7, 8, 8, 0, 0, 0, 0, 0, 0, 8, 9, 9,
+ 0, 0, 0, 0, 0, 0, 8, 9, 9, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c4_s_p1_0 = {
+ 8, 6561,
+ (long *)_vq_lengthlist__44c4_s_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44c4_s_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44c4_s_p2_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44c4_s_p2_0[] = {
+ 2, 5, 5, 0, 0, 0, 5, 5, 0, 0, 0, 5, 5, 0, 0, 0,
+ 7, 7, 0, 0, 0, 0, 0, 0, 0, 5, 6, 6, 0, 0, 0, 7,
+ 7, 0, 0, 0, 7, 7, 0, 0, 0,10,10, 0, 0, 0, 0, 0,
+ 0, 0, 5, 6, 6, 0, 0, 0, 7, 7, 0, 0, 0, 7, 7, 0,
+ 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 5, 8, 7, 0, 0, 0, 7, 7, 0, 0,
+ 0, 7, 7, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 5,
+ 7, 8, 0, 0, 0, 7, 7, 0, 0, 0, 7, 7, 0, 0, 0, 9,
+ 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 5, 7, 7, 0, 0, 0, 7, 7, 0, 0, 0, 7, 7,
+ 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 5, 7, 7, 0,
+ 0, 0, 7, 7, 0, 0, 0, 7, 7, 0, 0, 0, 9, 9, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 7,10,10, 0, 0, 0, 9, 9, 0, 0, 0, 9, 9, 0, 0, 0,
+ 10,10, 0, 0, 0, 0, 0, 0, 0, 8,10,10, 0, 0, 0, 9,
+ 9, 0, 0, 0, 9, 9, 0, 0, 0,10,10, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c4_s_p2_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44c4_s_p2_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44c4_s_p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44c4_s_p3_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44c4_s_p3_0[] = {
+ 2, 3, 3, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 5, 4, 6, 6, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 4, 4, 5, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 9, 9,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 6, 6, 7, 9, 9, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c4_s_p3_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44c4_s_p3_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44c4_s_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44c4_s_p4_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44c4_s_p4_0[] = {
+ 2, 3, 3, 6, 6, 0, 0, 0, 0, 0, 4, 4, 6, 6, 0, 0,
+ 0, 0, 0, 4, 4, 6, 6, 0, 0, 0, 0, 0, 5, 5, 6, 6,
+ 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0, 0,
+ 7, 8, 0, 0, 0, 0, 0, 0, 0, 7, 7, 0, 0, 0, 0, 0,
+ 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c4_s_p4_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44c4_s_p4_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c4_s_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44c4_s_p5_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44c4_s_p5_0[] = {
+ 2, 3, 3, 6, 6, 7, 7, 9, 9, 0, 4, 4, 6, 6, 7, 7,
+ 9, 9, 0, 4, 5, 6, 6, 7, 7, 9, 9, 0, 6, 6, 7, 7,
+ 8, 8,10,10, 0, 0, 0, 7, 7, 8, 8,10, 9, 0, 0, 0,
+ 9, 8, 8, 8,10,10, 0, 0, 0, 8, 8, 8, 8,10,10, 0,
+ 0, 0,10,10, 9, 9,11,11, 0, 0, 0, 0, 0, 9, 9,10,
+ 10,
+};
+
+static const static_codebook _44c4_s_p5_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44c4_s_p5_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c4_s_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44c4_s_p6_0[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44c4_s_p6_0[] = {
+ 2, 4, 4, 6, 6, 8, 8, 9, 9, 8, 8, 9, 9,10,10,11,
+ 11, 0, 4, 4, 6, 6, 8, 8, 9, 9, 9, 9,10,10,11,11,
+ 11,11, 0, 4, 4, 7, 6, 8, 8, 9, 9, 9, 9,10,10,11,
+ 11,11,11, 0, 6, 6, 7, 7, 8, 8, 9, 9, 9, 9,10,10,
+ 11,11,11,12, 0, 0, 0, 7, 7, 8, 8, 9, 9, 9, 9,10,
+ 10,11,11,12,12, 0, 0, 0, 8, 8, 8, 8, 9, 9, 9, 9,
+ 10,10,11,11,12,12, 0, 0, 0, 8, 8, 8, 8, 9, 9, 9,
+ 9,10,10,11,11,12,12, 0, 0, 0, 9, 9, 9, 9,10,10,
+ 10,10,11,11,11,11,12,12, 0, 0, 0, 0, 0, 9, 9,10,
+ 10,10,10,11,11,11,11,12,12, 0, 0, 0, 0, 0, 9, 9,
+ 9,10,10,10,11,11,11,11,12,12, 0, 0, 0, 0, 0, 9,
+ 9, 9, 9,10,10,11,11,11,12,12,12, 0, 0, 0, 0, 0,
+ 10,10,10,10,11,11,11,11,12,12,13,12, 0, 0, 0, 0,
+ 0, 0, 0,10,10,11,11,11,11,12,12,12,12, 0, 0, 0,
+ 0, 0, 0, 0,11,11,11,11,12,12,12,12,13,13, 0, 0,
+ 0, 0, 0, 0, 0,11,11,11,11,12,12,12,12,13,13, 0,
+ 0, 0, 0, 0, 0, 0,12,12,12,12,12,12,13,13,13,13,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,12,12,12,12,12,13,13,
+ 13,
+};
+
+static const static_codebook _44c4_s_p6_0 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44c4_s_p6_0,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44c4_s_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44c4_s_p7_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44c4_s_p7_0[] = {
+ 1, 4, 4, 7, 6, 6, 7, 6, 6, 4, 7, 7,10, 9, 9,11,
+ 9, 9, 4, 7, 7,10, 9, 9,11, 9, 9, 7,10,10,11,11,
+ 10,11,11,11, 6, 9, 9,11,10,10,11,10,10, 6, 9, 9,
+ 11,10,10,11,10,10, 7,11,11,12,11,11,12,11,11, 6,
+ 9, 9,11,10,10,11,10,10, 6, 9, 9,11,10,10,11,10,
+ 10,
+};
+
+static const static_codebook _44c4_s_p7_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44c4_s_p7_0,
+ 1, -529137664, 1618345984, 2, 0,
+ (long *)_vq_quantlist__44c4_s_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44c4_s_p7_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44c4_s_p7_1[] = {
+ 2, 4, 4, 6, 6, 7, 7, 7, 7, 8, 8,10, 5, 5, 6, 6,
+ 7, 7, 8, 8, 8, 8,10, 5, 5, 6, 6, 7, 7, 8, 8, 8,
+ 8,10, 6, 6, 7, 7, 8, 8, 8, 8, 8, 8,10,10,10, 7,
+ 7, 8, 8, 8, 8, 8, 8,10,10,10, 8, 7, 8, 8, 8, 8,
+ 8, 8,10,10,10, 7, 7, 8, 8, 8, 8, 8, 8,10,10,10,
+ 8, 8, 8, 8, 8, 8, 8, 8,10,10,10,10,10, 8, 8, 8,
+ 8, 8, 8,10,10,10,10,10, 9, 9, 8, 8, 9, 8,10,10,
+ 10,10,10, 8, 8, 8, 8, 9, 9,
+};
+
+static const static_codebook _44c4_s_p7_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44c4_s_p7_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c4_s_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44c4_s_p8_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c4_s_p8_0[] = {
+ 1, 4, 4, 6, 6, 7, 7, 8, 8, 9, 9,10,10, 6, 5, 5,
+ 7, 7, 8, 8, 8, 8, 9,10,11,11, 7, 5, 5, 7, 7, 8,
+ 8, 9, 9,10,10,11,11, 0, 8, 8, 8, 8, 9, 9, 9, 9,
+ 10,10,11,11, 0, 8, 8, 8, 8, 9, 9, 9, 9,10,10,11,
+ 11, 0,12,12, 9, 9, 9, 9,10,10,10,10,11,11, 0,13,
+ 13, 9, 9,10, 9,10,10,11,11,11,12, 0, 0, 0,10,10,
+ 10,10,10,10,11,11,12,12, 0, 0, 0,10,10,10,10,10,
+ 10,11,11,12,12, 0, 0, 0,14,14,11,11,11,11,12,12,
+ 12,12, 0, 0, 0,14,14,11,11,11,11,12,12,12,13, 0,
+ 0, 0, 0, 0,12,12,12,12,12,12,13,13, 0, 0, 0, 0,
+ 0,13,12,12,12,12,12,13,13,
+};
+
+static const static_codebook _44c4_s_p8_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c4_s_p8_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44c4_s_p8_0,
+ 0
+};
+
+static const long _vq_quantlist__44c4_s_p8_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44c4_s_p8_1[] = {
+ 2, 4, 4, 5, 5, 6, 5, 5, 5, 5, 6, 5, 4, 5, 5, 6,
+ 5, 5, 5, 5, 6, 6, 6, 5, 5,
+};
+
+static const static_codebook _44c4_s_p8_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44c4_s_p8_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44c4_s_p8_1,
+ 0
+};
+
+static const long _vq_quantlist__44c4_s_p9_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c4_s_p9_0[] = {
+ 1, 3, 3,12,12,12,12,12,12,12,12,12,12, 4, 7, 7,
+ 12,12,12,12,12,12,12,12,12,12, 3, 8, 8,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,
+};
+
+static const static_codebook _44c4_s_p9_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c4_s_p9_0,
+ 1, -513964032, 1628680192, 4, 0,
+ (long *)_vq_quantlist__44c4_s_p9_0,
+ 0
+};
+
+static const long _vq_quantlist__44c4_s_p9_1[] = {
+ 7,
+ 6,
+ 8,
+ 5,
+ 9,
+ 4,
+ 10,
+ 3,
+ 11,
+ 2,
+ 12,
+ 1,
+ 13,
+ 0,
+ 14,
+};
+
+static const long _vq_lengthlist__44c4_s_p9_1[] = {
+ 1, 4, 4, 5, 5, 7, 7, 9, 8,10, 9,10,10,10,10, 6,
+ 5, 5, 7, 7, 9, 8,10, 9,11,10,12,12,13,13, 6, 5,
+ 5, 7, 7, 9, 9,10,10,11,11,12,12,12,13,19, 8, 8,
+ 8, 8, 9, 9,10,10,12,11,12,12,13,13,19, 8, 8, 8,
+ 8, 9, 9,11,11,12,12,13,13,13,13,19,12,12, 9, 9,
+ 11,11,11,11,12,11,13,12,13,13,18,12,12, 9, 9,11,
+ 10,11,11,12,12,12,13,13,14,19,18,18,11,11,11,11,
+ 12,12,13,12,13,13,14,14,16,18,18,11,11,11,10,12,
+ 11,13,13,13,13,13,14,17,18,18,14,15,11,12,12,13,
+ 13,13,13,14,14,14,18,18,18,15,15,12,10,13,10,13,
+ 13,13,13,13,14,18,17,18,17,18,12,13,12,13,13,13,
+ 14,14,16,14,18,17,18,18,17,13,12,13,10,12,12,14,
+ 14,14,14,17,18,18,18,18,14,15,12,12,13,12,14,14,
+ 15,15,18,18,18,17,18,15,14,12,11,12,12,14,14,14,
+ 15,
+};
+
+static const static_codebook _44c4_s_p9_1 = {
+ 2, 225,
+ (long *)_vq_lengthlist__44c4_s_p9_1,
+ 1, -520986624, 1620377600, 4, 0,
+ (long *)_vq_quantlist__44c4_s_p9_1,
+ 0
+};
+
+static const long _vq_quantlist__44c4_s_p9_2[] = {
+ 10,
+ 9,
+ 11,
+ 8,
+ 12,
+ 7,
+ 13,
+ 6,
+ 14,
+ 5,
+ 15,
+ 4,
+ 16,
+ 3,
+ 17,
+ 2,
+ 18,
+ 1,
+ 19,
+ 0,
+ 20,
+};
+
+static const long _vq_lengthlist__44c4_s_p9_2[] = {
+ 2, 5, 5, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8,
+ 8, 9, 9, 9, 9,11, 6, 6, 7, 7, 8, 8, 8, 8, 9, 9,
+ 9, 9, 9, 9, 9, 9,10,10,10,10,11, 6, 6, 7, 7, 8,
+ 8, 8, 8, 9, 9, 9, 9, 9, 9,10, 9,10,10,10,10,11,
+ 7, 7, 7, 7, 8, 8, 9, 9, 9, 9, 9, 9, 9,10,10,10,
+ 10,10,10,10,12,11,11, 7, 7, 8, 8, 9, 9, 9, 9, 9,
+ 9,10,10,10,10,10,10,10,10,12,11,12, 8, 8, 8, 8,
+ 9, 9, 9, 9, 9,10,10,10,10,10,10,10,10,10,11,11,
+ 11, 8, 8, 8, 8, 9, 9, 9, 9,10,10,10,10,10,10,10,
+ 10,10,10,11,11,12, 9, 9, 9, 9, 9, 9,10, 9,10,10,
+ 10,10,10,10,10,10,10,10,11,11,11,11,11, 9, 9, 9,
+ 9,10,10,10,10,10,10,10,10,10,10,10,10,11,12,11,
+ 11,11, 9, 9, 9,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,11,11,11,11,11, 9, 9, 9, 9,10,10,10,10,10,
+ 10,10,10,10,10,10,10,11,11,11,12,12,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,11,12,11,12,
+ 11,11,11, 9,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,11,12,11,11,11,11,11,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,11,11,11,12,11,11,11,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,12,11,11,12,11,
+ 11,11,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 11,11,11,11,11,11,11,11,11,10,10,10,10,10,10,10,
+ 10,10,10,10,10,11,11,11,11,12,12,11,11,11,11,11,
+ 11,11,10,10,10,10,10,10,10,10,12,12,12,11,11,11,
+ 12,11,11,11,10,10,10,10,10,10,10,10,10,10,10,12,
+ 11,12,12,12,12,12,11,12,11,11,10,10,10,10,10,10,
+ 10,10,10,10,12,12,12,12,11,11,11,11,11,11,11,10,
+ 10,10,10,10,10,10,10,10,10,
+};
+
+static const static_codebook _44c4_s_p9_2 = {
+ 2, 441,
+ (long *)_vq_lengthlist__44c4_s_p9_2,
+ 1, -529268736, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44c4_s_p9_2,
+ 0
+};
+
+static const long _huff_lengthlist__44c4_s_short[] = {
+ 4, 7,14,10,15,10,12,15,16,15, 4, 2,11, 5,10, 6,
+ 8,11,14,14,14,10, 7,11, 6, 8,10,11,13,15, 9, 4,
+ 11, 5, 9, 6, 9,12,14,15,14, 9, 6, 9, 4, 5, 7,10,
+ 12,13, 9, 5, 7, 6, 5, 5, 7,10,13,13,10, 8, 9, 8,
+ 7, 6, 8,10,14,14,13,11,10,10, 7, 7, 8,11,14,15,
+ 13,12, 9, 9, 6, 5, 7,10,14,17,15,13,11,10, 6, 6,
+ 7, 9,12,17,
+};
+
+static const static_codebook _huff_book__44c4_s_short = {
+ 2, 100,
+ (long *)_huff_lengthlist__44c4_s_short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44c5_s_long[] = {
+ 3, 8, 9,13,10,12,12,12,12,12, 6, 4, 6, 8, 6, 8,
+ 10,10,11,12, 8, 5, 4,10, 4, 7, 8, 9,10,11,13, 8,
+ 10, 8, 9, 9,11,12,13,14,10, 6, 4, 9, 3, 5, 6, 8,
+ 10,11,11, 8, 6, 9, 5, 5, 6, 7, 9,11,12, 9, 7,11,
+ 6, 6, 6, 7, 8,10,12,11, 9,12, 7, 7, 6, 6, 7, 9,
+ 13,12,10,13, 9, 8, 7, 7, 7, 8,11,15,11,15,11,10,
+ 9, 8, 7, 7,
+};
+
+static const static_codebook _huff_book__44c5_s_long = {
+ 2, 100,
+ (long *)_huff_lengthlist__44c5_s_long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44c5_s_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44c5_s_p1_0[] = {
+ 2, 4, 4, 0, 0, 0, 0, 0, 0, 4, 7, 7, 0, 0, 0, 0,
+ 0, 0, 4, 6, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 5, 7, 7, 0, 0, 0, 0, 0, 0, 7, 9, 9, 0, 0, 0,
+ 0, 0, 0, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 4, 7, 7, 0, 0, 0, 0, 0, 0, 7, 9, 8, 0, 0,
+ 0, 0, 0, 0, 7, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 7, 7, 0, 0, 0, 0,
+ 0, 0, 7, 9, 9, 0, 0, 0, 0, 0, 0, 7, 9, 9, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 9, 9, 0, 0, 0,
+ 0, 0, 0, 9,10,11, 0, 0, 0, 0, 0, 0, 9,10,10, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 9, 9, 0, 0,
+ 0, 0, 0, 0, 8,10, 9, 0, 0, 0, 0, 0, 0, 9,10,11,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 4, 7, 7, 0, 0, 0, 0, 0, 0, 7, 9, 9, 0, 0,
+ 0, 0, 0, 0, 7, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 7, 9, 9, 0, 0, 0, 0, 0, 0, 9,11,10, 0,
+ 0, 0, 0, 0, 0, 8, 9,10, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 7, 9, 9, 0, 0, 0, 0, 0, 0, 9,10,10,
+ 0, 0, 0, 0, 0, 0, 9,11,10, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c5_s_p1_0 = {
+ 8, 6561,
+ (long *)_vq_lengthlist__44c5_s_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44c5_s_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44c5_s_p2_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44c5_s_p2_0[] = {
+ 2, 4, 4, 0, 0, 0, 5, 5, 0, 0, 0, 5, 5, 0, 0, 0,
+ 8, 7, 0, 0, 0, 0, 0, 0, 0, 4, 6, 6, 0, 0, 0, 8,
+ 8, 0, 0, 0, 8, 7, 0, 0, 0,10,10, 0, 0, 0, 0, 0,
+ 0, 0, 4, 6, 6, 0, 0, 0, 8, 8, 0, 0, 0, 7, 8, 0,
+ 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 5, 8, 7, 0, 0, 0, 8, 8, 0, 0,
+ 0, 8, 8, 0, 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 5,
+ 7, 8, 0, 0, 0, 8, 8, 0, 0, 0, 8, 8, 0, 0, 0,10,
+ 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 5, 8, 8, 0, 0, 0, 8, 8, 0, 0, 0, 8, 8,
+ 0, 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 5, 8, 8, 0,
+ 0, 0, 8, 8, 0, 0, 0, 8, 8, 0, 0, 0,10,10, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 8,10,10, 0, 0, 0,10,10, 0, 0, 0, 9,10, 0, 0, 0,
+ 11,10, 0, 0, 0, 0, 0, 0, 0, 8,10,10, 0, 0, 0,10,
+ 10, 0, 0, 0,10,10, 0, 0, 0,10,11, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c5_s_p2_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44c5_s_p2_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44c5_s_p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44c5_s_p3_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44c5_s_p3_0[] = {
+ 2, 4, 3, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 5, 5, 6, 6, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 3, 5, 5, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 8, 8,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 5, 6, 6, 8, 8, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c5_s_p3_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44c5_s_p3_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44c5_s_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44c5_s_p4_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44c5_s_p4_0[] = {
+ 2, 3, 3, 6, 6, 0, 0, 0, 0, 0, 4, 4, 6, 6, 0, 0,
+ 0, 0, 0, 4, 4, 6, 6, 0, 0, 0, 0, 0, 5, 5, 6, 6,
+ 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0, 0,
+ 7, 7, 0, 0, 0, 0, 0, 0, 0, 8, 7, 0, 0, 0, 0, 0,
+ 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c5_s_p4_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44c5_s_p4_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c5_s_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44c5_s_p5_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44c5_s_p5_0[] = {
+ 2, 4, 3, 6, 6, 7, 7, 9, 9, 0, 4, 4, 6, 6, 7, 7,
+ 9, 9, 0, 4, 4, 6, 6, 7, 7, 9, 9, 0, 6, 6, 7, 7,
+ 7, 7, 9, 9, 0, 0, 0, 7, 6, 7, 7, 9, 9, 0, 0, 0,
+ 8, 8, 8, 8,10,10, 0, 0, 0, 8, 8, 8, 8,10,10, 0,
+ 0, 0, 9, 9, 9, 9,10,10, 0, 0, 0, 0, 0, 9, 9,10,
+ 10,
+};
+
+static const static_codebook _44c5_s_p5_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44c5_s_p5_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c5_s_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44c5_s_p6_0[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44c5_s_p6_0[] = {
+ 2, 4, 4, 6, 6, 8, 8, 9, 9, 9, 9,10,10,10,10,11,
+ 11, 0, 4, 4, 6, 6, 8, 8, 9, 9, 9, 9,10,10,11,11,
+ 12,12, 0, 4, 4, 6, 6, 8, 8, 9, 9, 9, 9,10,10,11,
+ 11,12,12, 0, 6, 6, 7, 7, 8, 8, 9, 9, 9, 9,10,10,
+ 11,11,12,12, 0, 0, 0, 7, 7, 8, 8, 9, 9, 9, 9,10,
+ 10,11,11,12,12, 0, 0, 0, 7, 7, 9, 9,10,10,10,10,
+ 11,11,11,11,12,12, 0, 0, 0, 7, 7, 8, 9,10,10,10,
+ 10,11,11,11,11,12,12, 0, 0, 0, 8, 8, 9, 9,10,10,
+ 10,10,11,11,12,12,12,12, 0, 0, 0, 0, 0, 9, 9,10,
+ 10,10,10,11,11,12,12,12,12, 0, 0, 0, 0, 0, 9, 9,
+ 10,10,10,10,11,11,12,12,12,12, 0, 0, 0, 0, 0, 9,
+ 9, 9,10,10,10,11,11,12,12,12,12, 0, 0, 0, 0, 0,
+ 10,10,10,10,11,11,11,12,12,12,13,13, 0, 0, 0, 0,
+ 0, 0, 0,10,10,11,11,11,11,12,12,13,13, 0, 0, 0,
+ 0, 0, 0, 0,11,11,11,11,12,12,12,13,13,13, 0, 0,
+ 0, 0, 0, 0, 0,11,11,11,11,12,12,12,12,13,13, 0,
+ 0, 0, 0, 0, 0, 0,12,12,12,12,13,12,13,13,13,13,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,12,12,12,12,13,13,13,
+ 13,
+};
+
+static const static_codebook _44c5_s_p6_0 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44c5_s_p6_0,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44c5_s_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44c5_s_p7_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44c5_s_p7_0[] = {
+ 1, 4, 4, 7, 6, 6, 7, 6, 6, 4, 7, 7,10, 9, 9,11,
+ 9, 9, 4, 7, 7,10, 9, 9,11, 9, 9, 7,10,10,11,11,
+ 10,11,11,11, 6, 9, 9,11,10,10,11,10,10, 6, 9, 9,
+ 11,10,10,11,10,10, 7,11,11,12,11,11,12,11,11, 6,
+ 9, 9,11,10,10,11,10,10, 6, 9, 9,11,10,10,11,10,
+ 10,
+};
+
+static const static_codebook _44c5_s_p7_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44c5_s_p7_0,
+ 1, -529137664, 1618345984, 2, 0,
+ (long *)_vq_quantlist__44c5_s_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44c5_s_p7_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44c5_s_p7_1[] = {
+ 2, 4, 4, 6, 6, 7, 7, 8, 8, 8, 8,10, 5, 5, 6, 6,
+ 7, 7, 8, 8, 8, 8,10, 5, 5, 6, 6, 7, 7, 8, 8, 8,
+ 8,10, 6, 6, 7, 7, 8, 8, 8, 8, 8, 8,10,10,10, 7,
+ 7, 8, 8, 8, 8, 8, 8,10,10,10, 7, 7, 8, 8, 8, 8,
+ 8, 8,10,10,10, 7, 7, 8, 8, 8, 8, 8, 8,10,10,10,
+ 8, 8, 8, 8, 8, 8, 8, 9,10,10,10,10,10, 8, 8, 8,
+ 8, 8, 8,10,10,10,10,10, 9, 9, 8, 8, 8, 8,10,10,
+ 10,10,10, 8, 8, 8, 8, 8, 8,
+};
+
+static const static_codebook _44c5_s_p7_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44c5_s_p7_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c5_s_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44c5_s_p8_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c5_s_p8_0[] = {
+ 1, 4, 4, 6, 6, 7, 7, 8, 8, 9, 9,10,10, 6, 5, 5,
+ 7, 7, 8, 8, 8, 9,10,10,10,10, 7, 5, 5, 7, 7, 8,
+ 8, 9, 9,10,10,10,10, 0, 8, 8, 8, 8, 9, 9, 9, 9,
+ 10,10,11,11, 0, 8, 8, 8, 8, 9, 9, 9, 9,10,10,11,
+ 11, 0,12,12, 9, 9, 9,10,10,10,10,10,11,11, 0,13,
+ 13, 9, 9, 9, 9,10,10,11,11,11,11, 0, 0, 0,10,10,
+ 10,10,10,10,11,11,11,11, 0, 0, 0,10,10,10,10,10,
+ 10,11,11,12,12, 0, 0, 0,14,14,11,11,11,11,12,12,
+ 12,12, 0, 0, 0,14,14,11,11,11,11,12,12,12,12, 0,
+ 0, 0, 0, 0,12,12,12,12,12,12,13,13, 0, 0, 0, 0,
+ 0,12,12,12,12,12,12,13,13,
+};
+
+static const static_codebook _44c5_s_p8_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c5_s_p8_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44c5_s_p8_0,
+ 0
+};
+
+static const long _vq_quantlist__44c5_s_p8_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44c5_s_p8_1[] = {
+ 2, 4, 4, 5, 5, 6, 5, 5, 5, 5, 6, 4, 5, 5, 5, 6,
+ 5, 5, 5, 5, 6, 6, 6, 5, 5,
+};
+
+static const static_codebook _44c5_s_p8_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44c5_s_p8_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44c5_s_p8_1,
+ 0
+};
+
+static const long _vq_quantlist__44c5_s_p9_0[] = {
+ 7,
+ 6,
+ 8,
+ 5,
+ 9,
+ 4,
+ 10,
+ 3,
+ 11,
+ 2,
+ 12,
+ 1,
+ 13,
+ 0,
+ 14,
+};
+
+static const long _vq_lengthlist__44c5_s_p9_0[] = {
+ 1, 3, 3,13,13,13,13,13,13,13,13,13,13,13,13, 4,
+ 7, 7,13,13,13,13,13,13,13,13,13,13,13,13, 3, 8,
+ 6,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,12,12,12,12,12,12,12,
+ 12,
+};
+
+static const static_codebook _44c5_s_p9_0 = {
+ 2, 225,
+ (long *)_vq_lengthlist__44c5_s_p9_0,
+ 1, -512522752, 1628852224, 4, 0,
+ (long *)_vq_quantlist__44c5_s_p9_0,
+ 0
+};
+
+static const long _vq_quantlist__44c5_s_p9_1[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44c5_s_p9_1[] = {
+ 1, 4, 4, 5, 5, 7, 7, 9, 8,10, 9,10,10,11,10,11,
+ 11, 6, 5, 5, 7, 7, 8, 9,10,10,11,10,12,11,12,11,
+ 13,12, 6, 5, 5, 7, 7, 9, 9,10,10,11,11,12,12,13,
+ 12,13,13,18, 8, 8, 8, 8, 9, 9,10,11,11,11,12,11,
+ 13,11,13,12,18, 8, 8, 8, 8,10,10,11,11,12,12,13,
+ 13,13,13,13,14,18,12,12, 9, 9,11,11,11,11,12,12,
+ 13,12,13,12,13,13,20,13,12, 9, 9,11,11,11,11,12,
+ 12,13,13,13,14,14,13,20,18,19,11,12,11,11,12,12,
+ 13,13,13,13,13,13,14,13,18,19,19,12,11,11,11,12,
+ 12,13,12,13,13,13,14,14,13,18,17,19,14,15,12,12,
+ 12,13,13,13,14,14,14,14,14,14,19,19,19,16,15,12,
+ 11,13,12,14,14,14,13,13,14,14,14,19,18,19,18,19,
+ 13,13,13,13,14,14,14,13,14,14,14,14,18,17,19,19,
+ 19,13,13,13,11,13,11,13,14,14,14,14,14,19,17,17,
+ 18,18,16,16,13,13,13,13,14,13,15,15,14,14,19,19,
+ 17,17,18,16,16,13,11,14,10,13,12,14,14,14,14,19,
+ 19,19,19,19,18,17,13,14,13,11,14,13,14,14,15,15,
+ 19,19,19,17,19,18,18,14,13,12,11,14,11,15,15,15,
+ 15,
+};
+
+static const static_codebook _44c5_s_p9_1 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44c5_s_p9_1,
+ 1, -520814592, 1620377600, 5, 0,
+ (long *)_vq_quantlist__44c5_s_p9_1,
+ 0
+};
+
+static const long _vq_quantlist__44c5_s_p9_2[] = {
+ 10,
+ 9,
+ 11,
+ 8,
+ 12,
+ 7,
+ 13,
+ 6,
+ 14,
+ 5,
+ 15,
+ 4,
+ 16,
+ 3,
+ 17,
+ 2,
+ 18,
+ 1,
+ 19,
+ 0,
+ 20,
+};
+
+static const long _vq_lengthlist__44c5_s_p9_2[] = {
+ 3, 5, 5, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 9,11, 5, 6, 7, 7, 8, 7, 8, 8, 8, 8,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,11, 5, 5, 7, 7, 7,
+ 7, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,11,
+ 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9,10, 9,10,11,11,11, 7, 7, 8, 8, 8, 8, 9, 9, 9,
+ 9, 9, 9,10,10,10,10,10,10,11,11,11, 8, 8, 8, 8,
+ 9, 9, 9, 9, 9, 9, 9,10,10,10,10,10,10,10,11,11,
+ 11, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9,10,10,10,10,10,
+ 10,10,10,11,11,11, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 10,10,10,10,10,10,10,10,11,11,11,11,11, 9, 9, 9,
+ 9, 9, 9,10, 9,10,10,10,10,10,10,10,10,11,11,11,
+ 11,11, 9, 9, 9, 9, 9, 9,10,10,10,10,10,10,10,10,
+ 10,10,11,11,11,11,11, 9, 9, 9, 9, 9, 9,10,10,10,
+ 10,10,10,10,10,10,10,11,11,11,11,11, 9, 9,10, 9,
+ 10,10,10,10,10,10,10,10,10,10,10,10,11,11,11,11,
+ 11,11,11, 9, 9,10,10,10,10,10,10,10,10,10,10,10,
+ 10,11,11,11,11,11,11,11,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,11,11,11,11,11,11,11,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,11,11,11,11,11,
+ 11,11,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 11,11,11,11,11,11,11,11,11,10,10,10,10,10,10,10,
+ 10,10,10,10,10,11,11,11,11,11,11,11,11,11,10,10,
+ 10,10,10,10,10,10,10,10,10,10,11,11,11,11,11,11,
+ 11,11,11,10,10,10,10,10,10,10,10,10,10,10,10,11,
+ 11,11,11,11,11,11,11,11,10,10,10,10,10,10,10,10,
+ 10,10,10,10,11,11,11,11,11,11,11,11,11,11,11,10,
+ 10,10,10,10,10,10,10,10,10,
+};
+
+static const static_codebook _44c5_s_p9_2 = {
+ 2, 441,
+ (long *)_vq_lengthlist__44c5_s_p9_2,
+ 1, -529268736, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44c5_s_p9_2,
+ 0
+};
+
+static const long _huff_lengthlist__44c5_s_short[] = {
+ 5, 8,10,14,11,11,12,16,15,17, 5, 5, 7, 9, 7, 8,
+ 10,13,17,17, 7, 5, 5,10, 5, 7, 8,11,13,15,10, 8,
+ 10, 8, 8, 8,11,15,18,18, 8, 5, 5, 8, 3, 4, 6,10,
+ 14,16, 9, 7, 6, 7, 4, 3, 5, 9,14,18,10, 9, 8,10,
+ 6, 5, 6, 9,14,18,12,12,11,12, 8, 7, 8,11,14,18,
+ 14,13,12,10, 7, 5, 6, 9,14,18,14,14,13,10, 6, 5,
+ 6, 8,11,16,
+};
+
+static const static_codebook _huff_book__44c5_s_short = {
+ 2, 100,
+ (long *)_huff_lengthlist__44c5_s_short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44c6_s_long[] = {
+ 3, 8,11,13,14,14,13,13,16,14, 6, 3, 4, 7, 9, 9,
+ 10,11,14,13,10, 4, 3, 5, 7, 7, 9,10,13,15,12, 7,
+ 4, 4, 6, 6, 8,10,13,15,12, 8, 6, 6, 6, 6, 8,10,
+ 13,14,11, 9, 7, 6, 6, 6, 7, 8,12,11,13,10, 9, 8,
+ 7, 6, 6, 7,11,11,13,11,10, 9, 9, 7, 7, 6,10,11,
+ 13,13,13,13,13,11, 9, 8,10,12,12,15,15,16,15,12,
+ 11,10,10,12,
+};
+
+static const static_codebook _huff_book__44c6_s_long = {
+ 2, 100,
+ (long *)_huff_lengthlist__44c6_s_long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44c6_s_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44c6_s_p1_0[] = {
+ 1, 5, 5, 0, 5, 5, 0, 5, 5, 5, 8, 7, 0, 9, 9, 0,
+ 9, 8, 5, 7, 8, 0, 9, 9, 0, 8, 9, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 5, 9, 8, 0, 8, 8, 0, 8, 8, 5, 8, 9,
+ 0, 8, 8, 0, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
+ 9, 9, 0, 8, 8, 0, 8, 8, 5, 9, 9, 0, 8, 8, 0, 8,
+ 8,
+};
+static const static_codebook _44c6_s_p1_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44c6_s_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44c6_s_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44c6_s_p2_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44c6_s_p2_0[] = {
+ 3, 5, 5, 8, 8, 0, 5, 5, 8, 8, 0, 5, 5, 8, 8, 0,
+ 7, 7, 9, 9, 0, 0, 0, 9, 9, 5, 7, 7, 9, 9, 0, 8,
+ 8,10,10, 0, 8, 7,10, 9, 0,10,10,11,11, 0, 0, 0,
+ 11,11, 5, 7, 7, 9, 9, 0, 8, 8,10,10, 0, 7, 8, 9,
+ 10, 0,10,10,11,11, 0, 0, 0,11,11, 8, 9, 9,11,11,
+ 0,11,11,12,12, 0,11,10,12,12, 0,13,14,14,14, 0,
+ 0, 0,14,13, 8, 9, 9,11,11, 0,11,11,12,12, 0,10,
+ 11,12,12, 0,14,13,14,14, 0, 0, 0,13,14, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 5, 8, 7,11,10, 0, 7, 7,10,10,
+ 0, 7, 7,10,10, 0, 9, 9,11,10, 0, 0, 0,11,11, 5,
+ 7, 8,10,11, 0, 7, 7,10,10, 0, 7, 7,10,10, 0, 9,
+ 9,10,11, 0, 0, 0,11,11, 8,10, 9,12,12, 0,10,10,
+ 12,12, 0,10,10,12,12, 0,12,12,13,13, 0, 0, 0,13,
+ 13, 8, 9,10,12,12, 0,10,10,11,12, 0,10,10,12,12,
+ 0,12,12,13,13, 0, 0, 0,13,13, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 5, 8, 8,11,11, 0, 7, 7,10,10, 0, 7, 7,
+ 10,10, 0, 9, 9,10,11, 0, 0, 0,11,10, 5, 8, 8,11,
+ 11, 0, 7, 7,10,10, 0, 7, 7,10,10, 0, 9, 9,11,11,
+ 0, 0, 0,10,11, 8,10,10,12,12, 0,10,10,12,12, 0,
+ 10,10,12,12, 0,12,13,13,13, 0, 0, 0,14,13, 8,10,
+ 10,12,12, 0,10,10,12,12, 0,10,10,12,12, 0,13,12,
+ 13,13, 0, 0, 0,13,13, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 7,10,10,14,13, 0, 9, 9,13,12, 0, 9, 9,12,12, 0,
+ 10,10,12,12, 0, 0, 0,12,12, 7,10,10,13,14, 0, 9,
+ 9,12,13, 0, 9, 9,12,12, 0,10,10,12,12, 0, 0, 0,
+ 12,12, 9,11,11,14,13, 0,11,10,14,13, 0,11,11,13,
+ 13, 0,12,12,13,13, 0, 0, 0,13,13, 9,11,11,13,14,
+ 0,10,11,13,14, 0,11,11,13,13, 0,12,12,13,13, 0,
+ 0, 0,13,13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9,
+ 11,11,14,14, 0,11,11,13,13, 0,11,10,13,13, 0,12,
+ 12,13,13, 0, 0, 0,13,13, 9,11,11,14,14, 0,11,11,
+ 13,13, 0,10,11,13,13, 0,12,12,14,13, 0, 0, 0,13,
+ 13,
+};
+
+static const static_codebook _44c6_s_p2_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44c6_s_p2_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44c6_s_p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44c6_s_p3_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44c6_s_p3_0[] = {
+ 2, 3, 4, 6, 6, 7, 7, 9, 9, 0, 4, 4, 6, 6, 7, 7,
+ 9,10, 0, 4, 4, 6, 6, 7, 7,10, 9, 0, 5, 5, 7, 7,
+ 8, 8,10,10, 0, 0, 0, 7, 6, 8, 8,10,10, 0, 0, 0,
+ 7, 7, 9, 9,11,11, 0, 0, 0, 7, 7, 9, 9,11,11, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c6_s_p3_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44c6_s_p3_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c6_s_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44c6_s_p4_0[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44c6_s_p4_0[] = {
+ 2, 4, 4, 6, 6, 7, 7, 8, 8, 8, 8, 9, 9, 9,10,10,
+ 10, 0, 4, 4, 6, 6, 8, 8, 9, 9, 9, 9,10,10,10,10,
+ 11,11, 0, 4, 4, 6, 6, 8, 8, 9, 9, 9, 9,10,10,10,
+ 10,11,11, 0, 6, 6, 7, 7, 8, 8, 9, 9, 9, 9,10,10,
+ 11,11,11,11, 0, 0, 0, 7, 7, 8, 8, 9, 9, 9, 9,10,
+ 10,11,11,11,11, 0, 0, 0, 7, 7, 9, 9,10,10,10,10,
+ 11,11,11,11,12,12, 0, 0, 0, 7, 7, 9, 9,10,10,10,
+ 10,11,11,11,11,12,12, 0, 0, 0, 7, 7, 8, 8, 9, 9,
+ 10,10,11,11,12,12,12,12, 0, 0, 0, 0, 0, 8, 8, 9,
+ 9,10,10,11,11,12,12,12,12, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c6_s_p4_0 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44c6_s_p4_0,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44c6_s_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44c6_s_p5_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44c6_s_p5_0[] = {
+ 1, 4, 4, 5, 7, 7, 6, 7, 7, 4, 6, 6, 9, 9,10,10,
+ 10, 9, 4, 6, 6, 9,10, 9,10, 9,10, 6, 9, 9,10,12,
+ 11,10,11,11, 7,10, 9,11,12,12,12,12,12, 7,10,10,
+ 11,12,12,12,12,12, 6,10,10,10,12,12,11,12,12, 7,
+ 9,10,11,12,12,12,12,12, 7,10, 9,12,12,12,12,12,
+ 12,
+};
+
+static const static_codebook _44c6_s_p5_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44c6_s_p5_0,
+ 1, -529137664, 1618345984, 2, 0,
+ (long *)_vq_quantlist__44c6_s_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44c6_s_p5_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44c6_s_p5_1[] = {
+ 3, 5, 4, 6, 6, 7, 7, 8, 8, 8, 8,11, 4, 4, 6, 6,
+ 7, 7, 8, 8, 8, 8,11, 4, 4, 6, 6, 7, 7, 8, 8, 8,
+ 8,11, 6, 6, 6, 6, 8, 8, 8, 8, 9, 9,11,11,11, 6,
+ 6, 7, 8, 8, 8, 8, 9,11,11,11, 7, 7, 8, 8, 8, 8,
+ 8, 8,11,11,11, 7, 7, 8, 8, 8, 8, 8, 8,11,11,11,
+ 8, 8, 8, 8, 8, 8, 8, 8,11,11,11,10,10, 8, 8, 8,
+ 8, 8, 8,11,11,11,10,10, 8, 8, 8, 8, 8, 8,11,11,
+ 11,10,10, 7, 7, 8, 8, 8, 8,
+};
+
+static const static_codebook _44c6_s_p5_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44c6_s_p5_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c6_s_p5_1,
+ 0
+};
+
+static const long _vq_quantlist__44c6_s_p6_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c6_s_p6_0[] = {
+ 1, 4, 4, 6, 6, 8, 8, 8, 8,10, 9,10,10, 6, 5, 5,
+ 7, 7, 9, 9, 9, 9,10,10,11,11, 6, 5, 5, 7, 7, 9,
+ 9,10, 9,11,10,11,11, 0, 6, 6, 7, 7, 9, 9,10,10,
+ 11,11,12,12, 0, 7, 7, 7, 7, 9, 9,10,10,11,11,12,
+ 12, 0,11,11, 8, 8,10,10,11,11,12,12,12,12, 0,11,
+ 12, 9, 8,10,10,11,11,12,12,13,13, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+static const static_codebook _44c6_s_p6_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c6_s_p6_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44c6_s_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44c6_s_p6_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44c6_s_p6_1[] = {
+ 3, 4, 4, 5, 5, 5, 4, 4, 5, 5, 5, 4, 4, 5, 5, 6,
+ 5, 5, 5, 5, 6, 6, 6, 5, 5,
+};
+
+static const static_codebook _44c6_s_p6_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44c6_s_p6_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44c6_s_p6_1,
+ 0
+};
+
+static const long _vq_quantlist__44c6_s_p7_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c6_s_p7_0[] = {
+ 1, 4, 4, 6, 6, 8, 8, 8, 8,10,10,11,10, 6, 5, 5,
+ 7, 7, 8, 8, 9, 9,10,10,12,11, 6, 5, 5, 7, 7, 8,
+ 8, 9, 9,10,10,12,11,21, 7, 7, 7, 7, 9, 9,10,10,
+ 11,11,12,12,21, 7, 7, 7, 7, 9, 9,10,10,11,11,12,
+ 12,21,12,12, 9, 9,10,10,11,11,11,11,12,12,21,12,
+ 12, 9, 9,10,10,11,11,12,12,12,12,21,21,21,11,11,
+ 10,10,11,12,12,12,13,13,21,21,21,11,11,10,10,12,
+ 12,12,12,13,13,21,21,21,15,15,11,11,12,12,13,13,
+ 13,13,21,21,21,15,16,11,11,12,12,13,13,14,14,21,
+ 21,21,21,20,13,13,13,13,13,13,14,14,20,20,20,20,
+ 20,13,13,13,13,13,13,14,14,
+};
+
+static const static_codebook _44c6_s_p7_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c6_s_p7_0,
+ 1, -523206656, 1618345984, 4, 0,
+ (long *)_vq_quantlist__44c6_s_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44c6_s_p7_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44c6_s_p7_1[] = {
+ 3, 5, 5, 6, 6, 7, 7, 7, 7, 7, 7, 9, 5, 5, 6, 6,
+ 7, 7, 7, 7, 8, 7, 8, 5, 5, 6, 6, 7, 7, 7, 7, 7,
+ 7, 9, 6, 6, 7, 7, 7, 7, 8, 7, 7, 8, 9, 9, 9, 7,
+ 7, 7, 7, 7, 7, 7, 8, 9, 9, 9, 7, 7, 7, 7, 8, 8,
+ 8, 8, 9, 9, 9, 7, 7, 7, 7, 7, 7, 8, 8, 9, 9, 9,
+ 8, 8, 8, 8, 7, 7, 8, 8, 9, 9, 9, 9, 8, 8, 8, 7,
+ 7, 8, 8, 9, 9, 9, 8, 8, 8, 8, 7, 7, 8, 8, 9, 9,
+ 9, 8, 8, 7, 7, 7, 7, 8, 8,
+};
+
+static const static_codebook _44c6_s_p7_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44c6_s_p7_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c6_s_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44c6_s_p8_0[] = {
+ 7,
+ 6,
+ 8,
+ 5,
+ 9,
+ 4,
+ 10,
+ 3,
+ 11,
+ 2,
+ 12,
+ 1,
+ 13,
+ 0,
+ 14,
+};
+
+static const long _vq_lengthlist__44c6_s_p8_0[] = {
+ 1, 4, 4, 7, 7, 8, 8, 7, 7, 8, 7, 9, 8,10, 9, 6,
+ 5, 5, 8, 8, 9, 9, 8, 8, 9, 9,11,10,11,10, 6, 5,
+ 5, 8, 8, 9, 9, 8, 8, 9, 9,10,10,11,11,18, 8, 8,
+ 9, 8,10,10, 9, 9,10,10,10,10,11,10,18, 8, 8, 9,
+ 9,10,10, 9, 9,10,10,11,11,12,12,18,12,13, 9,10,
+ 10,10, 9,10,10,10,11,11,12,11,18,13,13, 9, 9,10,
+ 10,10,10,10,10,11,11,12,12,18,18,18,10,10, 9, 9,
+ 11,11,11,11,11,12,12,12,18,18,18,10, 9,10, 9,11,
+ 10,11,11,11,11,13,12,18,18,18,14,13,10,10,11,11,
+ 12,12,12,12,12,12,18,18,18,14,13,10,10,11,10,12,
+ 12,12,12,12,12,18,18,18,18,18,12,12,11,11,12,12,
+ 13,13,13,14,18,18,18,18,18,12,12,11,11,12,11,13,
+ 13,14,13,18,18,18,18,18,16,16,11,12,12,13,13,13,
+ 14,13,18,18,18,18,18,16,15,12,11,12,11,13,11,15,
+ 14,
+};
+
+static const static_codebook _44c6_s_p8_0 = {
+ 2, 225,
+ (long *)_vq_lengthlist__44c6_s_p8_0,
+ 1, -520986624, 1620377600, 4, 0,
+ (long *)_vq_quantlist__44c6_s_p8_0,
+ 0
+};
+
+static const long _vq_quantlist__44c6_s_p8_1[] = {
+ 10,
+ 9,
+ 11,
+ 8,
+ 12,
+ 7,
+ 13,
+ 6,
+ 14,
+ 5,
+ 15,
+ 4,
+ 16,
+ 3,
+ 17,
+ 2,
+ 18,
+ 1,
+ 19,
+ 0,
+ 20,
+};
+
+static const long _vq_lengthlist__44c6_s_p8_1[] = {
+ 3, 5, 5, 6, 6, 7, 7, 7, 7, 8, 7, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8,10, 6, 6, 7, 7, 8, 8, 8, 8, 8, 8,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,10, 6, 6, 7, 7, 8,
+ 8, 8, 8, 8, 8, 9, 8, 9, 9, 9, 9, 9, 9, 9, 9,10,
+ 7, 7, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9,10,11,11, 8, 7, 8, 8, 8, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9,11,11,11, 8, 8, 8, 8,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,11,11,
+ 11, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9,11,11,11, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9,11,11,11,11,11, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,10,10, 9,11,11,11,
+ 11,11, 9, 9, 9, 9, 9, 9,10, 9, 9,10, 9,10, 9, 9,
+ 10, 9,11,11,11,11,11, 9, 9, 9, 9, 9, 9, 9,10,10,
+ 10,10, 9,10,10, 9,10,11,11,11,11,11, 9, 9, 9, 9,
+ 10,10,10, 9,10,10,10,10, 9,10,10, 9,11,11,11,11,
+ 11,11,11, 9, 9, 9, 9,10,10,10,10, 9,10,10,10,10,
+ 10,11,11,11,11,11,11,11,10, 9,10,10,10,10,10,10,
+ 10, 9,10, 9,10,10,11,11,11,11,11,11,11,10, 9,10,
+ 9,10,10, 9,10,10,10,10,10,10,10,11,11,11,11,11,
+ 11,11,10,10,10,10,10,10,10, 9,10,10,10,10,10, 9,
+ 11,11,11,11,11,11,11,11,11,10,10,10,10,10,10,10,
+ 10,10,10,10,10,11,11,11,11,11,11,11,11,11,10,10,
+ 10,10,10,10,10,10,10,10,10,10,11,11,11,11,11,11,
+ 11,11,11,10,10,10,10,10,10,10,10,10, 9,10,10,11,
+ 11,11,11,11,11,11,11,11,10,10,10, 9,10,10,10,10,
+ 10,10,10,10,10,11,11,11,11,11,11,11,11,10,11, 9,
+ 10,10,10,10,10,10,10,10,10,
+};
+
+static const static_codebook _44c6_s_p8_1 = {
+ 2, 441,
+ (long *)_vq_lengthlist__44c6_s_p8_1,
+ 1, -529268736, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44c6_s_p8_1,
+ 0
+};
+
+static const long _vq_quantlist__44c6_s_p9_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c6_s_p9_0[] = {
+ 1, 3, 3,11,11,11,11,11,11,11,11,11,11, 4, 7, 7,
+ 11,11,11,11,11,11,11,11,11,11, 5, 8, 9,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,
+};
+
+static const static_codebook _44c6_s_p9_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c6_s_p9_0,
+ 1, -511845376, 1630791680, 4, 0,
+ (long *)_vq_quantlist__44c6_s_p9_0,
+ 0
+};
+
+static const long _vq_quantlist__44c6_s_p9_1[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c6_s_p9_1[] = {
+ 1, 4, 4, 7, 7, 7, 7, 7, 6, 8, 8, 8, 8, 6, 6, 6,
+ 8, 8, 8, 8, 8, 7, 9, 8,10,10, 5, 6, 6, 8, 8, 9,
+ 9, 8, 8,10,10,10,10,16, 9, 9, 9, 9, 9, 9, 9, 8,
+ 10, 9,11,11,16, 8, 9, 9, 9, 9, 9, 9, 9,10,10,11,
+ 11,16,13,13, 9, 9,10, 9, 9,10,11,11,11,12,16,13,
+ 14, 9, 8,10, 8, 9, 9,10,10,12,11,16,14,16, 9, 9,
+ 9, 9,11,11,12,11,12,11,16,16,16, 9, 7, 9, 6,11,
+ 11,11,10,11,11,16,16,16,11,12, 9,10,11,11,12,11,
+ 13,13,16,16,16,12,11,10, 7,12,10,12,12,12,12,16,
+ 16,15,16,16,10,11,10,11,13,13,14,12,16,16,16,15,
+ 15,12,10,11,11,13,11,12,13,
+};
+
+static const static_codebook _44c6_s_p9_1 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c6_s_p9_1,
+ 1, -518889472, 1622704128, 4, 0,
+ (long *)_vq_quantlist__44c6_s_p9_1,
+ 0
+};
+
+static const long _vq_quantlist__44c6_s_p9_2[] = {
+ 24,
+ 23,
+ 25,
+ 22,
+ 26,
+ 21,
+ 27,
+ 20,
+ 28,
+ 19,
+ 29,
+ 18,
+ 30,
+ 17,
+ 31,
+ 16,
+ 32,
+ 15,
+ 33,
+ 14,
+ 34,
+ 13,
+ 35,
+ 12,
+ 36,
+ 11,
+ 37,
+ 10,
+ 38,
+ 9,
+ 39,
+ 8,
+ 40,
+ 7,
+ 41,
+ 6,
+ 42,
+ 5,
+ 43,
+ 4,
+ 44,
+ 3,
+ 45,
+ 2,
+ 46,
+ 1,
+ 47,
+ 0,
+ 48,
+};
+
+static const long _vq_lengthlist__44c6_s_p9_2[] = {
+ 2, 4, 3, 4, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7,
+};
+
+static const static_codebook _44c6_s_p9_2 = {
+ 1, 49,
+ (long *)_vq_lengthlist__44c6_s_p9_2,
+ 1, -526909440, 1611661312, 6, 0,
+ (long *)_vq_quantlist__44c6_s_p9_2,
+ 0
+};
+
+static const long _huff_lengthlist__44c6_s_short[] = {
+ 3, 9,11,11,13,14,19,17,17,19, 5, 4, 5, 8,10,10,
+ 13,16,18,19, 7, 4, 4, 5, 8, 9,12,14,17,19, 8, 6,
+ 5, 5, 7, 7,10,13,16,18,10, 8, 7, 6, 5, 5, 8,11,
+ 17,19,11, 9, 7, 7, 5, 4, 5, 8,17,19,13,11, 8, 7,
+ 7, 5, 5, 7,16,18,14,13, 8, 6, 6, 5, 5, 7,16,18,
+ 18,16,10, 8, 8, 7, 7, 9,16,18,18,18,12,10,10, 9,
+ 9,10,17,18,
+};
+
+static const static_codebook _huff_book__44c6_s_short = {
+ 2, 100,
+ (long *)_huff_lengthlist__44c6_s_short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44c7_s_long[] = {
+ 3, 8,11,13,15,14,14,13,15,14, 6, 4, 5, 7, 9,10,
+ 11,11,14,13,10, 4, 3, 5, 7, 8, 9,10,13,13,12, 7,
+ 4, 4, 5, 6, 8, 9,12,14,13, 9, 6, 5, 5, 6, 8, 9,
+ 12,14,12, 9, 7, 6, 5, 5, 6, 8,11,11,12,11, 9, 8,
+ 7, 6, 6, 7,10,11,13,11,10, 9, 8, 7, 6, 6, 9,11,
+ 13,13,12,12,12,10, 9, 8, 9,11,12,14,15,15,14,12,
+ 11,10,10,12,
+};
+
+static const static_codebook _huff_book__44c7_s_long = {
+ 2, 100,
+ (long *)_huff_lengthlist__44c7_s_long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44c7_s_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44c7_s_p1_0[] = {
+ 1, 5, 5, 0, 5, 5, 0, 5, 5, 5, 8, 7, 0, 9, 9, 0,
+ 9, 8, 5, 7, 8, 0, 9, 9, 0, 8, 9, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 5, 9, 9, 0, 8, 8, 0, 8, 8, 5, 8, 9,
+ 0, 8, 8, 0, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
+ 9, 9, 0, 8, 8, 0, 8, 8, 5, 8, 9, 0, 8, 8, 0, 8,
+ 8,
+};
+
+static const static_codebook _44c7_s_p1_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44c7_s_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44c7_s_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44c7_s_p2_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44c7_s_p2_0[] = {
+ 3, 5, 5, 8, 8, 0, 5, 5, 8, 8, 0, 5, 5, 8, 8, 0,
+ 7, 7, 9, 9, 0, 0, 0, 9, 9, 5, 7, 7, 9, 9, 0, 8,
+ 8,10,10, 0, 8, 7,10, 9, 0,10,10,11,11, 0, 0, 0,
+ 11,11, 5, 7, 7, 9, 9, 0, 8, 8,10,10, 0, 7, 8, 9,
+ 10, 0,10,10,11,11, 0, 0, 0,11,11, 8, 9, 9,11,10,
+ 0,11,11,12,12, 0,11,10,12,12, 0,13,14,14,14, 0,
+ 0, 0,14,13, 8, 9, 9,10,11, 0,11,11,12,12, 0,10,
+ 11,12,12, 0,13,13,14,14, 0, 0, 0,13,14, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 5, 8, 7,11,10, 0, 7, 7,10,10,
+ 0, 7, 7,10,10, 0, 9, 9,11,10, 0, 0, 0,11,11, 5,
+ 7, 8,10,11, 0, 7, 7,10,10, 0, 7, 7,10,10, 0, 9,
+ 9,10,11, 0, 0, 0,11,11, 8,10, 9,12,12, 0,10,10,
+ 12,12, 0,10,10,12,12, 0,12,12,13,13, 0, 0, 0,13,
+ 13, 8, 9,10,12,12, 0,10,10,12,12, 0,10,10,11,12,
+ 0,12,12,13,13, 0, 0, 0,13,13, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 5, 8, 8,11,11, 0, 7, 7,10,10, 0, 7, 7,
+ 10,10, 0, 9, 9,10,11, 0, 0, 0,11,10, 5, 8, 8,10,
+ 11, 0, 7, 7,10,10, 0, 7, 7,10,10, 0, 9, 9,11,10,
+ 0, 0, 0,10,11, 9,10,10,12,12, 0,10,10,12,12, 0,
+ 10,10,12,12, 0,12,13,13,13, 0, 0, 0,13,12, 9,10,
+ 10,12,12, 0,10,10,12,12, 0,10,10,12,12, 0,13,12,
+ 13,13, 0, 0, 0,12,13, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 7,10,10,14,13, 0, 9, 9,12,12, 0, 9, 9,12,12, 0,
+ 10,10,12,12, 0, 0, 0,12,12, 7,10,10,13,14, 0, 9,
+ 9,12,13, 0, 9, 9,12,12, 0,10,10,12,12, 0, 0, 0,
+ 12,12, 9,11,11,14,13, 0,11,10,13,12, 0,11,11,13,
+ 13, 0,12,12,13,13, 0, 0, 0,13,13, 9,11,11,13,14,
+ 0,10,11,12,13, 0,11,11,13,13, 0,12,12,13,13, 0,
+ 0, 0,13,13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9,
+ 11,11,14,14, 0,10,11,13,13, 0,11,10,13,13, 0,12,
+ 12,13,13, 0, 0, 0,13,12, 9,11,11,14,14, 0,11,10,
+ 13,13, 0,10,11,13,13, 0,12,12,14,13, 0, 0, 0,13,
+ 13,
+};
+
+static const static_codebook _44c7_s_p2_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44c7_s_p2_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44c7_s_p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44c7_s_p3_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44c7_s_p3_0[] = {
+ 2, 4, 4, 5, 5, 7, 7, 9, 9, 0, 4, 4, 6, 6, 7, 7,
+ 9, 9, 0, 4, 4, 6, 6, 7, 7, 9, 9, 0, 5, 5, 6, 6,
+ 8, 8,10,10, 0, 0, 0, 6, 6, 8, 8,10,10, 0, 0, 0,
+ 7, 7, 9, 9,10,10, 0, 0, 0, 7, 7, 8, 8,10,10, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c7_s_p3_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44c7_s_p3_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c7_s_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44c7_s_p4_0[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44c7_s_p4_0[] = {
+ 3, 4, 4, 5, 5, 7, 7, 8, 8, 8, 8, 9, 9,10,10,11,
+ 11, 0, 4, 4, 6, 6, 7, 7, 8, 8, 9, 9,10,10,11,11,
+ 12,12, 0, 4, 4, 6, 6, 7, 7, 8, 8, 9, 9,10,10,11,
+ 11,12,12, 0, 5, 5, 6, 6, 8, 8, 9, 9, 9, 9,10,10,
+ 11,12,12,12, 0, 0, 0, 6, 6, 8, 7, 9, 9, 9, 9,10,
+ 10,11,11,12,12, 0, 0, 0, 7, 7, 8, 8, 9, 9,10,10,
+ 11,11,12,12,13,12, 0, 0, 0, 7, 7, 8, 8, 9, 9,10,
+ 10,11,11,12,12,12,13, 0, 0, 0, 7, 7, 8, 8, 9, 9,
+ 10,10,11,11,12,12,13,13, 0, 0, 0, 0, 0, 8, 8, 9,
+ 9,10,10,11,11,12,12,13,13, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c7_s_p4_0 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44c7_s_p4_0,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44c7_s_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44c7_s_p5_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44c7_s_p5_0[] = {
+ 1, 4, 4, 5, 7, 7, 6, 7, 7, 4, 6, 7,10,10,10,10,
+ 10, 9, 4, 6, 6,10,10,10,10, 9,10, 5,10,10, 9,11,
+ 12,10,11,12, 7,10,10,11,12,12,12,12,12, 7,10,10,
+ 11,12,12,12,12,12, 6,10,10,10,12,12,11,12,12, 7,
+ 10,10,12,12,12,12,11,12, 7,10,10,11,12,12,12,12,
+ 12,
+};
+
+static const static_codebook _44c7_s_p5_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44c7_s_p5_0,
+ 1, -529137664, 1618345984, 2, 0,
+ (long *)_vq_quantlist__44c7_s_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44c7_s_p5_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44c7_s_p5_1[] = {
+ 3, 5, 5, 6, 6, 7, 7, 8, 8, 8, 8,11, 4, 4, 6, 6,
+ 7, 7, 8, 8, 9, 9,11, 4, 4, 6, 6, 7, 7, 8, 8, 9,
+ 9,12, 5, 5, 6, 6, 7, 7, 9, 9, 9, 9,12,12,12, 6,
+ 6, 7, 7, 9, 9, 9, 9,11,11,11, 7, 7, 7, 7, 8, 8,
+ 9, 9,11,11,11, 7, 7, 7, 7, 8, 8, 9, 9,11,11,11,
+ 7, 7, 8, 8, 8, 8, 9, 9,11,11,11,11,11, 8, 8, 8,
+ 8, 8, 9,11,11,11,11,11, 8, 8, 8, 8, 8, 8,11,11,
+ 11,11,11, 7, 7, 8, 8, 8, 8,
+};
+
+static const static_codebook _44c7_s_p5_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44c7_s_p5_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c7_s_p5_1,
+ 0
+};
+
+static const long _vq_quantlist__44c7_s_p6_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c7_s_p6_0[] = {
+ 1, 4, 4, 6, 6, 7, 7, 8, 7, 9, 8,10,10, 6, 5, 5,
+ 7, 7, 8, 8, 9, 9, 9,10,11,11, 7, 5, 5, 7, 7, 8,
+ 8, 9, 9,10,10,11,11, 0, 7, 7, 7, 7, 9, 8, 9, 9,
+ 10,10,11,11, 0, 8, 8, 7, 7, 8, 9, 9, 9,10,10,11,
+ 11, 0,11,11, 9, 9,10,10,11,10,11,11,12,12, 0,12,
+ 12, 9, 9,10,10,11,11,11,11,12,12, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+static const static_codebook _44c7_s_p6_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c7_s_p6_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44c7_s_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44c7_s_p6_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44c7_s_p6_1[] = {
+ 3, 4, 4, 5, 5, 5, 4, 4, 5, 5, 5, 4, 4, 5, 5, 6,
+ 5, 5, 5, 5, 6, 6, 6, 5, 5,
+};
+
+static const static_codebook _44c7_s_p6_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44c7_s_p6_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44c7_s_p6_1,
+ 0
+};
+
+static const long _vq_quantlist__44c7_s_p7_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c7_s_p7_0[] = {
+ 1, 4, 4, 6, 6, 7, 8, 9, 9,10,10,12,11, 6, 5, 5,
+ 7, 7, 8, 8, 9,10,11,11,12,12, 7, 5, 5, 7, 7, 8,
+ 8,10,10,11,11,12,12,20, 7, 7, 7, 7, 8, 9,10,10,
+ 11,11,12,13,20, 7, 7, 7, 7, 9, 9,10,10,11,12,13,
+ 13,20,11,11, 8, 8, 9, 9,11,11,12,12,13,13,20,11,
+ 11, 8, 8, 9, 9,11,11,12,12,13,13,20,20,20,10,10,
+ 10,10,12,12,13,13,13,13,20,20,20,10,10,10,10,12,
+ 12,13,13,13,14,20,20,20,14,14,11,11,12,12,13,13,
+ 14,14,20,20,20,14,14,11,11,12,12,13,13,14,14,20,
+ 20,20,20,19,13,13,13,13,14,14,15,14,19,19,19,19,
+ 19,13,13,13,13,14,14,15,15,
+};
+
+static const static_codebook _44c7_s_p7_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c7_s_p7_0,
+ 1, -523206656, 1618345984, 4, 0,
+ (long *)_vq_quantlist__44c7_s_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44c7_s_p7_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44c7_s_p7_1[] = {
+ 4, 5, 5, 6, 6, 7, 7, 7, 7, 7, 7, 8, 6, 6, 7, 7,
+ 7, 7, 7, 7, 7, 7, 8, 6, 6, 6, 7, 7, 7, 7, 7, 7,
+ 7, 8, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 7,
+ 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 7, 7, 7, 7, 7, 7,
+ 7, 7, 8, 8, 8, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8,
+ 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 7, 7, 7,
+ 7, 7, 7, 8, 8, 8, 8, 8, 7, 7, 7, 7, 7, 7, 8, 8,
+ 8, 8, 8, 7, 7, 7, 7, 7, 7,
+};
+
+static const static_codebook _44c7_s_p7_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44c7_s_p7_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c7_s_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44c7_s_p8_0[] = {
+ 7,
+ 6,
+ 8,
+ 5,
+ 9,
+ 4,
+ 10,
+ 3,
+ 11,
+ 2,
+ 12,
+ 1,
+ 13,
+ 0,
+ 14,
+};
+
+static const long _vq_lengthlist__44c7_s_p8_0[] = {
+ 1, 4, 4, 7, 7, 8, 8, 8, 7, 9, 8, 9, 9,10,10, 6,
+ 5, 5, 7, 7, 9, 9, 8, 8,10, 9,11,10,12,11, 6, 5,
+ 5, 8, 7, 9, 9, 8, 8,10,10,11,11,12,11,19, 8, 8,
+ 8, 8,10,10, 9, 9,10,10,11,11,12,11,19, 8, 8, 8,
+ 8,10,10, 9, 9,10,10,11,11,12,12,19,12,12, 9, 9,
+ 10,10, 9,10,10,10,11,11,12,12,19,12,12, 9, 9,10,
+ 10,10,10,10,10,12,12,12,12,19,19,19, 9, 9, 9, 9,
+ 11,10,11,11,12,11,13,13,19,19,19, 9, 9, 9, 9,11,
+ 10,11,11,11,12,13,13,19,19,19,13,13,10,10,11,11,
+ 12,12,12,12,13,12,19,19,19,14,13,10,10,11,11,12,
+ 12,12,13,13,13,19,19,19,19,19,12,12,12,11,12,13,
+ 14,13,13,13,19,19,19,19,19,12,12,12,11,12,12,13,
+ 14,13,14,19,19,19,19,19,16,16,12,13,12,13,13,14,
+ 15,14,19,18,18,18,18,16,15,12,11,12,11,14,12,14,
+ 14,
+};
+
+static const static_codebook _44c7_s_p8_0 = {
+ 2, 225,
+ (long *)_vq_lengthlist__44c7_s_p8_0,
+ 1, -520986624, 1620377600, 4, 0,
+ (long *)_vq_quantlist__44c7_s_p8_0,
+ 0
+};
+
+static const long _vq_quantlist__44c7_s_p8_1[] = {
+ 10,
+ 9,
+ 11,
+ 8,
+ 12,
+ 7,
+ 13,
+ 6,
+ 14,
+ 5,
+ 15,
+ 4,
+ 16,
+ 3,
+ 17,
+ 2,
+ 18,
+ 1,
+ 19,
+ 0,
+ 20,
+};
+
+static const long _vq_lengthlist__44c7_s_p8_1[] = {
+ 3, 5, 5, 7, 6, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8,10, 6, 6, 7, 7, 8, 8, 8, 8, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,10, 6, 6, 7, 7, 8,
+ 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,10,
+ 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9,10,10,10, 8, 8, 8, 8, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9,10,10,10, 8, 8, 8, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,10,10,
+ 10, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9,10,10,10, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9,10,11,10,10,10, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9,10, 9, 9,10, 9, 9,10,11,10,
+ 11,10, 9, 9, 9, 9, 9, 9, 9,10,10,10, 9,10, 9, 9,
+ 9, 9,11,10,11,10,10, 9, 9, 9, 9, 9, 9,10, 9, 9,
+ 10, 9, 9,10, 9, 9,10,11,10,10,11,10, 9, 9, 9, 9,
+ 9,10,10, 9,10,10,10,10, 9,10,10,10,10,10,10,11,
+ 11,11,10, 9, 9, 9,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,11,11,10,10,10,10,10,10,10,10,10,10,10,
+ 10, 9,10,10, 9,10,11,11,10,11,10,11,10, 9,10,10,
+ 9,10,10,10,10,10,10,10,10,10,10,11,11,11,11,10,
+ 11,11,10,10,10,10,10,10, 9,10, 9,10,10, 9,10, 9,
+ 10,10,10,11,10,11,10,11,11,10,10,10,10,10,10, 9,
+ 10,10,10,10,10,10,10,11,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,11,10,11,
+ 11,10,10,10,10, 9, 9,10,10, 9, 9,10, 9,10,10,10,
+ 10,11,11,10,10,10,10,10,10,10, 9, 9,10,10,10, 9,
+ 9,10,10,10,10,10,11,10,11,10,10,10,10,10,10, 9,
+ 10,10,10,10,10,10,10,10,10,
+};
+
+static const static_codebook _44c7_s_p8_1 = {
+ 2, 441,
+ (long *)_vq_lengthlist__44c7_s_p8_1,
+ 1, -529268736, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44c7_s_p8_1,
+ 0
+};
+
+static const long _vq_quantlist__44c7_s_p9_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c7_s_p9_0[] = {
+ 1, 3, 3,11,11,11,11,11,11,11,11,11,11, 4, 6, 6,
+ 11,11,11,11,11,11,11,11,11,11, 4, 7, 7,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,
+};
+
+static const static_codebook _44c7_s_p9_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c7_s_p9_0,
+ 1, -511845376, 1630791680, 4, 0,
+ (long *)_vq_quantlist__44c7_s_p9_0,
+ 0
+};
+
+static const long _vq_quantlist__44c7_s_p9_1[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c7_s_p9_1[] = {
+ 1, 4, 4, 7, 7, 7, 7, 7, 6, 8, 8, 8, 8, 6, 6, 6,
+ 8, 8, 9, 8, 8, 7, 9, 8,11,10, 5, 6, 6, 8, 8, 9,
+ 8, 8, 8,10, 9,11,11,16, 8, 8, 9, 8, 9, 9, 9, 8,
+ 10, 9,11,10,16, 8, 8, 9, 9,10,10, 9, 9,10,10,11,
+ 11,16,13,13, 9, 9,10,10, 9,10,11,11,12,11,16,13,
+ 13, 9, 8,10, 9,10,10,10,10,11,11,16,14,16, 8, 9,
+ 9, 9,11,10,11,11,12,11,16,16,16, 9, 7,10, 7,11,
+ 10,11,11,12,11,16,16,16,12,12, 9,10,11,11,12,11,
+ 12,12,16,16,16,12,10,10, 7,11, 8,12,11,12,12,16,
+ 16,15,16,16,11,12,10,10,12,11,12,12,16,16,16,15,
+ 15,11,11,10,10,12,12,12,12,
+};
+
+static const static_codebook _44c7_s_p9_1 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c7_s_p9_1,
+ 1, -518889472, 1622704128, 4, 0,
+ (long *)_vq_quantlist__44c7_s_p9_1,
+ 0
+};
+
+static const long _vq_quantlist__44c7_s_p9_2[] = {
+ 24,
+ 23,
+ 25,
+ 22,
+ 26,
+ 21,
+ 27,
+ 20,
+ 28,
+ 19,
+ 29,
+ 18,
+ 30,
+ 17,
+ 31,
+ 16,
+ 32,
+ 15,
+ 33,
+ 14,
+ 34,
+ 13,
+ 35,
+ 12,
+ 36,
+ 11,
+ 37,
+ 10,
+ 38,
+ 9,
+ 39,
+ 8,
+ 40,
+ 7,
+ 41,
+ 6,
+ 42,
+ 5,
+ 43,
+ 4,
+ 44,
+ 3,
+ 45,
+ 2,
+ 46,
+ 1,
+ 47,
+ 0,
+ 48,
+};
+
+static const long _vq_lengthlist__44c7_s_p9_2[] = {
+ 2, 4, 3, 4, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7,
+};
+
+static const static_codebook _44c7_s_p9_2 = {
+ 1, 49,
+ (long *)_vq_lengthlist__44c7_s_p9_2,
+ 1, -526909440, 1611661312, 6, 0,
+ (long *)_vq_quantlist__44c7_s_p9_2,
+ 0
+};
+
+static const long _huff_lengthlist__44c7_s_short[] = {
+ 4,11,12,14,15,15,17,17,18,18, 5, 6, 6, 8, 9,10,
+ 13,17,18,19, 7, 5, 4, 6, 8, 9,11,15,19,19, 8, 6,
+ 5, 5, 6, 7,11,14,16,17, 9, 7, 7, 6, 7, 7,10,13,
+ 15,19,10, 8, 7, 6, 7, 6, 7, 9,14,16,12,10, 9, 7,
+ 7, 6, 4, 5,10,15,14,13,11, 7, 6, 6, 4, 2, 7,13,
+ 16,16,15, 9, 8, 8, 8, 6, 9,13,19,19,17,12,11,10,
+ 10, 9,11,14,
+};
+
+static const static_codebook _huff_book__44c7_s_short = {
+ 2, 100,
+ (long *)_huff_lengthlist__44c7_s_short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44c8_s_long[] = {
+ 3, 8,12,13,14,14,14,13,14,14, 6, 4, 5, 8,10,10,
+ 11,11,14,13, 9, 5, 4, 5, 7, 8, 9,10,13,13,12, 7,
+ 5, 4, 5, 6, 8, 9,12,13,13, 9, 6, 5, 5, 5, 7, 9,
+ 11,14,12,10, 7, 6, 5, 4, 6, 7,10,11,12,11, 9, 8,
+ 7, 5, 5, 6,10,10,13,12,10, 9, 8, 6, 6, 5, 8,10,
+ 14,13,12,12,11,10, 9, 7, 8,10,12,13,14,14,13,12,
+ 11, 9, 9,10,
+};
+
+static const static_codebook _huff_book__44c8_s_long = {
+ 2, 100,
+ (long *)_huff_lengthlist__44c8_s_long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44c8_s_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44c8_s_p1_0[] = {
+ 1, 5, 5, 0, 5, 5, 0, 5, 5, 5, 7, 7, 0, 9, 8, 0,
+ 9, 8, 6, 7, 7, 0, 8, 9, 0, 8, 9, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 5, 9, 8, 0, 8, 8, 0, 8, 8, 5, 8, 9,
+ 0, 8, 8, 0, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
+ 9, 8, 0, 8, 8, 0, 8, 8, 5, 8, 9, 0, 8, 8, 0, 8,
+ 8,
+};
+
+static const static_codebook _44c8_s_p1_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44c8_s_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44c8_s_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44c8_s_p2_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44c8_s_p2_0[] = {
+ 3, 5, 5, 8, 8, 0, 5, 5, 8, 8, 0, 5, 5, 8, 8, 0,
+ 7, 7, 9, 9, 0, 0, 0, 9, 9, 5, 7, 7, 9, 9, 0, 8,
+ 7,10, 9, 0, 8, 7,10, 9, 0,10,10,11,11, 0, 0, 0,
+ 11,11, 5, 7, 7, 9, 9, 0, 7, 8, 9,10, 0, 7, 8, 9,
+ 10, 0,10,10,11,11, 0, 0, 0,11,11, 8, 9, 9,11,10,
+ 0,11,10,12,11, 0,11,10,12,12, 0,13,13,14,14, 0,
+ 0, 0,14,13, 8, 9, 9,10,11, 0,10,11,12,12, 0,10,
+ 11,12,12, 0,13,13,14,14, 0, 0, 0,13,14, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 5, 8, 7,11,10, 0, 7, 7,10,10,
+ 0, 7, 7,10,10, 0, 9, 9,10,10, 0, 0, 0,11,10, 5,
+ 7, 8,10,11, 0, 7, 7,10,10, 0, 7, 7,10,10, 0, 9,
+ 9,10,10, 0, 0, 0,10,10, 8,10, 9,12,12, 0,10,10,
+ 12,11, 0,10,10,12,12, 0,12,12,13,12, 0, 0, 0,13,
+ 12, 8, 9,10,12,12, 0,10,10,11,12, 0,10,10,11,12,
+ 0,12,12,13,13, 0, 0, 0,12,13, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 6, 8, 7,11,10, 0, 7, 7,10,10, 0, 7, 7,
+ 10,10, 0, 9, 9,10,11, 0, 0, 0,10,10, 6, 7, 8,10,
+ 11, 0, 7, 7,10,10, 0, 7, 7,10,10, 0, 9, 9,10,10,
+ 0, 0, 0,10,10, 9,10, 9,12,12, 0,10,10,12,12, 0,
+ 10,10,12,11, 0,12,12,13,13, 0, 0, 0,13,12, 8, 9,
+ 10,12,12, 0,10,10,12,12, 0,10,10,11,12, 0,12,12,
+ 13,13, 0, 0, 0,12,13, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 7,10,10,13,13, 0, 9, 9,12,12, 0, 9, 9,12,12, 0,
+ 10,10,12,12, 0, 0, 0,12,12, 7,10,10,13,13, 0, 9,
+ 9,12,12, 0, 9, 9,12,12, 0,10,10,12,12, 0, 0, 0,
+ 12,12, 9,11,11,14,13, 0,10,10,13,12, 0,11,10,13,
+ 12, 0,12,12,13,12, 0, 0, 0,13,13, 9,11,11,13,14,
+ 0,10,11,12,13, 0,10,11,13,13, 0,12,12,12,13, 0,
+ 0, 0,13,13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9,
+ 11,11,14,14, 0,10,11,13,13, 0,11,10,13,13, 0,11,
+ 12,13,13, 0, 0, 0,13,12, 9,11,11,14,14, 0,11,10,
+ 13,13, 0,10,11,13,13, 0,12,12,13,13, 0, 0, 0,12,
+ 13,
+};
+
+static const static_codebook _44c8_s_p2_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44c8_s_p2_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44c8_s_p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44c8_s_p3_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44c8_s_p3_0[] = {
+ 2, 4, 4, 5, 5, 7, 7, 9, 9, 0, 4, 4, 6, 6, 7, 7,
+ 9, 9, 0, 4, 4, 6, 6, 7, 7, 9, 9, 0, 5, 5, 6, 6,
+ 8, 8,10,10, 0, 0, 0, 6, 6, 8, 8,10,10, 0, 0, 0,
+ 7, 7, 9, 9,10,10, 0, 0, 0, 7, 7, 8, 8,10,10, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c8_s_p3_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44c8_s_p3_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c8_s_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44c8_s_p4_0[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44c8_s_p4_0[] = {
+ 3, 4, 4, 5, 5, 7, 7, 8, 8, 8, 8, 9, 9,10,10,11,
+ 11, 0, 4, 4, 6, 6, 7, 7, 8, 8, 9, 8,10,10,11,11,
+ 11,11, 0, 4, 4, 6, 6, 7, 7, 8, 8, 9, 9,10,10,11,
+ 11,11,11, 0, 6, 5, 6, 6, 7, 7, 9, 9, 9, 9,10,10,
+ 11,11,12,12, 0, 0, 0, 6, 6, 7, 7, 9, 9, 9, 9,10,
+ 10,11,11,12,12, 0, 0, 0, 7, 7, 8, 8, 9, 9,10,10,
+ 11,11,11,12,12,12, 0, 0, 0, 7, 7, 8, 8, 9, 9,10,
+ 10,11,11,11,12,12,12, 0, 0, 0, 7, 7, 8, 8, 9, 9,
+ 10,10,11,11,12,12,13,13, 0, 0, 0, 0, 0, 8, 8, 9,
+ 9,10,10,11,11,12,12,13,13, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c8_s_p4_0 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44c8_s_p4_0,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44c8_s_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44c8_s_p5_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44c8_s_p5_0[] = {
+ 1, 4, 4, 5, 7, 7, 6, 7, 7, 4, 7, 6,10,10,10,10,
+ 10,10, 4, 6, 6,10,10,10,10, 9,10, 5,10,10, 9,11,
+ 11,10,11,11, 7,10,10,11,12,12,12,12,12, 7,10,10,
+ 11,12,12,12,12,12, 6,10,10,10,12,12,10,12,12, 7,
+ 10,10,11,12,12,12,12,12, 7,10,10,11,12,12,12,12,
+ 12,
+};
+
+static const static_codebook _44c8_s_p5_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44c8_s_p5_0,
+ 1, -529137664, 1618345984, 2, 0,
+ (long *)_vq_quantlist__44c8_s_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44c8_s_p5_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44c8_s_p5_1[] = {
+ 3, 5, 5, 6, 6, 7, 7, 8, 8, 8, 8,11, 4, 5, 6, 6,
+ 7, 7, 8, 8, 8, 8,11, 5, 5, 6, 6, 7, 7, 8, 8, 8,
+ 9,12, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9,12,12,12, 6,
+ 6, 7, 7, 8, 8, 9, 9,11,11,11, 6, 6, 7, 7, 8, 8,
+ 8, 8,11,11,11, 6, 6, 7, 7, 8, 8, 8, 8,11,11,11,
+ 7, 7, 7, 8, 8, 8, 8, 8,11,11,11,11,11, 7, 7, 8,
+ 8, 8, 8,11,11,11,11,11, 7, 7, 7, 7, 8, 8,11,11,
+ 11,11,11, 7, 7, 7, 7, 8, 8,
+};
+
+static const static_codebook _44c8_s_p5_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44c8_s_p5_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c8_s_p5_1,
+ 0
+};
+
+static const long _vq_quantlist__44c8_s_p6_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c8_s_p6_0[] = {
+ 1, 4, 4, 6, 6, 7, 7, 8, 8, 9, 9,10,10, 6, 5, 5,
+ 7, 7, 8, 8, 9, 9,10,10,11,11, 6, 5, 5, 7, 7, 8,
+ 8, 9, 9,10,10,11,11, 0, 7, 7, 7, 7, 9, 9,10,10,
+ 10,10,11,11, 0, 7, 7, 7, 7, 9, 9,10,10,10,10,11,
+ 11, 0,11,11, 9, 9,10,10,11,11,11,11,12,12, 0,12,
+ 12, 9, 9,10,10,11,11,12,12,12,12, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+static const static_codebook _44c8_s_p6_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c8_s_p6_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44c8_s_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44c8_s_p6_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44c8_s_p6_1[] = {
+ 3, 4, 4, 5, 5, 5, 4, 4, 5, 5, 5, 4, 4, 5, 5, 6,
+ 5, 5, 5, 5, 6, 6, 6, 5, 5,
+};
+
+static const static_codebook _44c8_s_p6_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44c8_s_p6_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44c8_s_p6_1,
+ 0
+};
+
+static const long _vq_quantlist__44c8_s_p7_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c8_s_p7_0[] = {
+ 1, 4, 4, 6, 6, 8, 7, 9, 9,10,10,12,12, 6, 5, 5,
+ 7, 7, 8, 8,10,10,11,11,12,12, 7, 5, 5, 7, 7, 8,
+ 8,10,10,11,11,12,12,21, 7, 7, 7, 7, 8, 9,10,10,
+ 11,11,12,12,21, 7, 7, 7, 7, 9, 9,10,10,12,12,13,
+ 13,21,11,11, 8, 8, 9, 9,11,11,12,12,13,13,21,11,
+ 11, 8, 8, 9, 9,11,11,12,12,13,13,21,21,21,10,10,
+ 10,10,11,11,12,13,13,13,21,21,21,10,10,10,10,11,
+ 11,13,13,14,13,21,21,21,13,13,11,11,12,12,13,13,
+ 14,14,21,21,21,14,14,11,11,12,12,13,13,14,14,21,
+ 21,21,21,20,13,13,13,12,14,14,16,15,20,20,20,20,
+ 20,13,13,13,13,14,13,15,15,
+};
+
+static const static_codebook _44c8_s_p7_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c8_s_p7_0,
+ 1, -523206656, 1618345984, 4, 0,
+ (long *)_vq_quantlist__44c8_s_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44c8_s_p7_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44c8_s_p7_1[] = {
+ 4, 5, 6, 6, 6, 7, 7, 7, 7, 7, 7, 8, 6, 6, 6, 7,
+ 7, 7, 7, 7, 7, 7, 8, 6, 6, 6, 6, 7, 7, 7, 7, 7,
+ 7, 8, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 7,
+ 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 7, 7, 7, 7, 7, 7,
+ 7, 7, 8, 8, 8, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8,
+ 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 7, 7, 7,
+ 7, 7, 7, 8, 8, 8, 8, 8, 7, 7, 7, 7, 7, 7, 8, 8,
+ 8, 8, 8, 7, 7, 7, 7, 7, 7,
+};
+
+static const static_codebook _44c8_s_p7_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44c8_s_p7_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c8_s_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44c8_s_p8_0[] = {
+ 7,
+ 6,
+ 8,
+ 5,
+ 9,
+ 4,
+ 10,
+ 3,
+ 11,
+ 2,
+ 12,
+ 1,
+ 13,
+ 0,
+ 14,
+};
+
+static const long _vq_lengthlist__44c8_s_p8_0[] = {
+ 1, 4, 4, 7, 6, 8, 8, 8, 7, 9, 8,10,10,11,10, 6,
+ 5, 5, 7, 7, 9, 9, 8, 8,10,10,11,11,12,11, 6, 5,
+ 5, 7, 7, 9, 9, 9, 9,10,10,11,11,12,12,20, 8, 8,
+ 8, 8, 9, 9, 9, 9,10,10,11,11,12,12,20, 8, 8, 8,
+ 8,10, 9, 9, 9,10,10,11,11,12,12,20,12,12, 9, 9,
+ 10,10,10,10,10,11,12,12,12,12,20,12,12, 9, 9,10,
+ 10,10,10,11,11,12,12,13,13,20,20,20, 9, 9, 9, 9,
+ 11,10,11,11,12,12,12,13,20,19,19, 9, 9, 9, 9,11,
+ 11,11,12,12,12,13,13,19,19,19,13,13,10,10,11,11,
+ 12,12,13,13,13,13,19,19,19,14,13,11,10,11,11,12,
+ 12,12,13,13,13,19,19,19,19,19,12,12,12,12,13,13,
+ 13,13,14,13,19,19,19,19,19,12,12,12,11,12,12,13,
+ 14,14,14,19,19,19,19,19,16,15,13,12,13,13,13,14,
+ 14,14,19,19,19,19,19,17,17,13,12,13,11,14,13,15,
+ 15,
+};
+
+static const static_codebook _44c8_s_p8_0 = {
+ 2, 225,
+ (long *)_vq_lengthlist__44c8_s_p8_0,
+ 1, -520986624, 1620377600, 4, 0,
+ (long *)_vq_quantlist__44c8_s_p8_0,
+ 0
+};
+
+static const long _vq_quantlist__44c8_s_p8_1[] = {
+ 10,
+ 9,
+ 11,
+ 8,
+ 12,
+ 7,
+ 13,
+ 6,
+ 14,
+ 5,
+ 15,
+ 4,
+ 16,
+ 3,
+ 17,
+ 2,
+ 18,
+ 1,
+ 19,
+ 0,
+ 20,
+};
+
+static const long _vq_lengthlist__44c8_s_p8_1[] = {
+ 4, 5, 5, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8,10, 6, 6, 7, 7, 8, 8, 8, 8, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,10, 6, 6, 7, 7, 8,
+ 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,10,
+ 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9,10,10,10, 8, 8, 8, 8, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9,10,10,10, 8, 8, 8, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,10,10,
+ 10, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9,10,10,10, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9,10,10,10,10,10, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,10,10,10,
+ 10,10, 9, 9, 9, 9, 9, 9, 9, 9,10, 9, 9, 9, 9, 9,
+ 9, 9,10,10,10,10,10, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9,10,10,10,10,10, 9, 9, 9, 9,
+ 9, 9, 9, 9,10,10,10, 9, 9, 9, 9, 9,10,10,10,10,
+ 10,10,10, 9, 9, 9, 9, 9,10,10,10, 9, 9, 9, 9, 9,
+ 9,10,10,10,10,10,10,10, 9,10,10, 9,10,10,10,10,
+ 9,10, 9,10,10, 9,10,10,10,10,10,10,10, 9,10,10,
+ 10,10,10,10, 9, 9,10,10, 9,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10, 9, 9, 9,10, 9, 9, 9, 9,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10, 9, 9,
+ 10, 9,10, 9,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10, 9, 9,10, 9, 9, 9,10,10,10,10,10,10,
+ 10,10,10,10,10, 9, 9, 9, 9, 9, 9,10, 9, 9,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10, 9,10, 9,
+ 9,10, 9, 9,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10, 9, 9,10,10, 9,10, 9, 9,
+};
+
+static const static_codebook _44c8_s_p8_1 = {
+ 2, 441,
+ (long *)_vq_lengthlist__44c8_s_p8_1,
+ 1, -529268736, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44c8_s_p8_1,
+ 0
+};
+
+static const long _vq_quantlist__44c8_s_p9_0[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44c8_s_p9_0[] = {
+ 1, 4, 3,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11, 4, 7, 7,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11, 4, 8,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,
+};
+
+static const static_codebook _44c8_s_p9_0 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44c8_s_p9_0,
+ 1, -509798400, 1631393792, 5, 0,
+ (long *)_vq_quantlist__44c8_s_p9_0,
+ 0
+};
+
+static const long _vq_quantlist__44c8_s_p9_1[] = {
+ 9,
+ 8,
+ 10,
+ 7,
+ 11,
+ 6,
+ 12,
+ 5,
+ 13,
+ 4,
+ 14,
+ 3,
+ 15,
+ 2,
+ 16,
+ 1,
+ 17,
+ 0,
+ 18,
+};
+
+static const long _vq_lengthlist__44c8_s_p9_1[] = {
+ 1, 4, 4, 7, 6, 7, 7, 7, 7, 8, 8, 9, 9,10,10,10,
+ 10,11,11, 6, 6, 6, 8, 8, 9, 8, 8, 7,10, 8,11,10,
+ 12,11,12,12,13,13, 5, 5, 6, 8, 8, 9, 9, 8, 8,10,
+ 9,11,11,12,12,13,13,13,13,17, 8, 8, 9, 9, 9, 9,
+ 9, 9,10, 9,12,10,12,12,13,12,13,13,17, 9, 8, 9,
+ 9, 9, 9, 9, 9,10,10,12,12,12,12,13,13,13,13,17,
+ 13,13, 9, 9,10,10,10,10,11,11,12,11,13,12,13,13,
+ 14,15,17,13,13, 9, 8,10, 9,10,10,11,11,12,12,14,
+ 13,15,13,14,15,17,17,17, 9,10, 9,10,11,11,12,12,
+ 12,12,13,13,14,14,15,15,17,17,17, 9, 8, 9, 8,11,
+ 11,12,12,12,12,14,13,14,14,14,15,17,17,17,12,14,
+ 9,10,11,11,12,12,14,13,13,14,15,13,15,15,17,17,
+ 17,13,11,10, 8,11, 9,13,12,13,13,13,13,13,14,14,
+ 14,17,17,17,17,17,11,12,11,11,13,13,14,13,15,14,
+ 13,15,16,15,17,17,17,17,17,11,11,12, 8,13,12,14,
+ 13,17,14,15,14,15,14,17,17,17,17,17,15,15,12,12,
+ 12,12,13,14,14,14,15,14,17,14,17,17,17,17,17,16,
+ 17,12,12,13,12,13,13,14,14,14,14,14,14,17,17,17,
+ 17,17,17,17,14,14,13,12,13,13,15,15,14,13,15,17,
+ 17,17,17,17,17,17,17,13,14,13,13,13,13,14,15,15,
+ 15,14,15,17,17,17,17,17,17,17,16,15,13,14,13,13,
+ 14,14,15,14,14,16,17,17,17,17,17,17,17,16,16,13,
+ 14,13,13,14,14,15,14,15,14,
+};
+
+static const static_codebook _44c8_s_p9_1 = {
+ 2, 361,
+ (long *)_vq_lengthlist__44c8_s_p9_1,
+ 1, -518287360, 1622704128, 5, 0,
+ (long *)_vq_quantlist__44c8_s_p9_1,
+ 0
+};
+
+static const long _vq_quantlist__44c8_s_p9_2[] = {
+ 24,
+ 23,
+ 25,
+ 22,
+ 26,
+ 21,
+ 27,
+ 20,
+ 28,
+ 19,
+ 29,
+ 18,
+ 30,
+ 17,
+ 31,
+ 16,
+ 32,
+ 15,
+ 33,
+ 14,
+ 34,
+ 13,
+ 35,
+ 12,
+ 36,
+ 11,
+ 37,
+ 10,
+ 38,
+ 9,
+ 39,
+ 8,
+ 40,
+ 7,
+ 41,
+ 6,
+ 42,
+ 5,
+ 43,
+ 4,
+ 44,
+ 3,
+ 45,
+ 2,
+ 46,
+ 1,
+ 47,
+ 0,
+ 48,
+};
+
+static const long _vq_lengthlist__44c8_s_p9_2[] = {
+ 2, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7,
+};
+
+static const static_codebook _44c8_s_p9_2 = {
+ 1, 49,
+ (long *)_vq_lengthlist__44c8_s_p9_2,
+ 1, -526909440, 1611661312, 6, 0,
+ (long *)_vq_quantlist__44c8_s_p9_2,
+ 0
+};
+
+static const long _huff_lengthlist__44c8_s_short[] = {
+ 4,11,13,14,15,15,18,17,19,17, 5, 6, 8, 9,10,10,
+ 12,15,19,19, 6, 6, 6, 6, 8, 8,11,14,18,19, 8, 6,
+ 5, 4, 6, 7,10,13,16,17, 9, 7, 6, 5, 6, 7, 9,12,
+ 15,19,10, 8, 7, 6, 6, 6, 7, 9,13,15,12,10, 9, 8,
+ 7, 6, 4, 5,10,15,13,13,11, 8, 6, 6, 4, 2, 7,12,
+ 17,15,16,10, 8, 8, 7, 6, 9,12,19,18,17,13,11,10,
+ 10, 9,11,14,
+};
+
+static const static_codebook _huff_book__44c8_s_short = {
+ 2, 100,
+ (long *)_huff_lengthlist__44c8_s_short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44c9_s_long[] = {
+ 3, 8,12,14,15,15,15,13,15,15, 6, 5, 8,10,12,12,
+ 13,12,14,13,10, 6, 5, 6, 8, 9,11,11,13,13,13, 8,
+ 5, 4, 5, 6, 8,10,11,13,14,10, 7, 5, 4, 5, 7, 9,
+ 11,12,13,11, 8, 6, 5, 4, 5, 7, 9,11,12,11,10, 8,
+ 7, 5, 4, 5, 9,10,13,13,11,10, 8, 6, 5, 4, 7, 9,
+ 15,14,13,12,10, 9, 8, 7, 8, 9,12,12,14,13,12,11,
+ 10, 9, 8, 9,
+};
+
+static const static_codebook _huff_book__44c9_s_long = {
+ 2, 100,
+ (long *)_huff_lengthlist__44c9_s_long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44c9_s_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44c9_s_p1_0[] = {
+ 1, 5, 5, 0, 5, 5, 0, 5, 5, 6, 8, 8, 0, 9, 8, 0,
+ 9, 8, 6, 8, 8, 0, 8, 9, 0, 8, 9, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 5, 8, 8, 0, 7, 7, 0, 8, 8, 5, 8, 8,
+ 0, 7, 8, 0, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
+ 9, 8, 0, 8, 8, 0, 7, 7, 5, 8, 9, 0, 8, 8, 0, 7,
+ 7,
+};
+
+static const static_codebook _44c9_s_p1_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44c9_s_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44c9_s_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44c9_s_p2_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44c9_s_p2_0[] = {
+ 3, 5, 5, 8, 8, 0, 5, 5, 8, 8, 0, 5, 5, 8, 8, 0,
+ 7, 7, 9, 9, 0, 0, 0, 9, 9, 6, 7, 7, 9, 8, 0, 8,
+ 8, 9, 9, 0, 8, 7, 9, 9, 0, 9,10,10,10, 0, 0, 0,
+ 11,10, 6, 7, 7, 8, 9, 0, 8, 8, 9, 9, 0, 7, 8, 9,
+ 9, 0,10, 9,11,10, 0, 0, 0,10,10, 8, 9, 8,10,10,
+ 0,10,10,12,11, 0,10,10,11,11, 0,12,13,13,13, 0,
+ 0, 0,13,12, 8, 8, 9,10,10, 0,10,10,11,12, 0,10,
+ 10,11,11, 0,13,12,13,13, 0, 0, 0,13,13, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 6, 8, 7,10,10, 0, 7, 7,10, 9,
+ 0, 7, 7,10,10, 0, 9, 9,10,10, 0, 0, 0,10,10, 6,
+ 7, 8,10,10, 0, 7, 7, 9,10, 0, 7, 7,10,10, 0, 9,
+ 9,10,10, 0, 0, 0,10,10, 8, 9, 9,11,11, 0,10,10,
+ 11,11, 0,10,10,11,11, 0,12,12,12,12, 0, 0, 0,12,
+ 12, 8, 9,10,11,11, 0, 9,10,11,11, 0,10,10,11,11,
+ 0,12,12,12,12, 0, 0, 0,12,12, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 5, 8, 7,10,10, 0, 7, 7,10,10, 0, 7, 7,
+ 10, 9, 0, 9, 9,10,10, 0, 0, 0,10,10, 6, 7, 8,10,
+ 10, 0, 7, 7,10,10, 0, 7, 7, 9,10, 0, 9, 9,10,10,
+ 0, 0, 0,10,10, 8,10, 9,12,11, 0,10,10,12,11, 0,
+ 10, 9,11,11, 0,11,12,12,12, 0, 0, 0,12,12, 8, 9,
+ 10,11,12, 0,10,10,11,11, 0, 9,10,11,11, 0,12,11,
+ 12,12, 0, 0, 0,12,12, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 7,10, 9,12,12, 0, 9, 9,12,11, 0, 9, 9,11,11, 0,
+ 10,10,12,11, 0, 0, 0,11,12, 7, 9,10,12,12, 0, 9,
+ 9,11,12, 0, 9, 9,11,11, 0,10,10,11,12, 0, 0, 0,
+ 11,11, 9,11,10,13,12, 0,10,10,12,12, 0,10,10,12,
+ 12, 0,11,11,12,12, 0, 0, 0,13,12, 9,10,11,12,13,
+ 0,10,10,12,12, 0,10,10,12,12, 0,11,12,12,12, 0,
+ 0, 0,12,13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9,
+ 11,10,13,13, 0,10,10,12,12, 0,10,10,12,12, 0,11,
+ 12,12,12, 0, 0, 0,12,12, 9,10,11,13,13, 0,10,10,
+ 12,12, 0,10,10,12,12, 0,12,11,13,12, 0, 0, 0,12,
+ 12,
+};
+
+static const static_codebook _44c9_s_p2_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44c9_s_p2_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44c9_s_p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44c9_s_p3_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44c9_s_p3_0[] = {
+ 3, 4, 4, 5, 5, 6, 6, 8, 8, 0, 4, 4, 5, 5, 6, 7,
+ 8, 8, 0, 4, 4, 5, 5, 7, 7, 8, 8, 0, 5, 5, 6, 6,
+ 7, 7, 9, 9, 0, 0, 0, 6, 6, 7, 7, 9, 9, 0, 0, 0,
+ 7, 7, 8, 8, 9, 9, 0, 0, 0, 7, 7, 8, 8, 9, 9, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c9_s_p3_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44c9_s_p3_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c9_s_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44c9_s_p4_0[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44c9_s_p4_0[] = {
+ 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9,10,10,10,
+ 10, 0, 5, 4, 5, 5, 7, 7, 8, 8, 8, 8, 9, 9,10,10,
+ 11,11, 0, 5, 5, 6, 6, 7, 7, 8, 8, 8, 8, 9, 9,10,
+ 10,11,11, 0, 6, 5, 6, 6, 7, 7, 8, 8, 9, 9,10,10,
+ 11,11,11,12, 0, 0, 0, 6, 6, 7, 7, 8, 8, 9, 9,10,
+ 10,11,11,12,12, 0, 0, 0, 7, 7, 7, 7, 9, 9, 9, 9,
+ 10,10,11,11,12,12, 0, 0, 0, 7, 7, 7, 8, 9, 9, 9,
+ 9,10,10,11,11,12,12, 0, 0, 0, 7, 7, 8, 8, 9, 9,
+ 10,10,11,11,12,12,13,13, 0, 0, 0, 0, 0, 8, 8, 9,
+ 9,10,10,11,11,12,12,12,12, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c9_s_p4_0 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44c9_s_p4_0,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44c9_s_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44c9_s_p5_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44c9_s_p5_0[] = {
+ 1, 4, 4, 5, 7, 7, 6, 7, 7, 4, 7, 6, 9,10,10,10,
+ 10, 9, 4, 6, 7, 9,10,10,10, 9,10, 5, 9, 9, 9,11,
+ 11,10,11,11, 7,10, 9,11,12,11,12,12,12, 7, 9,10,
+ 11,11,12,12,12,12, 6,10,10,10,12,12,10,12,11, 7,
+ 10,10,11,12,12,11,12,12, 7,10,10,11,12,12,12,12,
+ 12,
+};
+
+static const static_codebook _44c9_s_p5_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44c9_s_p5_0,
+ 1, -529137664, 1618345984, 2, 0,
+ (long *)_vq_quantlist__44c9_s_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44c9_s_p5_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44c9_s_p5_1[] = {
+ 4, 5, 5, 6, 6, 7, 7, 7, 7, 7, 7,11, 5, 5, 6, 6,
+ 7, 7, 7, 7, 8, 8,11, 5, 5, 6, 6, 7, 7, 7, 7, 8,
+ 8,11, 5, 5, 6, 6, 7, 7, 8, 8, 8, 8,11,11,11, 6,
+ 6, 7, 7, 7, 8, 8, 8,11,11,11, 6, 6, 7, 7, 7, 8,
+ 8, 8,11,11,11, 6, 6, 7, 7, 7, 7, 8, 8,11,11,11,
+ 7, 7, 7, 7, 7, 7, 8, 8,11,11,11,10,10, 7, 7, 7,
+ 7, 8, 8,11,11,11,11,11, 7, 7, 7, 7, 7, 7,11,11,
+ 11,11,11, 7, 7, 7, 7, 7, 7,
+};
+
+static const static_codebook _44c9_s_p5_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44c9_s_p5_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c9_s_p5_1,
+ 0
+};
+
+static const long _vq_quantlist__44c9_s_p6_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c9_s_p6_0[] = {
+ 2, 4, 4, 6, 6, 7, 7, 7, 7, 8, 8, 9, 9, 5, 4, 4,
+ 6, 6, 8, 8, 9, 9, 9, 9,10,10, 6, 4, 4, 6, 6, 8,
+ 8, 9, 9, 9, 9,10,10, 0, 6, 6, 7, 7, 8, 8, 9, 9,
+ 10,10,11,11, 0, 6, 6, 7, 7, 8, 8, 9, 9,10,10,11,
+ 11, 0,10,10, 8, 8, 9, 9,10,10,11,11,12,12, 0,11,
+ 11, 8, 8, 9, 9,10,10,11,11,12,12, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+static const static_codebook _44c9_s_p6_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c9_s_p6_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44c9_s_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44c9_s_p6_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44c9_s_p6_1[] = {
+ 4, 4, 4, 5, 5, 5, 4, 4, 5, 5, 5, 4, 4, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5,
+};
+
+static const static_codebook _44c9_s_p6_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44c9_s_p6_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44c9_s_p6_1,
+ 0
+};
+
+static const long _vq_quantlist__44c9_s_p7_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c9_s_p7_0[] = {
+ 2, 4, 4, 6, 6, 7, 7, 8, 8,10,10,11,11, 6, 4, 4,
+ 6, 6, 8, 8, 9, 9,10,10,12,12, 6, 4, 5, 6, 6, 8,
+ 8, 9, 9,10,10,12,12,20, 6, 6, 6, 6, 8, 8, 9,10,
+ 11,11,12,12,20, 6, 6, 6, 6, 8, 8,10,10,11,11,12,
+ 12,20,10,10, 7, 7, 9, 9,10,10,11,11,12,12,20,11,
+ 11, 7, 7, 9, 9,10,10,11,11,12,12,20,20,20, 9, 9,
+ 9, 9,11,11,12,12,13,13,20,20,20, 9, 9, 9, 9,11,
+ 11,12,12,13,13,20,20,20,13,13,10,10,11,11,12,13,
+ 13,13,20,20,20,13,13,10,10,11,11,12,13,13,13,20,
+ 20,20,20,19,12,12,12,12,13,13,14,15,19,19,19,19,
+ 19,12,12,12,12,13,13,14,14,
+};
+
+static const static_codebook _44c9_s_p7_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c9_s_p7_0,
+ 1, -523206656, 1618345984, 4, 0,
+ (long *)_vq_quantlist__44c9_s_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44c9_s_p7_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44c9_s_p7_1[] = {
+ 5, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6,
+ 7, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 7, 7, 7, 7, 7,
+ 7, 8, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 8, 8, 8, 6,
+ 6, 7, 7, 7, 7, 7, 7, 8, 8, 8, 7, 7, 7, 7, 7, 7,
+ 7, 7, 8, 8, 8, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8,
+ 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 7, 7, 7,
+ 7, 7, 7, 8, 8, 8, 8, 8, 7, 7, 7, 7, 7, 7, 8, 8,
+ 8, 8, 8, 7, 7, 7, 7, 7, 7,
+};
+
+static const static_codebook _44c9_s_p7_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44c9_s_p7_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c9_s_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44c9_s_p8_0[] = {
+ 7,
+ 6,
+ 8,
+ 5,
+ 9,
+ 4,
+ 10,
+ 3,
+ 11,
+ 2,
+ 12,
+ 1,
+ 13,
+ 0,
+ 14,
+};
+
+static const long _vq_lengthlist__44c9_s_p8_0[] = {
+ 1, 4, 4, 7, 6, 8, 8, 8, 8, 9, 9,10,10,11,10, 6,
+ 5, 5, 7, 7, 9, 9, 8, 9,10,10,11,11,12,12, 6, 5,
+ 5, 7, 7, 9, 9, 9, 9,10,10,11,11,12,12,21, 7, 8,
+ 8, 8, 9, 9, 9, 9,10,10,11,11,12,12,21, 8, 8, 8,
+ 8, 9, 9, 9, 9,10,10,11,11,12,12,21,11,12, 9, 9,
+ 10,10,10,10,10,11,11,12,12,12,21,12,12, 9, 8,10,
+ 10,10,10,11,11,12,12,13,13,21,21,21, 9, 9, 9, 9,
+ 11,11,11,11,12,12,12,13,21,20,20, 9, 9, 9, 9,10,
+ 11,11,11,12,12,13,13,20,20,20,13,13,10,10,11,11,
+ 12,12,13,13,13,13,20,20,20,13,13,10,10,11,11,12,
+ 12,13,13,13,13,20,20,20,20,20,12,12,12,12,12,12,
+ 13,13,14,14,20,20,20,20,20,12,12,12,11,13,12,13,
+ 13,14,14,20,20,20,20,20,15,16,13,12,13,13,14,13,
+ 14,14,20,20,20,20,20,16,15,12,12,13,12,14,13,14,
+ 14,
+};
+
+static const static_codebook _44c9_s_p8_0 = {
+ 2, 225,
+ (long *)_vq_lengthlist__44c9_s_p8_0,
+ 1, -520986624, 1620377600, 4, 0,
+ (long *)_vq_quantlist__44c9_s_p8_0,
+ 0
+};
+
+static const long _vq_quantlist__44c9_s_p8_1[] = {
+ 10,
+ 9,
+ 11,
+ 8,
+ 12,
+ 7,
+ 13,
+ 6,
+ 14,
+ 5,
+ 15,
+ 4,
+ 16,
+ 3,
+ 17,
+ 2,
+ 18,
+ 1,
+ 19,
+ 0,
+ 20,
+};
+
+static const long _vq_lengthlist__44c9_s_p8_1[] = {
+ 4, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8,10, 6, 6, 7, 7, 8, 8, 8, 8, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,10, 6, 6, 7, 7, 8,
+ 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,10,
+ 7, 7, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9,10,10,10, 8, 8, 8, 8, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9,10,10,10, 8, 8, 8, 8,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,10,10,
+ 10, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9,10,10,10, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9,10,10,10,10,10, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,10,10,10,
+ 10,10, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9,10,10,10,10,10, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9,10,10,10,10,10, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9,10, 9, 9, 9,10,10,10,10,
+ 10,10,10, 9, 9, 9, 9, 9, 9,10, 9, 9, 9, 9, 9, 9,
+ 9,10,10,10,10,10,10,10, 9, 9, 9,10,10,10,10,10,
+ 9, 9, 9, 9, 9, 9,10,10,10,10,10,10,10, 9, 9,10,
+ 9,10, 9, 9, 9, 9, 9, 9, 9, 9,10,10,10,10,10,10,
+ 10,10,10,10, 9, 9,10,10, 9, 9, 9, 9, 9, 9, 9, 9,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10, 9, 9, 9,
+ 9, 9, 9, 9, 9,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10, 9, 9,10, 9, 9, 9, 9, 9,10,10,10,10,10,10,
+ 10,10,10,10,10, 9, 9,10,10, 9, 9,10, 9, 9, 9,10,
+ 10,10,10,10,10,10,10,10,10,10, 9, 9,10, 9, 9, 9,
+ 9, 9, 9, 9,10,10,10,10,10,10,10,10,10,10,10, 9,
+ 9, 9, 9,10, 9, 9, 9, 9, 9,
+};
+
+static const static_codebook _44c9_s_p8_1 = {
+ 2, 441,
+ (long *)_vq_lengthlist__44c9_s_p8_1,
+ 1, -529268736, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44c9_s_p8_1,
+ 0
+};
+
+static const long _vq_quantlist__44c9_s_p9_0[] = {
+ 9,
+ 8,
+ 10,
+ 7,
+ 11,
+ 6,
+ 12,
+ 5,
+ 13,
+ 4,
+ 14,
+ 3,
+ 15,
+ 2,
+ 16,
+ 1,
+ 17,
+ 0,
+ 18,
+};
+
+static const long _vq_lengthlist__44c9_s_p9_0[] = {
+ 1, 4, 3,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12, 4, 5, 6,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12, 4, 6, 6,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,11,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,
+};
+
+static const static_codebook _44c9_s_p9_0 = {
+ 2, 361,
+ (long *)_vq_lengthlist__44c9_s_p9_0,
+ 1, -508535424, 1631393792, 5, 0,
+ (long *)_vq_quantlist__44c9_s_p9_0,
+ 0
+};
+
+static const long _vq_quantlist__44c9_s_p9_1[] = {
+ 9,
+ 8,
+ 10,
+ 7,
+ 11,
+ 6,
+ 12,
+ 5,
+ 13,
+ 4,
+ 14,
+ 3,
+ 15,
+ 2,
+ 16,
+ 1,
+ 17,
+ 0,
+ 18,
+};
+
+static const long _vq_lengthlist__44c9_s_p9_1[] = {
+ 1, 4, 4, 7, 7, 7, 7, 8, 7, 9, 8, 9, 9,10,10,11,
+ 11,11,11, 6, 5, 5, 8, 8, 9, 9, 9, 8,10, 9,11,10,
+ 12,12,13,12,13,13, 5, 5, 5, 8, 8, 9, 9, 9, 9,10,
+ 10,11,11,12,12,13,12,13,13,17, 8, 8, 9, 9, 9, 9,
+ 9, 9,10,10,12,11,13,12,13,13,13,13,18, 8, 8, 9,
+ 9, 9, 9, 9, 9,11,11,12,12,13,13,13,13,13,13,17,
+ 13,12, 9, 9,10,10,10,10,11,11,12,12,12,13,13,13,
+ 14,14,18,13,12, 9, 9,10,10,10,10,11,11,12,12,13,
+ 13,13,14,14,14,17,18,18,10,10,10,10,11,11,11,12,
+ 12,12,14,13,14,13,13,14,18,18,18,10, 9,10, 9,11,
+ 11,12,12,12,12,13,13,15,14,14,14,18,18,16,13,14,
+ 10,11,11,11,12,13,13,13,13,14,13,13,14,14,18,18,
+ 18,14,12,11, 9,11,10,13,12,13,13,13,14,14,14,13,
+ 14,18,18,17,18,18,11,12,12,12,13,13,14,13,14,14,
+ 13,14,14,14,18,18,18,18,17,12,10,12, 9,13,11,13,
+ 14,14,14,14,14,15,14,18,18,17,17,18,14,15,12,13,
+ 13,13,14,13,14,14,15,14,15,14,18,17,18,18,18,15,
+ 15,12,10,14,10,14,14,13,13,14,14,14,14,18,16,18,
+ 18,18,18,17,14,14,13,14,14,13,13,14,14,14,15,15,
+ 18,18,18,18,17,17,17,14,14,14,12,14,13,14,14,15,
+ 14,15,14,18,18,18,18,18,18,18,17,16,13,13,13,14,
+ 14,14,14,15,16,15,18,18,18,18,18,18,18,17,17,13,
+ 13,13,13,14,13,14,15,15,15,
+};
+
+static const static_codebook _44c9_s_p9_1 = {
+ 2, 361,
+ (long *)_vq_lengthlist__44c9_s_p9_1,
+ 1, -518287360, 1622704128, 5, 0,
+ (long *)_vq_quantlist__44c9_s_p9_1,
+ 0
+};
+
+static const long _vq_quantlist__44c9_s_p9_2[] = {
+ 24,
+ 23,
+ 25,
+ 22,
+ 26,
+ 21,
+ 27,
+ 20,
+ 28,
+ 19,
+ 29,
+ 18,
+ 30,
+ 17,
+ 31,
+ 16,
+ 32,
+ 15,
+ 33,
+ 14,
+ 34,
+ 13,
+ 35,
+ 12,
+ 36,
+ 11,
+ 37,
+ 10,
+ 38,
+ 9,
+ 39,
+ 8,
+ 40,
+ 7,
+ 41,
+ 6,
+ 42,
+ 5,
+ 43,
+ 4,
+ 44,
+ 3,
+ 45,
+ 2,
+ 46,
+ 1,
+ 47,
+ 0,
+ 48,
+};
+
+static const long _vq_lengthlist__44c9_s_p9_2[] = {
+ 2, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7,
+};
+
+static const static_codebook _44c9_s_p9_2 = {
+ 1, 49,
+ (long *)_vq_lengthlist__44c9_s_p9_2,
+ 1, -526909440, 1611661312, 6, 0,
+ (long *)_vq_quantlist__44c9_s_p9_2,
+ 0
+};
+
+static const long _huff_lengthlist__44c9_s_short[] = {
+ 5,13,18,16,17,17,19,18,19,19, 5, 7,10,11,12,12,
+ 13,16,17,18, 6, 6, 7, 7, 9, 9,10,14,17,19, 8, 7,
+ 6, 5, 6, 7, 9,12,19,17, 8, 7, 7, 6, 5, 6, 8,11,
+ 15,19, 9, 8, 7, 6, 5, 5, 6, 8,13,15,11,10, 8, 8,
+ 7, 5, 4, 4,10,14,12,13,11, 9, 7, 6, 4, 2, 6,12,
+ 18,16,16,13, 8, 7, 7, 5, 8,13,16,17,18,15,11, 9,
+ 9, 8,10,13,
+};
+
+static const static_codebook _huff_book__44c9_s_short = {
+ 2, 100,
+ (long *)_huff_lengthlist__44c9_s_short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44c0_s_long[] = {
+ 5, 4, 8, 9, 8, 9,10,12,15, 4, 1, 5, 5, 6, 8,11,
+ 12,12, 8, 5, 8, 9, 9,11,13,12,12, 9, 5, 8, 5, 7,
+ 9,12,13,13, 8, 6, 8, 7, 7, 9,11,11,11, 9, 7, 9,
+ 7, 7, 7, 7,10,12,10,10,11, 9, 8, 7, 7, 9,11,11,
+ 12,13,12,11, 9, 8, 9,11,13,16,16,15,15,12,10,11,
+ 12,
+};
+
+static const static_codebook _huff_book__44c0_s_long = {
+ 2, 81,
+ (long *)_huff_lengthlist__44c0_s_long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44c0_s_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44c0_s_p1_0[] = {
+ 1, 5, 5, 0, 0, 0, 0, 0, 0, 5, 7, 7, 0, 0, 0, 0,
+ 0, 0, 5, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 5, 8, 7, 0, 0, 0, 0, 0, 0, 7, 9, 9, 0, 0, 0,
+ 0, 0, 0, 7, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 5, 7, 7, 0, 0, 0, 0, 0, 0, 7, 9, 9, 0, 0,
+ 0, 0, 0, 0, 7, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 7, 7, 0, 0, 0, 0,
+ 0, 0, 8,10, 9, 0, 0, 0, 0, 0, 0, 7, 9, 9, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 9, 9, 0, 0, 0,
+ 0, 0, 0, 9,10,11, 0, 0, 0, 0, 0, 0, 9,11,10, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 9, 9, 0, 0,
+ 0, 0, 0, 0, 9,11, 9, 0, 0, 0, 0, 0, 0, 9,10,11,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 5, 7, 7, 0, 0, 0, 0, 0, 0, 7, 9, 9, 0, 0,
+ 0, 0, 0, 0, 8, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 7, 9, 9, 0, 0, 0, 0, 0, 0, 9,11,10, 0,
+ 0, 0, 0, 0, 0, 9, 9,11, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 7, 9,10, 0, 0, 0, 0, 0, 0, 9,10,11,
+ 0, 0, 0, 0, 0, 0, 9,11,10, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c0_s_p1_0 = {
+ 8, 6561,
+ (long *)_vq_lengthlist__44c0_s_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44c0_s_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44c0_s_p2_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44c0_s_p2_0[] = {
+ 1, 4, 4, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 5, 5, 7, 6, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 4, 5, 6, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 7, 7, 9, 9,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 6, 7, 7, 9, 9, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c0_s_p2_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44c0_s_p2_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44c0_s_p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44c0_s_p3_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44c0_s_p3_0[] = {
+ 1, 3, 2, 8, 7, 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0,
+ 0, 0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0, 0, 7, 7,
+ 0, 0, 0, 0, 0, 0, 0, 7, 7, 0, 0, 0, 0, 0, 0, 0,
+ 8, 8, 0, 0, 0, 0, 0, 0, 0, 8, 8, 0, 0, 0, 0, 0,
+ 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c0_s_p3_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44c0_s_p3_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c0_s_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44c0_s_p4_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44c0_s_p4_0[] = {
+ 1, 3, 3, 6, 6, 6, 6, 8, 8, 0, 0, 0, 7, 7, 7, 7,
+ 9, 9, 0, 0, 0, 7, 7, 7, 7, 9, 9, 0, 0, 0, 7, 7,
+ 7, 8, 9, 9, 0, 0, 0, 7, 7, 7, 7, 9, 9, 0, 0, 0,
+ 9, 9, 8, 8,10,10, 0, 0, 0, 8, 9, 8, 8,10,10, 0,
+ 0, 0,10,10, 9, 9,10,10, 0, 0, 0, 0, 0, 9, 9,10,
+ 10,
+};
+
+static const static_codebook _44c0_s_p4_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44c0_s_p4_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c0_s_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44c0_s_p5_0[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44c0_s_p5_0[] = {
+ 1, 4, 3, 6, 6, 8, 7, 8, 8, 8, 8, 9, 9,10,10,11,
+ 11, 0, 0, 0, 7, 7, 8, 8, 9, 9, 9, 9, 9,10,10,10,
+ 11,11, 0, 0, 0, 7, 7, 8, 8, 9, 9, 9, 9,10,10,10,
+ 10,11,11, 0, 0, 0, 7, 7, 8, 8, 9, 9, 9, 9,10,10,
+ 11,11,11,11, 0, 0, 0, 7, 7, 8, 8, 9, 9, 9, 9,10,
+ 10,11,11,11,11, 0, 0, 0, 8, 8, 9, 9, 9, 9,10,10,
+ 10,10,11,11,12,12, 0, 0, 0, 8, 8, 9, 9, 9, 9,10,
+ 10,10,10,11,11,12,12, 0, 0, 0, 9, 9, 9, 9,10,10,
+ 10,10,11,11,11,12,12,12, 0, 0, 0, 0, 0, 9, 9,10,
+ 10,10,10,11,11,11,11,12,12, 0, 0, 0, 0, 0, 9, 9,
+ 10,10,10,10,11,11,12,12,13,13, 0, 0, 0, 0, 0, 9,
+ 9,10,10,10,10,11,11,12,12,13,13, 0, 0, 0, 0, 0,
+ 10,10,11,11,11,11,11,12,12,12,13,13, 0, 0, 0, 0,
+ 0, 0, 0,11,10,11,11,11,11,12,12,13,13, 0, 0, 0,
+ 0, 0, 0, 0,11,11,12,11,12,12,12,12,13,13, 0, 0,
+ 0, 0, 0, 0, 0,11,11,11,12,12,12,12,13,13,13, 0,
+ 0, 0, 0, 0, 0, 0,12,12,12,12,12,13,13,13,14,14,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,12,12,12,12,13,13,14,
+ 14,
+};
+
+static const static_codebook _44c0_s_p5_0 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44c0_s_p5_0,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44c0_s_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44c0_s_p6_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44c0_s_p6_0[] = {
+ 1, 4, 4, 7, 6, 6, 7, 6, 6, 4, 7, 7,10, 9, 9,10,
+ 9, 9, 4, 6, 7,10, 9, 9,11, 9, 9, 7,10,10,11,11,
+ 11,12,10,11, 6, 9, 9,11,10,11,11,10,10, 6, 9, 9,
+ 11,10,11,11,10,10, 7,11,10,12,11,11,11,11,11, 7,
+ 9, 9,10,10,10,11,11,10, 6, 9, 9,11,10,10,11,10,
+ 10,
+};
+
+static const static_codebook _44c0_s_p6_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44c0_s_p6_0,
+ 1, -529137664, 1618345984, 2, 0,
+ (long *)_vq_quantlist__44c0_s_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44c0_s_p6_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44c0_s_p6_1[] = {
+ 2, 3, 3, 6, 6, 7, 7, 7, 7, 7, 8,10,10,10, 6, 6,
+ 7, 7, 8, 8, 8, 8,10,10,10, 6, 6, 7, 7, 8, 8, 8,
+ 8,10,10,10, 7, 7, 7, 7, 8, 8, 8, 8,10,10,10, 7,
+ 7, 7, 7, 8, 8, 8, 8,10,10,10, 8, 7, 8, 8, 8, 8,
+ 8, 8,10,10,10, 7, 7, 8, 8, 8, 8, 8, 8,10,10,10,
+ 8, 8, 8, 8, 8, 8, 8, 8,10,10,10,10,10, 8, 8, 8,
+ 8, 8, 8,10,10,10,10,10, 9, 9, 8, 8, 8, 8,10,10,
+ 10,10,10, 8, 8, 8, 8, 8, 8,
+};
+
+static const static_codebook _44c0_s_p6_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44c0_s_p6_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c0_s_p6_1,
+ 0
+};
+
+static const long _vq_quantlist__44c0_s_p7_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c0_s_p7_0[] = {
+ 1, 4, 4, 6, 6, 7, 7, 7, 7, 8, 8, 9, 9, 7, 5, 5,
+ 7, 7, 8, 8, 8, 8, 9, 9,10,10, 7, 5, 6, 7, 7, 8,
+ 8, 8, 8, 9, 9,10,10, 0, 8, 8, 8, 8, 9, 9, 9, 9,
+ 10,10,11,11, 0, 8, 8, 8, 8, 9, 9, 9, 9,10,10,11,
+ 11, 0,12,12, 9, 9,10,10,10,10,11,11,11,11, 0,13,
+ 13, 9, 9, 9, 9,10,10,11,11,11,12, 0, 0, 0,10,10,
+ 10,10,11,11,11,11,12,12, 0, 0, 0,10,10, 9, 9,11,
+ 11,11,12,12,12, 0, 0, 0,13,13,10,10,11,11,12,12,
+ 13,13, 0, 0, 0,14,14,10,10,11,11,12,12,13,13, 0,
+ 0, 0, 0, 0,11,11,11,11,13,12,13,13, 0, 0, 0, 0,
+ 0,12,12,11,11,12,12,13,13,
+};
+
+static const static_codebook _44c0_s_p7_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c0_s_p7_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44c0_s_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44c0_s_p7_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44c0_s_p7_1[] = {
+ 2, 3, 3, 5, 5, 6, 6, 6, 5, 5, 6, 6, 6, 5, 5, 6,
+ 6, 6, 5, 5, 6, 6, 6, 5, 5,
+};
+
+static const static_codebook _44c0_s_p7_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44c0_s_p7_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44c0_s_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44c0_s_p8_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44c0_s_p8_0[] = {
+ 1, 5, 5,10,10, 6, 9, 8,10,10, 6,10, 9,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10, 8,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,10,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,
+};
+
+static const static_codebook _44c0_s_p8_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44c0_s_p8_0,
+ 1, -518283264, 1627103232, 3, 0,
+ (long *)_vq_quantlist__44c0_s_p8_0,
+ 0
+};
+
+static const long _vq_quantlist__44c0_s_p8_1[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c0_s_p8_1[] = {
+ 1, 4, 4, 6, 6, 7, 7, 9, 9,11,12,13,12, 6, 5, 5,
+ 7, 7, 8, 8,10, 9,12,12,12,12, 6, 5, 5, 7, 7, 8,
+ 8,10, 9,12,11,11,13,16, 7, 7, 8, 8, 9, 9,10,10,
+ 12,12,13,12,16, 7, 7, 8, 7, 9, 9,10,10,11,12,12,
+ 13,16,10,10, 8, 8,10,10,11,12,12,12,13,13,16,11,
+ 10, 8, 7,11,10,11,11,12,11,13,13,16,16,16,10,10,
+ 10,10,11,11,13,12,13,13,16,16,16,11, 9,11, 9,15,
+ 13,12,13,13,13,16,16,16,15,13,11,11,12,13,12,12,
+ 14,13,16,16,16,14,13,11,11,13,12,14,13,13,13,16,
+ 16,16,16,16,13,13,13,12,14,13,14,14,16,16,16,16,
+ 16,13,13,12,12,14,14,15,13,
+};
+
+static const static_codebook _44c0_s_p8_1 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c0_s_p8_1,
+ 1, -522616832, 1620115456, 4, 0,
+ (long *)_vq_quantlist__44c0_s_p8_1,
+ 0
+};
+
+static const long _vq_quantlist__44c0_s_p8_2[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44c0_s_p8_2[] = {
+ 2, 4, 4, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8,
+ 8,10,10,10, 7, 7, 7, 8, 8, 8, 9, 9, 9, 9, 9, 9,
+ 9, 9,10,10,10, 7, 7, 7, 7, 8, 8, 9, 9, 9, 9, 9,
+ 9, 9, 9,10,10,10, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9,
+ 9,10, 9, 9,10,10,10, 7, 7, 8, 8, 9, 8, 9, 9, 9,
+ 9,10, 9, 9,10,10,10,10, 8, 8, 8, 8, 9, 8, 9, 9,
+ 9, 9, 9,10, 9,10,10,10,10, 7, 7, 8, 8, 9, 9, 9,
+ 9, 9, 9,10, 9,10,10,10,10,10, 8, 8, 8, 9, 9, 9,
+ 9, 9, 9, 9,10,10,10, 9,11,10,10,10,10, 8, 8, 9,
+ 9, 9, 9, 9,10, 9, 9, 9,10,10,10,10,11,11, 9, 9,
+ 9, 9, 9, 9, 9, 9,10, 9, 9,10,11,10,10,11,11, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9,10, 9,11,11,10,11,11,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,10, 9,11,10,10,11,
+ 11,11,11, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,10,10,10,
+ 11,11,11,11, 9,10, 9,10, 9, 9, 9, 9,10, 9,10,11,
+ 10,11,10,10,10,10,10, 9, 9, 9,10, 9, 9, 9,10,11,
+ 11,10,11,11,10,11,10,10,10, 9, 9, 9, 9,10, 9, 9,
+ 10,11,10,11,11,11,11,10,11,10,10, 9,10, 9, 9, 9,
+ 10,
+};
+
+static const static_codebook _44c0_s_p8_2 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44c0_s_p8_2,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44c0_s_p8_2,
+ 0
+};
+
+static const long _huff_lengthlist__44c0_s_short[] = {
+ 9, 8,12,11,12,13,14,14,16, 6, 1, 5, 6, 6, 9,12,
+ 14,17, 9, 4, 5, 9, 7, 9,13,15,16, 8, 5, 8, 6, 8,
+ 10,13,17,17, 9, 6, 7, 7, 8, 9,13,15,17,11, 8, 9,
+ 9, 9,10,12,16,16,13, 7, 8, 7, 7, 9,12,14,15,13,
+ 6, 7, 5, 5, 7,10,13,13,14, 7, 8, 5, 6, 7, 9,10,
+ 12,
+};
+
+static const static_codebook _huff_book__44c0_s_short = {
+ 2, 81,
+ (long *)_huff_lengthlist__44c0_s_short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44c0_sm_long[] = {
+ 5, 4, 9,10, 9,10,11,12,13, 4, 1, 5, 7, 7, 9,11,
+ 12,14, 8, 5, 7, 9, 8,10,13,13,13,10, 7, 9, 4, 6,
+ 7,10,12,14, 9, 6, 7, 6, 6, 7,10,12,12, 9, 8, 9,
+ 7, 6, 7, 8,11,12,11,11,11, 9, 8, 7, 8,10,12,12,
+ 13,14,12,11, 9, 9, 9,12,12,17,17,15,16,12,10,11,
+ 13,
+};
+
+static const static_codebook _huff_book__44c0_sm_long = {
+ 2, 81,
+ (long *)_huff_lengthlist__44c0_sm_long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44c0_sm_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44c0_sm_p1_0[] = {
+ 1, 5, 5, 0, 0, 0, 0, 0, 0, 5, 7, 7, 0, 0, 0, 0,
+ 0, 0, 5, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 5, 8, 7, 0, 0, 0, 0, 0, 0, 7, 9, 9, 0, 0, 0,
+ 0, 0, 0, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 5, 7, 7, 0, 0, 0, 0, 0, 0, 7, 9, 8, 0, 0,
+ 0, 0, 0, 0, 7, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 8, 7, 0, 0, 0, 0,
+ 0, 0, 8, 9, 9, 0, 0, 0, 0, 0, 0, 8, 9, 9, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 9, 9, 0, 0, 0,
+ 0, 0, 0, 9,10,10, 0, 0, 0, 0, 0, 0, 9,10,10, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 9, 9, 0, 0,
+ 0, 0, 0, 0, 8,10, 9, 0, 0, 0, 0, 0, 0, 9,10,10,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 5, 7, 8, 0, 0, 0, 0, 0, 0, 7, 9, 9, 0, 0,
+ 0, 0, 0, 0, 8, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 7, 9, 9, 0, 0, 0, 0, 0, 0, 9,10,10, 0,
+ 0, 0, 0, 0, 0, 9, 9,10, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 7, 9, 9, 0, 0, 0, 0, 0, 0, 9,10,10,
+ 0, 0, 0, 0, 0, 0, 9,10,10, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c0_sm_p1_0 = {
+ 8, 6561,
+ (long *)_vq_lengthlist__44c0_sm_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44c0_sm_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44c0_sm_p2_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44c0_sm_p2_0[] = {
+ 1, 4, 4, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 5, 5, 7, 7, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 4, 5, 5, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 7, 7, 9, 9,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 7, 7, 7, 9, 9, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c0_sm_p2_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44c0_sm_p2_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44c0_sm_p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44c0_sm_p3_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44c0_sm_p3_0[] = {
+ 1, 3, 3, 7, 7, 0, 0, 0, 0, 0, 5, 4, 7, 7, 0, 0,
+ 0, 0, 0, 5, 5, 7, 7, 0, 0, 0, 0, 0, 6, 7, 8, 8,
+ 0, 0, 0, 0, 0, 0, 0, 8, 8, 0, 0, 0, 0, 0, 0, 0,
+ 9,10, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0,
+ 0, 0,11,11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c0_sm_p3_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44c0_sm_p3_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c0_sm_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44c0_sm_p4_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44c0_sm_p4_0[] = {
+ 1, 4, 3, 6, 6, 7, 7, 9, 9, 0, 5, 5, 7, 7, 8, 7,
+ 9, 9, 0, 5, 5, 7, 7, 8, 8, 9, 9, 0, 7, 7, 8, 8,
+ 8, 8,10,10, 0, 0, 0, 8, 8, 8, 8,10,10, 0, 0, 0,
+ 9, 9, 9, 9,11,11, 0, 0, 0, 9, 9, 9, 9,11,11, 0,
+ 0, 0,10,10,10,10,11,11, 0, 0, 0, 0, 0, 9, 9,11,
+ 11,
+};
+
+static const static_codebook _44c0_sm_p4_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44c0_sm_p4_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c0_sm_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44c0_sm_p5_0[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44c0_sm_p5_0[] = {
+ 1, 4, 4, 6, 6, 8, 8, 8, 8, 8, 8, 9, 9,10,10,11,
+ 11, 0, 6, 6, 7, 7, 8, 8, 9, 9, 9, 9,10,10,10,11,
+ 11,11, 0, 5, 6, 7, 7, 8, 8, 9, 9, 9, 9,10,10,10,
+ 11,11,11, 0, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9,10,10,
+ 11,11,12,12, 0, 0, 0, 8, 8, 8, 8, 9, 9, 9, 9,10,
+ 10,11,11,12,12, 0, 0, 0, 8, 8, 9, 9,10,10,10,10,
+ 11,11,11,11,12,12, 0, 0, 0, 8, 8, 9, 9,10,10,10,
+ 10,11,11,11,11,12,12, 0, 0, 0, 9, 9, 9, 9,10,10,
+ 10,10,11,11,12,12,12,13, 0, 0, 0, 0, 0, 9, 9,10,
+ 10,10,10,11,11,12,12,13,13, 0, 0, 0, 0, 0, 9, 9,
+ 10,10,11,11,11,11,12,12,13,13, 0, 0, 0, 0, 0, 9,
+ 9,10,10,11,10,11,11,12,12,13,13, 0, 0, 0, 0, 0,
+ 10,10,10,10,11,11,12,12,12,13,13,13, 0, 0, 0, 0,
+ 0, 0, 0,10,10,11,11,12,12,12,13,13,13, 0, 0, 0,
+ 0, 0, 0, 0,11,11,12,12,12,12,13,13,14,14, 0, 0,
+ 0, 0, 0, 0, 0,11,11,12,11,12,12,13,13,13,13, 0,
+ 0, 0, 0, 0, 0, 0,12,12,12,12,13,13,13,13,14,14,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,12,12,12,12,13,13,14,
+ 14,
+};
+
+static const static_codebook _44c0_sm_p5_0 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44c0_sm_p5_0,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44c0_sm_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44c0_sm_p6_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44c0_sm_p6_0[] = {
+ 1, 4, 4, 7, 6, 6, 7, 6, 6, 4, 7, 7,10, 9, 9,11,
+ 9, 9, 4, 7, 7,10, 9, 9,11, 9, 9, 7,10,10,10,11,
+ 11,11,10,10, 6, 9, 9,11,11,10,11,10,10, 6, 9, 9,
+ 11,10,11,11,10,10, 7,11,10,11,11,11,11,11,11, 6,
+ 9, 9,11,10,10,11,11,10, 6, 9, 9,11,10,10,11,10,
+ 11,
+};
+
+static const static_codebook _44c0_sm_p6_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44c0_sm_p6_0,
+ 1, -529137664, 1618345984, 2, 0,
+ (long *)_vq_quantlist__44c0_sm_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44c0_sm_p6_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44c0_sm_p6_1[] = {
+ 2, 4, 4, 6, 6, 7, 7, 7, 7, 7, 8, 9, 5, 5, 6, 6,
+ 7, 7, 8, 8, 8, 8, 9, 5, 5, 6, 6, 7, 7, 8, 8, 8,
+ 8,10, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8,10,10,10, 7,
+ 7, 7, 7, 8, 8, 8, 8,10,10,10, 8, 8, 8, 8, 8, 8,
+ 8, 8,10,10,10, 8, 8, 8, 8, 8, 8, 8, 8,10,10,10,
+ 8, 8, 8, 8, 8, 8, 8, 8,10,10,10,10,10, 8, 8, 8,
+ 8, 8, 8,10,10,10,10,10, 9, 9, 8, 8, 8, 8,10,10,
+ 10,10,10, 8, 8, 8, 8, 8, 8,
+};
+
+static const static_codebook _44c0_sm_p6_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44c0_sm_p6_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c0_sm_p6_1,
+ 0
+};
+
+static const long _vq_quantlist__44c0_sm_p7_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c0_sm_p7_0[] = {
+ 1, 4, 4, 6, 6, 7, 7, 7, 7, 8, 8, 9, 9, 7, 5, 5,
+ 7, 7, 8, 8, 8, 8, 9, 9,10,10, 7, 6, 5, 7, 7, 8,
+ 8, 8, 8, 9, 9,10,10, 0, 8, 8, 8, 8, 9, 9, 9, 9,
+ 10,10,11,11, 0, 8, 8, 8, 8, 9, 9, 9, 9,10,10,11,
+ 11, 0,12,12, 9, 9,10,10,10,10,11,11,11,11, 0,13,
+ 13, 9, 9, 9, 9,10,10,11,11,11,12, 0, 0, 0, 9,10,
+ 10,10,11,11,12,11,12,12, 0, 0, 0,10,10, 9, 9,11,
+ 11,12,12,12,12, 0, 0, 0,13,13,10,10,11,11,12,12,
+ 13,13, 0, 0, 0,14,14,10,10,11,11,12,12,13,13, 0,
+ 0, 0, 0, 0,11,12,11,11,13,12,13,13, 0, 0, 0, 0,
+ 0,12,12,11,11,13,12,14,14,
+};
+
+static const static_codebook _44c0_sm_p7_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c0_sm_p7_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44c0_sm_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44c0_sm_p7_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44c0_sm_p7_1[] = {
+ 2, 4, 4, 4, 4, 6, 5, 5, 5, 5, 6, 5, 5, 5, 5, 6,
+ 6, 6, 5, 5, 6, 6, 6, 5, 5,
+};
+
+static const static_codebook _44c0_sm_p7_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44c0_sm_p7_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44c0_sm_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44c0_sm_p8_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44c0_sm_p8_0[] = {
+ 1, 3, 3,11,11,11,11,11,11, 3, 7, 6,11,11,11,11,
+ 11,11, 4, 8, 7,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,
+};
+
+static const static_codebook _44c0_sm_p8_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44c0_sm_p8_0,
+ 1, -516186112, 1627103232, 4, 0,
+ (long *)_vq_quantlist__44c0_sm_p8_0,
+ 0
+};
+
+static const long _vq_quantlist__44c0_sm_p8_1[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c0_sm_p8_1[] = {
+ 1, 4, 4, 6, 6, 7, 7, 9, 9,10,11,12,12, 6, 5, 5,
+ 7, 7, 8, 8,10,10,12,11,12,12, 6, 5, 5, 7, 7, 8,
+ 8,10,10,12,11,12,12,17, 7, 7, 8, 8, 9, 9,10,10,
+ 12,12,13,13,18, 7, 7, 8, 7, 9, 9,10,10,12,12,12,
+ 13,19,10,10, 8, 8,10,10,11,11,12,12,13,14,19,11,
+ 10, 8, 7,10,10,11,11,12,12,13,12,19,19,19,10,10,
+ 10,10,11,11,12,12,13,13,19,19,19,11, 9,11, 9,14,
+ 12,13,12,13,13,19,20,18,13,14,11,11,12,12,13,13,
+ 14,13,20,20,20,15,13,11,10,13,11,13,13,14,13,20,
+ 20,20,20,20,13,14,12,12,13,13,13,13,20,20,20,20,
+ 20,13,13,12,12,16,13,15,13,
+};
+
+static const static_codebook _44c0_sm_p8_1 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c0_sm_p8_1,
+ 1, -522616832, 1620115456, 4, 0,
+ (long *)_vq_quantlist__44c0_sm_p8_1,
+ 0
+};
+
+static const long _vq_quantlist__44c0_sm_p8_2[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44c0_sm_p8_2[] = {
+ 2, 5, 5, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8,
+ 8,10, 6, 6, 7, 7, 7, 7, 8, 8, 9, 9, 9, 9, 9, 9,
+ 9, 9,10, 6, 6, 7, 7, 8, 7, 8, 8, 9, 9, 9, 9, 9,
+ 9, 9, 9,10, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9,10,10,10, 7, 7, 8, 8, 9, 8, 9, 9, 9,
+ 9,10, 9, 9,10,10,10,11, 8, 8, 8, 8, 9, 9, 9, 9,
+ 9, 9, 9,10, 9,10,10,10,10, 8, 8, 8, 8, 9, 9, 9,
+ 9, 9, 9, 9, 9,10,10,11,10,10, 8, 8, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9,10,10,10,10,10,11,11, 8, 8, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9,10,11,11,11,11,11, 9, 9,
+ 9, 9, 9, 9, 9, 9,10, 9,10, 9,11,11,10,11,11, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9,10, 9,11,11,10,11,11,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,10, 9,11,10,11,11,
+ 11,11,11, 9, 9,10, 9, 9, 9, 9, 9, 9, 9,10,11,10,
+ 11,11,11,11,10,10,10,10, 9, 9, 9, 9, 9, 9,10,11,
+ 11,11,11,11,11, 9,10, 9, 9, 9, 9, 9, 9, 9, 9,11,
+ 11,10,11,11,11,10,10,10, 9, 9, 9, 9, 9, 9, 9, 9,
+ 10,11,10,11,11,11,11,11,11, 9, 9, 9, 9, 9, 9, 9,
+ 9,
+};
+
+static const static_codebook _44c0_sm_p8_2 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44c0_sm_p8_2,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44c0_sm_p8_2,
+ 0
+};
+
+static const long _huff_lengthlist__44c0_sm_short[] = {
+ 6, 6,12,13,13,14,16,17,17, 4, 2, 5, 8, 7, 9,12,
+ 15,15, 9, 4, 5, 9, 7, 9,12,16,18,11, 6, 7, 4, 6,
+ 8,11,14,18,10, 5, 6, 5, 5, 7,10,14,17,10, 5, 7,
+ 7, 6, 7,10,13,16,11, 5, 7, 7, 7, 8,10,12,15,13,
+ 6, 7, 5, 5, 7, 9,12,13,16, 8, 9, 6, 6, 7, 9,10,
+ 12,
+};
+
+static const static_codebook _huff_book__44c0_sm_short = {
+ 2, 81,
+ (long *)_huff_lengthlist__44c0_sm_short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44c1_s_long[] = {
+ 5, 5, 9,10, 9, 9,10,11,12, 5, 1, 5, 6, 6, 7,10,
+ 12,14, 9, 5, 6, 8, 8,10,12,14,14,10, 5, 8, 5, 6,
+ 8,11,13,14, 9, 5, 7, 6, 6, 8,10,12,11, 9, 7, 9,
+ 7, 6, 6, 7,10,10,10, 9,12, 9, 8, 7, 7,10,12,11,
+ 11,13,12,10, 9, 8, 9,11,11,14,15,15,13,11, 9, 9,
+ 11,
+};
+
+static const static_codebook _huff_book__44c1_s_long = {
+ 2, 81,
+ (long *)_huff_lengthlist__44c1_s_long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44c1_s_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44c1_s_p1_0[] = {
+ 2, 4, 4, 0, 0, 0, 0, 0, 0, 5, 7, 6, 0, 0, 0, 0,
+ 0, 0, 5, 6, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 5, 7, 7, 0, 0, 0, 0, 0, 0, 7, 8, 8, 0, 0, 0,
+ 0, 0, 0, 7, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 5, 7, 7, 0, 0, 0, 0, 0, 0, 7, 8, 8, 0, 0,
+ 0, 0, 0, 0, 7, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 7, 7, 0, 0, 0, 0,
+ 0, 0, 7, 8, 8, 0, 0, 0, 0, 0, 0, 7, 8, 8, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 8, 0, 0, 0,
+ 0, 0, 0, 8, 9,10, 0, 0, 0, 0, 0, 0, 8, 9, 9, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 8, 8, 0, 0,
+ 0, 0, 0, 0, 8, 9, 8, 0, 0, 0, 0, 0, 0, 8, 9, 9,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 4, 7, 7, 0, 0, 0, 0, 0, 0, 7, 8, 8, 0, 0,
+ 0, 0, 0, 0, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 6, 8, 8, 0, 0, 0, 0, 0, 0, 8,10, 9, 0,
+ 0, 0, 0, 0, 0, 8, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 7, 8, 8, 0, 0, 0, 0, 0, 0, 8, 9, 9,
+ 0, 0, 0, 0, 0, 0, 8, 9, 9, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c1_s_p1_0 = {
+ 8, 6561,
+ (long *)_vq_lengthlist__44c1_s_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44c1_s_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44c1_s_p2_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44c1_s_p2_0[] = {
+ 2, 3, 4, 6, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 6, 6, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 4, 4, 5, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 8, 8,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 6, 6, 6, 8, 8, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c1_s_p2_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44c1_s_p2_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44c1_s_p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44c1_s_p3_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44c1_s_p3_0[] = {
+ 1, 3, 2, 7, 7, 0, 0, 0, 0, 0,13,13, 6, 6, 0, 0,
+ 0, 0, 0,12, 0, 6, 6, 0, 0, 0, 0, 0, 0, 0, 7, 7,
+ 0, 0, 0, 0, 0, 0, 0, 7, 7, 0, 0, 0, 0, 0, 0, 0,
+ 8, 9, 0, 0, 0, 0, 0, 0, 0, 8, 8, 0, 0, 0, 0, 0,
+ 0, 0,11,10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c1_s_p3_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44c1_s_p3_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c1_s_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44c1_s_p4_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44c1_s_p4_0[] = {
+ 1, 3, 3, 6, 5, 6, 6, 8, 8, 0, 0, 0, 7, 7, 7, 7,
+ 9, 9, 0, 0, 0, 7, 7, 7, 7, 9, 9, 0, 0, 0, 7, 7,
+ 8, 8,10,10, 0, 0, 0, 7, 7, 8, 8,10,10, 0, 0, 0,
+ 9, 9, 8, 8,10,10, 0, 0, 0, 8, 8, 8, 8,10,10, 0,
+ 0, 0,10,10, 9, 9,11,11, 0, 0, 0, 0, 0, 9, 9,11,
+ 11,
+};
+
+static const static_codebook _44c1_s_p4_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44c1_s_p4_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c1_s_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44c1_s_p5_0[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44c1_s_p5_0[] = {
+ 1, 4, 3, 6, 6, 7, 7, 8, 8, 8, 8, 9, 9,10,10,11,
+ 11, 0, 0, 0, 7, 7, 8, 8, 9, 9, 9, 9,10,10,10,10,
+ 11,11, 0, 0, 0, 7, 7, 8, 8, 9, 9, 9, 9,10,10,10,
+ 10,11,11, 0, 0, 0, 7, 7, 8, 8, 9, 9, 9, 9,10,10,
+ 11,11,11,11, 0, 0, 0, 7, 7, 8, 8, 9, 9, 9, 9,10,
+ 10,11,11,12,11, 0, 0, 0, 8, 8, 9, 9, 9,10,10,10,
+ 10,10,11,11,12,12, 0, 0, 0, 8, 8, 9, 9,10, 9,10,
+ 10,10,10,11,11,12,12, 0, 0, 0, 9, 9, 9, 9,10,10,
+ 10,10,11,11,12,12,12,12, 0, 0, 0, 0, 0, 9, 9,10,
+ 10,10,10,11,11,12,12,12,12, 0, 0, 0, 0, 0, 9, 9,
+ 10,10,10,11,11,11,12,12,13,13, 0, 0, 0, 0, 0, 9,
+ 9,10,10,10,10,11,11,12,12,13,13, 0, 0, 0, 0, 0,
+ 10,10,10,10,11,11,12,12,12,12,13,13, 0, 0, 0, 0,
+ 0, 0, 0,10,10,11,11,12,12,12,12,13,13, 0, 0, 0,
+ 0, 0, 0, 0,11,11,12,12,12,12,13,13,13,13, 0, 0,
+ 0, 0, 0, 0, 0,11,11,11,11,12,12,13,13,13,13, 0,
+ 0, 0, 0, 0, 0, 0,12,12,12,12,12,12,13,13,14,14,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,12,12,12,12,13,13,14,
+ 14,
+};
+
+static const static_codebook _44c1_s_p5_0 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44c1_s_p5_0,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44c1_s_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44c1_s_p6_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44c1_s_p6_0[] = {
+ 1, 4, 4, 7, 6, 6, 7, 6, 6, 4, 7, 7,10, 9, 9,11,
+ 9, 9, 4, 7, 7,10, 9, 9,11, 9, 9, 6,10,10,11,11,
+ 11,11,10,10, 6, 9, 9,11,10,10,11,10,10, 6, 9, 9,
+ 11,10,11,11,10,10, 7,11,10,11,11,11,12,11,11, 7,
+ 9, 9,11,10,10,11,11,10, 6, 9, 9,10,10,10,12,10,
+ 11,
+};
+
+static const static_codebook _44c1_s_p6_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44c1_s_p6_0,
+ 1, -529137664, 1618345984, 2, 0,
+ (long *)_vq_quantlist__44c1_s_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44c1_s_p6_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44c1_s_p6_1[] = {
+ 2, 3, 3, 6, 6, 7, 7, 7, 7, 8, 8,10,10,10, 6, 6,
+ 7, 7, 8, 8, 8, 8,10,10,10, 6, 6, 7, 7, 8, 8, 8,
+ 8,10,10,10, 7, 7, 7, 7, 8, 8, 8, 8,10,10,10, 7,
+ 7, 7, 7, 8, 8, 8, 8,10,10,10, 7, 7, 8, 8, 8, 8,
+ 8, 8,10,10,10, 7, 7, 8, 8, 8, 8, 8, 8,10,10,10,
+ 8, 8, 8, 8, 8, 8, 8, 8,10,10,10,10,10, 8, 8, 8,
+ 8, 8, 8,10,10,10,10,10, 9, 9, 8, 8, 8, 8,10,10,
+ 10,10,10, 8, 8, 8, 8, 8, 8,
+};
+
+static const static_codebook _44c1_s_p6_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44c1_s_p6_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c1_s_p6_1,
+ 0
+};
+
+static const long _vq_quantlist__44c1_s_p7_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c1_s_p7_0[] = {
+ 1, 4, 4, 6, 6, 7, 7, 7, 7, 8, 8,10, 9, 7, 5, 6,
+ 7, 7, 8, 8, 8, 8, 9, 9,10,10, 7, 5, 5, 7, 7, 8,
+ 8, 8, 8, 9, 9,10,10, 0, 8, 8, 8, 8, 9, 9, 9, 9,
+ 10,10,11,10, 0, 8, 8, 8, 8, 9, 9, 9, 9,10,10,11,
+ 11, 0,12,12, 9, 9, 9,10,10,10,11,11,11,11, 0,13,
+ 13, 9, 9, 9, 9,10,10,11,11,11,11, 0, 0, 0,10,10,
+ 10,10,11,11,12,11,12,12, 0, 0, 0,10,10,10, 9,11,
+ 11,12,11,13,12, 0, 0, 0,13,13,10,10,11,11,12,12,
+ 13,13, 0, 0, 0,14,14,10,10,11,11,12,12,13,13, 0,
+ 0, 0, 0, 0,11,12,11,11,12,12,14,13, 0, 0, 0, 0,
+ 0,12,11,11,11,13,10,14,13,
+};
+
+static const static_codebook _44c1_s_p7_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c1_s_p7_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44c1_s_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44c1_s_p7_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44c1_s_p7_1[] = {
+ 2, 3, 3, 5, 5, 6, 6, 6, 5, 5, 6, 6, 6, 5, 5, 6,
+ 6, 6, 5, 5, 6, 6, 6, 5, 5,
+};
+
+static const static_codebook _44c1_s_p7_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44c1_s_p7_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44c1_s_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44c1_s_p8_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c1_s_p8_0[] = {
+ 1, 4, 3,10,10,10,10,10,10,10,10,10,10, 4, 8, 6,
+ 10,10,10,10,10,10,10,10,10,10, 4, 8, 7,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,
+};
+
+static const static_codebook _44c1_s_p8_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c1_s_p8_0,
+ 1, -514541568, 1627103232, 4, 0,
+ (long *)_vq_quantlist__44c1_s_p8_0,
+ 0
+};
+
+static const long _vq_quantlist__44c1_s_p8_1[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c1_s_p8_1[] = {
+ 1, 4, 4, 6, 5, 7, 7, 9, 9,10,10,12,12, 6, 5, 5,
+ 7, 7, 8, 8,10,10,12,11,12,12, 6, 5, 5, 7, 7, 8,
+ 8,10,10,11,11,12,12,15, 7, 7, 8, 8, 9, 9,11,11,
+ 12,12,13,12,15, 8, 8, 8, 7, 9, 9,10,10,12,12,13,
+ 13,16,11,10, 8, 8,10,10,11,11,12,12,13,13,16,11,
+ 11, 9, 8,11,10,11,11,12,12,13,12,16,16,16,10,11,
+ 10,11,12,12,12,12,13,13,16,16,16,11, 9,11, 9,14,
+ 12,12,12,13,13,16,16,16,12,14,11,12,12,12,13,13,
+ 14,13,16,16,16,15,13,12,10,13,10,13,14,13,13,16,
+ 16,16,16,16,13,14,12,13,13,12,13,13,16,16,16,16,
+ 16,13,12,12,11,14,12,15,13,
+};
+
+static const static_codebook _44c1_s_p8_1 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c1_s_p8_1,
+ 1, -522616832, 1620115456, 4, 0,
+ (long *)_vq_quantlist__44c1_s_p8_1,
+ 0
+};
+
+static const long _vq_quantlist__44c1_s_p8_2[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44c1_s_p8_2[] = {
+ 2, 4, 4, 6, 6, 6, 6, 7, 7, 8, 8, 8, 8, 8, 8, 8,
+ 8,10,10,10, 7, 7, 7, 7, 8, 8, 9, 9, 9, 9, 9, 9,
+ 9, 9,10,10,10, 7, 7, 8, 7, 8, 8, 9, 9, 9, 9, 9,
+ 9, 9, 9,10,10,10, 7, 7, 8, 8, 8, 9, 9, 9, 9, 9,
+ 9,10, 9, 9,10,10,10, 7, 7, 8, 8, 9, 8, 9, 9, 9,
+ 9,10, 9, 9,10,10,11,11, 8, 8, 8, 8, 9, 9, 9, 9,
+ 9, 9,10, 9, 9,10,10,10,10, 8, 8, 8, 8, 9, 9, 9,
+ 9, 9, 9, 9, 9,10,10,11,11,11, 8, 8, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9,10,10,10,10,11,11,11, 8, 8, 9,
+ 9, 9, 9,10, 9, 9, 9, 9, 9,11,11,11,11,11, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,11,10,10,11,11, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9,10,10,10,10,11,10,11,11,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9,10,10, 9,10,10,11,11,
+ 11,11,11, 9, 9, 9,10, 9, 9, 9, 9, 9, 9,10,11,11,
+ 11,11,11,11,10,10,10,10, 9, 9, 9, 9, 9, 9,10,11,
+ 11,11,11,11,11, 9,10, 9, 9, 9, 9,10, 9, 9, 9,11,
+ 11,11,11,11,11,11,10,10, 9, 9, 9, 9, 9, 9,10, 9,
+ 11,11,10,11,11,11,11,10,11, 9, 9, 9, 9, 9, 9, 9,
+ 9,
+};
+
+static const static_codebook _44c1_s_p8_2 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44c1_s_p8_2,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44c1_s_p8_2,
+ 0
+};
+
+static const long _huff_lengthlist__44c1_s_short[] = {
+ 6, 8,13,12,13,14,15,16,16, 4, 2, 4, 7, 6, 8,11,
+ 13,15,10, 4, 4, 8, 6, 8,11,14,17,11, 5, 6, 5, 6,
+ 8,12,14,17,11, 5, 5, 6, 5, 7,10,13,16,12, 6, 7,
+ 8, 7, 8,10,13,15,13, 8, 8, 7, 7, 8,10,12,15,15,
+ 7, 7, 5, 5, 7, 9,12,14,15, 8, 8, 6, 6, 7, 8,10,
+ 11,
+};
+
+static const static_codebook _huff_book__44c1_s_short = {
+ 2, 81,
+ (long *)_huff_lengthlist__44c1_s_short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44c1_sm_long[] = {
+ 5, 4, 8,10, 9, 9,10,11,12, 4, 2, 5, 6, 6, 8,10,
+ 11,13, 8, 4, 6, 8, 7, 9,12,12,14,10, 6, 8, 4, 5,
+ 6, 9,11,12, 9, 5, 6, 5, 5, 6, 9,11,11, 9, 7, 9,
+ 6, 5, 5, 7,10,10,10, 9,11, 8, 7, 6, 7, 9,11,11,
+ 12,13,10,10, 9, 8, 9,11,11,15,15,12,13,11, 9,10,
+ 11,
+};
+
+static const static_codebook _huff_book__44c1_sm_long = {
+ 2, 81,
+ (long *)_huff_lengthlist__44c1_sm_long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44c1_sm_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44c1_sm_p1_0[] = {
+ 1, 5, 5, 0, 0, 0, 0, 0, 0, 5, 7, 7, 0, 0, 0, 0,
+ 0, 0, 5, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 5, 8, 7, 0, 0, 0, 0, 0, 0, 7, 9, 9, 0, 0, 0,
+ 0, 0, 0, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 5, 7, 7, 0, 0, 0, 0, 0, 0, 7, 9, 8, 0, 0,
+ 0, 0, 0, 0, 7, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 8, 7, 0, 0, 0, 0,
+ 0, 0, 8, 9, 9, 0, 0, 0, 0, 0, 0, 8, 9, 9, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 9, 9, 0, 0, 0,
+ 0, 0, 0, 9, 9,10, 0, 0, 0, 0, 0, 0, 9,10,10, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 9, 9, 0, 0,
+ 0, 0, 0, 0, 8,10, 9, 0, 0, 0, 0, 0, 0, 9,10,10,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 5, 7, 8, 0, 0, 0, 0, 0, 0, 8, 9, 9, 0, 0,
+ 0, 0, 0, 0, 8, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 7, 9, 9, 0, 0, 0, 0, 0, 0, 9,10,10, 0,
+ 0, 0, 0, 0, 0, 8, 9,10, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 7, 9, 9, 0, 0, 0, 0, 0, 0, 9,10,10,
+ 0, 0, 0, 0, 0, 0, 9,10, 9, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c1_sm_p1_0 = {
+ 8, 6561,
+ (long *)_vq_lengthlist__44c1_sm_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44c1_sm_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44c1_sm_p2_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44c1_sm_p2_0[] = {
+ 2, 3, 4, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 6, 6, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 4, 4, 4, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 9, 9,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 6, 6, 7, 9, 9, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c1_sm_p2_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44c1_sm_p2_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44c1_sm_p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44c1_sm_p3_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44c1_sm_p3_0[] = {
+ 1, 3, 3, 7, 7, 0, 0, 0, 0, 0, 5, 5, 6, 6, 0, 0,
+ 0, 0, 0, 5, 5, 7, 7, 0, 0, 0, 0, 0, 7, 7, 7, 7,
+ 0, 0, 0, 0, 0, 0, 0, 7, 7, 0, 0, 0, 0, 0, 0, 0,
+ 8, 9, 0, 0, 0, 0, 0, 0, 0, 8, 8, 0, 0, 0, 0, 0,
+ 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44c1_sm_p3_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44c1_sm_p3_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c1_sm_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44c1_sm_p4_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44c1_sm_p4_0[] = {
+ 1, 3, 3, 6, 6, 7, 7, 9, 9, 0, 6, 6, 7, 7, 8, 8,
+ 9, 9, 0, 6, 6, 7, 7, 8, 8, 9, 9, 0, 7, 7, 8, 8,
+ 8, 8,10,10, 0, 0, 0, 8, 8, 8, 8,10,10, 0, 0, 0,
+ 8, 8, 9, 9,11,11, 0, 0, 0, 9, 9, 9, 9,11,11, 0,
+ 0, 0,10,10,10,10,11,11, 0, 0, 0, 0, 0, 9, 9,11,
+ 11,
+};
+
+static const static_codebook _44c1_sm_p4_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44c1_sm_p4_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c1_sm_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44c1_sm_p5_0[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44c1_sm_p5_0[] = {
+ 2, 3, 3, 6, 6, 7, 7, 8, 8, 8, 8, 9, 9,10,10,11,
+ 11, 0, 5, 5, 6, 6, 8, 8, 9, 9, 9, 9,10,10,10,10,
+ 11,11, 0, 5, 5, 6, 6, 8, 8, 9, 9, 9, 9,10,10,10,
+ 10,11,11, 0, 7, 7, 7, 7, 8, 8, 9, 9, 9, 9,10,10,
+ 11,11,12,12, 0, 0, 0, 7, 7, 8, 8, 9, 9, 9, 9,10,
+ 10,11,11,12,12, 0, 0, 0, 8, 8, 8, 8, 9, 9,10,10,
+ 10,11,11,11,12,12, 0, 0, 0, 8, 8, 8, 8, 9, 9,10,
+ 10,10,10,11,11,12,12, 0, 0, 0, 9, 9, 9, 9,10,10,
+ 10,10,11,11,12,12,12,12, 0, 0, 0, 0, 0, 9, 9,10,
+ 10,10,10,11,11,12,12,13,13, 0, 0, 0, 0, 0, 9, 9,
+ 9, 9,10,10,11,11,12,12,13,13, 0, 0, 0, 0, 0, 9,
+ 9, 9, 9,10,10,11,11,12,12,13,13, 0, 0, 0, 0, 0,
+ 9, 9,10,10,11,11,12,12,12,12,13,13, 0, 0, 0, 0,
+ 0, 0, 0,10,10,11,11,12,12,12,12,13,13, 0, 0, 0,
+ 0, 0, 0, 0,11,11,11,11,12,12,13,13,13,13, 0, 0,
+ 0, 0, 0, 0, 0,11,11,11,11,12,12,13,13,13,13, 0,
+ 0, 0, 0, 0, 0, 0,11,11,12,12,12,12,13,13,14,14,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,12,12,12,12,13,13,14,
+ 14,
+};
+
+static const static_codebook _44c1_sm_p5_0 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44c1_sm_p5_0,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44c1_sm_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44c1_sm_p6_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44c1_sm_p6_0[] = {
+ 1, 4, 4, 7, 6, 6, 7, 6, 6, 4, 7, 7,10, 9, 9,11,
+ 9, 9, 4, 7, 7,10, 9, 9,11, 9, 9, 7,10,10,10,11,
+ 11,11,10,10, 6, 9, 9,11,11,10,11,10,10, 6, 9, 9,
+ 11,10,11,11,10,10, 7,11,11,11,11,11,11,11,11, 6,
+ 9, 9,11,10,10,11,11,10, 6, 9, 9,10,10,10,11,10,
+ 11,
+};
+
+static const static_codebook _44c1_sm_p6_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44c1_sm_p6_0,
+ 1, -529137664, 1618345984, 2, 0,
+ (long *)_vq_quantlist__44c1_sm_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44c1_sm_p6_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44c1_sm_p6_1[] = {
+ 2, 4, 4, 6, 6, 7, 7, 7, 7, 8, 8,10, 5, 5, 6, 6,
+ 7, 7, 8, 8, 8, 8,10, 5, 5, 6, 6, 7, 7, 8, 8, 8,
+ 8,10, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8,10,10,10, 7,
+ 7, 7, 7, 8, 8, 8, 8,10,10,10, 7, 7, 8, 8, 8, 8,
+ 8, 8,10,10,10, 7, 7, 8, 8, 8, 8, 8, 8,10,10,10,
+ 8, 8, 8, 8, 8, 8, 9, 8,10,10,10,10,10, 8, 8, 8,
+ 8, 8, 8,10,10,10,10,10, 9, 9, 8, 8, 8, 8,10,10,
+ 10,10,10, 8, 8, 8, 8, 8, 8,
+};
+
+static const static_codebook _44c1_sm_p6_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44c1_sm_p6_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44c1_sm_p6_1,
+ 0
+};
+
+static const long _vq_quantlist__44c1_sm_p7_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c1_sm_p7_0[] = {
+ 1, 4, 4, 6, 6, 7, 7, 7, 7, 8, 8, 9, 9, 7, 5, 5,
+ 7, 7, 8, 8, 8, 8, 9, 9,10,10, 7, 5, 6, 7, 7, 8,
+ 8, 8, 8, 9, 9,11,10, 0, 8, 8, 8, 8, 9, 9, 9, 9,
+ 10,10,11,11, 0, 8, 8, 8, 8, 9, 9, 9, 9,10,10,11,
+ 11, 0,12,12, 9, 9,10,10,10,10,11,11,11,11, 0,13,
+ 13, 9, 9, 9, 9,10,10,11,11,12,12, 0, 0, 0, 9,10,
+ 9,10,11,11,12,11,13,12, 0, 0, 0,10,10, 9, 9,11,
+ 11,12,12,13,12, 0, 0, 0,13,13,10,10,11,11,12,12,
+ 13,13, 0, 0, 0,14,14,10,10,11,11,12,12,13,13, 0,
+ 0, 0, 0, 0,11,12,11,11,12,13,14,13, 0, 0, 0, 0,
+ 0,12,12,11,11,13,12,14,13,
+};
+
+static const static_codebook _44c1_sm_p7_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c1_sm_p7_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44c1_sm_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44c1_sm_p7_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44c1_sm_p7_1[] = {
+ 2, 4, 4, 4, 5, 6, 5, 5, 5, 5, 6, 5, 5, 5, 5, 6,
+ 5, 5, 5, 5, 6, 6, 6, 5, 5,
+};
+
+static const static_codebook _44c1_sm_p7_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44c1_sm_p7_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44c1_sm_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44c1_sm_p8_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c1_sm_p8_0[] = {
+ 1, 3, 3,13,13,13,13,13,13,13,13,13,13, 3, 6, 6,
+ 13,13,13,13,13,13,13,13,13,13, 4, 8, 7,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,
+};
+
+static const static_codebook _44c1_sm_p8_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c1_sm_p8_0,
+ 1, -514541568, 1627103232, 4, 0,
+ (long *)_vq_quantlist__44c1_sm_p8_0,
+ 0
+};
+
+static const long _vq_quantlist__44c1_sm_p8_1[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44c1_sm_p8_1[] = {
+ 1, 4, 4, 6, 6, 7, 7, 9, 9,10,11,12,12, 6, 5, 5,
+ 7, 7, 8, 7,10,10,11,11,12,12, 6, 5, 5, 7, 7, 8,
+ 8,10,10,11,11,12,12,16, 7, 7, 8, 8, 9, 9,11,11,
+ 12,12,13,13,17, 7, 7, 8, 7, 9, 9,11,10,12,12,13,
+ 13,19,11,10, 8, 8,10,10,11,11,12,12,13,13,19,11,
+ 11, 9, 7,11,10,11,11,12,12,13,12,19,19,19,10,10,
+ 10,10,11,12,12,12,13,14,18,19,19,11, 9,11, 9,13,
+ 12,12,12,13,13,19,20,19,13,15,11,11,12,12,13,13,
+ 14,13,18,19,20,15,13,12,10,13,10,13,13,13,14,20,
+ 20,20,20,20,13,14,12,12,13,12,13,13,20,20,20,20,
+ 20,13,12,12,12,14,12,14,13,
+};
+
+static const static_codebook _44c1_sm_p8_1 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44c1_sm_p8_1,
+ 1, -522616832, 1620115456, 4, 0,
+ (long *)_vq_quantlist__44c1_sm_p8_1,
+ 0
+};
+
+static const long _vq_quantlist__44c1_sm_p8_2[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44c1_sm_p8_2[] = {
+ 2, 5, 5, 6, 6, 7, 6, 7, 7, 8, 8, 8, 8, 8, 8, 8,
+ 8,10, 6, 6, 7, 7, 7, 7, 8, 8, 9, 9, 9, 9, 9, 9,
+ 9, 9,10, 6, 6, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 9,
+ 9, 9, 9,10, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9,10,10,10, 7, 7, 8, 8, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9,10,11,11, 8, 8, 8, 8, 9, 9, 9, 9,
+ 9, 9,10,10, 9,10,10,10,10, 8, 8, 8, 8, 9, 9, 9,
+ 9, 9, 9, 9, 9,10,10,11,10,10, 8, 8, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9,10, 9,10,10,10,11,11, 8, 8, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9,11,11,11,11,11, 9, 9,
+ 9, 9, 9, 9, 9, 9,10, 9,10, 9,11,11,11,11,11, 9,
+ 8, 9, 9, 9, 9, 9, 9, 9,10,10, 9,11,11,10,11,11,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9,10,10, 9,11,11,11,11,
+ 11,11,11, 9, 9,10, 9, 9, 9, 9,10, 9,10,10,11,10,
+ 11,11,11,11, 9,10,10,10, 9, 9, 9, 9, 9, 9,10,11,
+ 11,11,11,11,11, 9, 9, 9, 9, 9, 9, 9, 9,10, 9,11,
+ 11,10,11,11,11,11,10,10, 9, 9, 9, 9, 9, 9,10, 9,
+ 10,11,10,11,11,11,11,11,11, 9, 9,10, 9, 9, 9, 9,
+ 9,
+};
+
+static const static_codebook _44c1_sm_p8_2 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44c1_sm_p8_2,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44c1_sm_p8_2,
+ 0
+};
+
+static const long _huff_lengthlist__44c1_sm_short[] = {
+ 4, 7,13,14,14,15,16,18,18, 4, 2, 5, 8, 7, 9,12,
+ 15,15,10, 4, 5,10, 6, 8,11,15,17,12, 5, 7, 5, 6,
+ 8,11,14,17,11, 5, 6, 6, 5, 6, 9,13,17,12, 6, 7,
+ 6, 5, 6, 8,12,14,14, 7, 8, 6, 6, 7, 9,11,14,14,
+ 8, 9, 6, 5, 6, 9,11,13,16,10,10, 7, 6, 7, 8,10,
+ 11,
+};
+
+static const static_codebook _huff_book__44c1_sm_short = {
+ 2, 81,
+ (long *)_huff_lengthlist__44c1_sm_short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44cn1_s_long[] = {
+ 4, 4, 7, 8, 7, 8,10,12,17, 3, 1, 6, 6, 7, 8,10,
+ 12,15, 7, 6, 9, 9, 9,11,12,14,17, 8, 6, 9, 6, 7,
+ 9,11,13,17, 7, 6, 9, 7, 7, 8, 9,12,15, 8, 8,10,
+ 8, 7, 7, 7,10,14, 9,10,12,10, 8, 8, 8,10,14,11,
+ 13,15,13,12,11,11,12,16,17,18,18,19,20,18,16,16,
+ 20,
+};
+
+static const static_codebook _huff_book__44cn1_s_long = {
+ 2, 81,
+ (long *)_huff_lengthlist__44cn1_s_long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44cn1_s_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44cn1_s_p1_0[] = {
+ 1, 4, 4, 0, 0, 0, 0, 0, 0, 5, 7, 7, 0, 0, 0, 0,
+ 0, 0, 5, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 5, 8, 8, 0, 0, 0, 0, 0, 0, 8, 9, 9, 0, 0, 0,
+ 0, 0, 0, 7, 9,10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 5, 8, 8, 0, 0, 0, 0, 0, 0, 7,10, 9, 0, 0,
+ 0, 0, 0, 0, 8,10, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 8, 8, 0, 0, 0, 0,
+ 0, 0, 8,10,10, 0, 0, 0, 0, 0, 0, 8, 9,10, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7,10,10, 0, 0, 0,
+ 0, 0, 0, 9, 9,11, 0, 0, 0, 0, 0, 0,10,11,11, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7,10,10, 0, 0,
+ 0, 0, 0, 0, 9,11, 9, 0, 0, 0, 0, 0, 0,10,11,11,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 5, 8, 8, 0, 0, 0, 0, 0, 0, 8,10,10, 0, 0,
+ 0, 0, 0, 0, 8,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 7,10,10, 0, 0, 0, 0, 0, 0,10,11,11, 0,
+ 0, 0, 0, 0, 0, 9, 9,11, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 7,10,10, 0, 0, 0, 0, 0, 0,10,11,11,
+ 0, 0, 0, 0, 0, 0, 9,11, 9, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44cn1_s_p1_0 = {
+ 8, 6561,
+ (long *)_vq_lengthlist__44cn1_s_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44cn1_s_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44cn1_s_p2_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44cn1_s_p2_0[] = {
+ 1, 4, 4, 7, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 5, 5, 7, 7, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 4, 5, 5, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 7, 7, 9, 9,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 6, 7, 7, 9, 9, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44cn1_s_p2_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44cn1_s_p2_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44cn1_s_p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44cn1_s_p3_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44cn1_s_p3_0[] = {
+ 1, 2, 3, 7, 7, 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0,
+ 0, 0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0, 0, 7, 7,
+ 0, 0, 0, 0, 0, 0, 0, 7, 7, 0, 0, 0, 0, 0, 0, 0,
+ 9, 8, 0, 0, 0, 0, 0, 0, 0, 8, 8, 0, 0, 0, 0, 0,
+ 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44cn1_s_p3_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44cn1_s_p3_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44cn1_s_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44cn1_s_p4_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44cn1_s_p4_0[] = {
+ 1, 3, 3, 6, 6, 6, 6, 8, 8, 0, 0, 0, 6, 6, 7, 7,
+ 9, 9, 0, 0, 0, 6, 6, 7, 7, 9, 9, 0, 0, 0, 7, 7,
+ 8, 8,10,10, 0, 0, 0, 7, 7, 8, 8,10,10, 0, 0, 0,
+ 9, 9, 9, 9,10,10, 0, 0, 0, 9, 9, 9, 9,10,10, 0,
+ 0, 0,10,10,10,10,11,11, 0, 0, 0, 0, 0,10,10,11,
+ 11,
+};
+
+static const static_codebook _44cn1_s_p4_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44cn1_s_p4_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44cn1_s_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44cn1_s_p5_0[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44cn1_s_p5_0[] = {
+ 1, 4, 3, 6, 6, 7, 7, 8, 8, 8, 8, 9, 9,10,10,10,
+ 10, 0, 0, 0, 7, 7, 8, 8, 9, 9, 9, 9,10,10,10,10,
+ 11,11, 0, 0, 0, 7, 7, 8, 8, 9, 9, 9, 9,10,10,10,
+ 10,11,11, 0, 0, 0, 7, 7, 8, 8, 9, 9, 9, 9,10,10,
+ 11,11,11,12, 0, 0, 0, 7, 7, 8, 8, 9, 9, 9, 9,10,
+ 10,11,11,11,11, 0, 0, 0, 8, 8, 9, 9, 9, 9,10,10,
+ 10,10,11,11,12,12, 0, 0, 0, 8, 8, 9, 9, 9, 9,10,
+ 10,10,11,11,11,12,12, 0, 0, 0, 9, 9,10, 9,10,10,
+ 10,10,11,11,11,11,12,12, 0, 0, 0, 0, 0, 9, 9,10,
+ 10,10,10,11,11,12,12,12,12, 0, 0, 0, 0, 0, 9, 9,
+ 10,10,10,11,11,11,12,12,13,13, 0, 0, 0, 0, 0, 9,
+ 9,10,10,10,10,11,11,12,12,13,13, 0, 0, 0, 0, 0,
+ 10,10,11,10,11,11,11,12,13,12,13,13, 0, 0, 0, 0,
+ 0, 0, 0,11,10,11,11,12,12,12,12,13,13, 0, 0, 0,
+ 0, 0, 0, 0,11,11,12,12,12,12,13,13,13,14, 0, 0,
+ 0, 0, 0, 0, 0,11,11,12,12,12,12,13,13,13,14, 0,
+ 0, 0, 0, 0, 0, 0,12,12,12,13,13,13,13,13,14,14,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,12,12,13,12,13,13,14,
+ 14,
+};
+
+static const static_codebook _44cn1_s_p5_0 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44cn1_s_p5_0,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44cn1_s_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44cn1_s_p6_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44cn1_s_p6_0[] = {
+ 1, 4, 4, 7, 6, 6, 7, 6, 6, 4, 6, 6,10, 9, 9,11,
+ 9, 9, 4, 6, 6,10, 9, 9,10, 9, 9, 7,10,10,11,11,
+ 11,12,11,11, 7, 9, 9,11,11,10,11,10,10, 7, 9, 9,
+ 11,10,11,11,10,10, 7,10,10,11,11,11,12,11,11, 7,
+ 9, 9,11,10,10,11,10,10, 7, 9, 9,11,10,10,11,10,
+ 10,
+};
+
+static const static_codebook _44cn1_s_p6_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44cn1_s_p6_0,
+ 1, -529137664, 1618345984, 2, 0,
+ (long *)_vq_quantlist__44cn1_s_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44cn1_s_p6_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44cn1_s_p6_1[] = {
+ 1, 4, 4, 6, 6, 7, 7, 8, 8, 8, 8,10,10,10, 7, 6,
+ 8, 8, 8, 8, 8, 8,10,10,10, 7, 6, 7, 7, 8, 8, 8,
+ 8,10,10,10, 7, 7, 8, 8, 8, 8, 8, 8,10,10,10, 7,
+ 7, 8, 8, 8, 8, 8, 8,10,10,10, 8, 8, 8, 8, 9, 9,
+ 9, 9,10,10,10, 8, 8, 8, 8, 9, 9, 9, 9,10,10,10,
+ 9, 9, 9, 9, 9, 9, 9, 9,10,10,10,10,10, 9, 9, 9,
+ 9, 9, 9,10,10,10,10,10, 9, 9, 9, 9, 9, 9,10,10,
+ 10,10,10, 9, 9, 9, 9, 9, 9,
+};
+
+static const static_codebook _44cn1_s_p6_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44cn1_s_p6_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44cn1_s_p6_1,
+ 0
+};
+
+static const long _vq_quantlist__44cn1_s_p7_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44cn1_s_p7_0[] = {
+ 1, 4, 4, 6, 6, 7, 7, 8, 8, 9, 9,10,10, 6, 5, 5,
+ 7, 7, 8, 8, 8, 8, 9, 9,11,11, 7, 5, 5, 7, 7, 8,
+ 8, 8, 8, 9,10,11,11, 0, 8, 8, 8, 8, 9, 9, 9, 9,
+ 10,10,11,11, 0, 8, 8, 8, 8, 9, 9, 9, 9,10,10,11,
+ 11, 0,12,12, 9, 9, 9,10,10,10,11,11,11,12, 0,13,
+ 13, 9, 9, 9, 9,10,10,11,11,11,12, 0, 0, 0,10,10,
+ 10,10,11,11,12,12,12,13, 0, 0, 0,10,10,10,10,11,
+ 11,12,12,13,12, 0, 0, 0,14,14,11,10,11,12,12,13,
+ 13,14, 0, 0, 0,15,15,11,11,12,11,12,12,14,13, 0,
+ 0, 0, 0, 0,12,12,12,12,13,13,14,14, 0, 0, 0, 0,
+ 0,13,13,12,12,13,13,13,14,
+};
+
+static const static_codebook _44cn1_s_p7_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44cn1_s_p7_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44cn1_s_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44cn1_s_p7_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44cn1_s_p7_1[] = {
+ 2, 3, 3, 5, 5, 6, 6, 6, 5, 5, 6, 6, 6, 5, 5, 6,
+ 6, 6, 5, 5, 6, 6, 6, 5, 5,
+};
+
+static const static_codebook _44cn1_s_p7_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44cn1_s_p7_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44cn1_s_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44cn1_s_p8_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44cn1_s_p8_0[] = {
+ 1, 7, 7,11,11, 8,11,11,11,11, 4,11, 3,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,10,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,10,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11, 7,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,10,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,10,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11, 8,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,
+};
+
+static const static_codebook _44cn1_s_p8_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44cn1_s_p8_0,
+ 1, -518283264, 1627103232, 3, 0,
+ (long *)_vq_quantlist__44cn1_s_p8_0,
+ 0
+};
+
+static const long _vq_quantlist__44cn1_s_p8_1[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44cn1_s_p8_1[] = {
+ 1, 4, 4, 6, 6, 8, 8, 9,10,10,11,11,11, 6, 5, 5,
+ 7, 7, 8, 8, 9,10, 9,11,11,12, 5, 5, 5, 7, 7, 8,
+ 9,10,10,12,12,14,13,15, 7, 7, 8, 8, 9,10,11,11,
+ 10,12,10,11,15, 7, 8, 8, 8, 9, 9,11,11,13,12,12,
+ 13,15,10,10, 8, 8,10,10,12,12,11,14,10,10,15,11,
+ 11, 8, 8,10,10,12,13,13,14,15,13,15,15,15,10,10,
+ 10,10,12,12,13,12,13,10,15,15,15,10,10,11,10,13,
+ 11,13,13,15,13,15,15,15,13,13,10,11,11,11,12,10,
+ 14,11,15,15,14,14,13,10,10,12,11,13,13,14,14,15,
+ 15,15,15,15,11,11,11,11,12,11,15,12,15,15,15,15,
+ 15,12,12,11,11,14,12,13,14,
+};
+
+static const static_codebook _44cn1_s_p8_1 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44cn1_s_p8_1,
+ 1, -522616832, 1620115456, 4, 0,
+ (long *)_vq_quantlist__44cn1_s_p8_1,
+ 0
+};
+
+static const long _vq_quantlist__44cn1_s_p8_2[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44cn1_s_p8_2[] = {
+ 3, 4, 3, 6, 6, 7, 7, 8, 8, 9, 9, 9, 9, 9, 9, 9,
+ 9,10,11,11, 6, 6, 7, 7, 8, 8, 9, 9, 9, 9, 9, 9,
+ 9, 9,10,10,10, 6, 6, 7, 7, 8, 8, 9, 9, 9, 9, 9,
+ 9, 9, 9,10,10,10, 7, 7, 7, 8, 8, 8, 9, 9, 9, 9,
+ 9, 9,10, 9,10,11,10, 7, 6, 7, 7, 8, 8, 9, 9, 9,
+ 9, 9, 9, 9,10,10,10,11, 7, 7, 8, 8, 8, 8, 9, 9,
+ 9, 9, 9, 9, 9, 9,10,10,10, 7, 7, 8, 8, 8, 8, 9,
+ 9, 9, 9, 9, 9, 9,10,11,11,11, 8, 8, 8, 8, 8, 8,
+ 9, 9, 9, 9, 9, 9, 9, 9,11,10,10,11,11, 8, 8, 8,
+ 9, 9, 9, 9, 9, 9,10, 9,10,10,10,10,11,11, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,11,11,10,11,11, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9,10,10,10,10,11,10,11,11,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,11,10,10,11,
+ 11,11,11, 9, 9, 9, 9, 9, 9, 9, 9,10,10,10,11,11,
+ 10,11,11,11, 9,10,10, 9, 9, 9, 9, 9, 9, 9,10,11,
+ 11,11,11,11,11, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,11,
+ 11,11,11,11,11,11,10,10, 9, 9, 9, 9, 9, 9, 9, 9,
+ 11,11,11,10,11,11,11,11,11, 9, 9, 9,10, 9, 9, 9,
+ 9,
+};
+
+static const static_codebook _44cn1_s_p8_2 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44cn1_s_p8_2,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44cn1_s_p8_2,
+ 0
+};
+
+static const long _huff_lengthlist__44cn1_s_short[] = {
+ 10, 9,12,15,12,13,16,14,16, 7, 1, 5,14, 7,10,13,
+ 16,16, 9, 4, 6,16, 8,11,16,16,16,14, 4, 7,16, 9,
+ 12,14,16,16,10, 5, 7,14, 9,12,14,15,15,13, 8, 9,
+ 14,10,12,13,14,15,13, 9, 9, 7, 6, 8,11,12,12,14,
+ 8, 8, 5, 4, 5, 8,11,12,16,10,10, 6, 5, 6, 8, 9,
+ 10,
+};
+
+static const static_codebook _huff_book__44cn1_s_short = {
+ 2, 81,
+ (long *)_huff_lengthlist__44cn1_s_short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44cn1_sm_long[] = {
+ 3, 3, 8, 8, 8, 8,10,12,14, 3, 2, 6, 7, 7, 8,10,
+ 12,16, 7, 6, 7, 9, 8,10,12,14,16, 8, 6, 8, 4, 5,
+ 7, 9,11,13, 7, 6, 8, 5, 6, 7, 9,11,14, 8, 8,10,
+ 7, 7, 6, 8,10,13, 9,11,12, 9, 9, 7, 8,10,12,10,
+ 13,15,11,11,10, 9,10,13,13,16,17,14,15,14,13,14,
+ 17,
+};
+
+static const static_codebook _huff_book__44cn1_sm_long = {
+ 2, 81,
+ (long *)_huff_lengthlist__44cn1_sm_long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44cn1_sm_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44cn1_sm_p1_0[] = {
+ 1, 4, 5, 0, 0, 0, 0, 0, 0, 5, 7, 7, 0, 0, 0, 0,
+ 0, 0, 5, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 5, 8, 8, 0, 0, 0, 0, 0, 0, 8, 9, 9, 0, 0, 0,
+ 0, 0, 0, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 5, 8, 8, 0, 0, 0, 0, 0, 0, 7, 9, 8, 0, 0,
+ 0, 0, 0, 0, 8, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 8, 8, 0, 0, 0, 0,
+ 0, 0, 8,10, 9, 0, 0, 0, 0, 0, 0, 8, 9, 9, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7,10, 9, 0, 0, 0,
+ 0, 0, 0, 9, 9,10, 0, 0, 0, 0, 0, 0, 9,10,10, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 9, 9, 0, 0,
+ 0, 0, 0, 0, 8,10, 9, 0, 0, 0, 0, 0, 0, 9,10,10,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 5, 8, 8, 0, 0, 0, 0, 0, 0, 8, 9, 9, 0, 0,
+ 0, 0, 0, 0, 8, 9,10, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 7, 9, 9, 0, 0, 0, 0, 0, 0, 9,10,10, 0,
+ 0, 0, 0, 0, 0, 8, 9,10, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 7, 9,10, 0, 0, 0, 0, 0, 0, 9,10,10,
+ 0, 0, 0, 0, 0, 0, 9,10, 9, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44cn1_sm_p1_0 = {
+ 8, 6561,
+ (long *)_vq_lengthlist__44cn1_sm_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44cn1_sm_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44cn1_sm_p2_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44cn1_sm_p2_0[] = {
+ 1, 4, 4, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 5, 5, 7, 7, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 4, 5, 5, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 7, 7, 9, 9,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 7, 7, 7, 9, 9, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44cn1_sm_p2_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44cn1_sm_p2_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44cn1_sm_p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44cn1_sm_p3_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44cn1_sm_p3_0[] = {
+ 1, 3, 4, 7, 7, 0, 0, 0, 0, 0, 4, 4, 7, 7, 0, 0,
+ 0, 0, 0, 4, 5, 7, 7, 0, 0, 0, 0, 0, 6, 7, 8, 8,
+ 0, 0, 0, 0, 0, 0, 0, 8, 8, 0, 0, 0, 0, 0, 0, 0,
+ 9, 9, 0, 0, 0, 0, 0, 0, 0,10, 9, 0, 0, 0, 0, 0,
+ 0, 0,11,11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,
+};
+
+static const static_codebook _44cn1_sm_p3_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44cn1_sm_p3_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44cn1_sm_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44cn1_sm_p4_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44cn1_sm_p4_0[] = {
+ 1, 4, 3, 6, 6, 7, 7, 9, 9, 0, 5, 5, 7, 7, 8, 7,
+ 9, 9, 0, 5, 5, 7, 7, 8, 8, 9, 9, 0, 7, 7, 8, 8,
+ 8, 8,10,10, 0, 0, 0, 8, 8, 8, 8,10,10, 0, 0, 0,
+ 9, 9, 9, 9,10,10, 0, 0, 0, 9, 9, 9, 9,10,10, 0,
+ 0, 0,10,10,10,10,11,11, 0, 0, 0, 0, 0,10,10,11,
+ 11,
+};
+
+static const static_codebook _44cn1_sm_p4_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44cn1_sm_p4_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44cn1_sm_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44cn1_sm_p5_0[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44cn1_sm_p5_0[] = {
+ 1, 4, 4, 6, 6, 8, 8, 9, 9, 8, 8, 9, 9,10,10,11,
+ 11, 0, 6, 6, 7, 7, 8, 8, 9, 9, 9, 9,10,10,11,11,
+ 12,12, 0, 6, 5, 7, 7, 8, 8, 9, 9, 9, 9,10,10,11,
+ 11,12,12, 0, 7, 7, 7, 7, 8, 8, 9, 9, 9, 9,10,10,
+ 11,11,12,12, 0, 0, 0, 7, 7, 8, 8, 9, 9,10,10,11,
+ 11,11,11,12,12, 0, 0, 0, 8, 8, 9, 9,10,10,10,10,
+ 11,11,12,12,12,12, 0, 0, 0, 8, 8, 9, 9,10,10,10,
+ 10,11,11,12,12,12,12, 0, 0, 0, 9, 9, 9, 9,10,10,
+ 10,10,11,11,12,12,13,13, 0, 0, 0, 0, 0, 9, 9,10,
+ 10,10,10,11,11,12,12,13,13, 0, 0, 0, 0, 0, 9, 9,
+ 10,10,11,11,12,12,13,13,13,13, 0, 0, 0, 0, 0, 9,
+ 9,10,10,11,11,12,12,12,13,13,13, 0, 0, 0, 0, 0,
+ 10,10,11,11,11,11,12,12,13,13,14,14, 0, 0, 0, 0,
+ 0, 0, 0,11,11,11,11,12,12,13,13,14,14, 0, 0, 0,
+ 0, 0, 0, 0,11,11,12,12,13,13,13,13,14,14, 0, 0,
+ 0, 0, 0, 0, 0,11,11,12,12,13,13,13,13,14,14, 0,
+ 0, 0, 0, 0, 0, 0,12,12,12,13,13,13,14,14,14,14,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,12,12,13,13,14,14,14,
+ 14,
+};
+
+static const static_codebook _44cn1_sm_p5_0 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44cn1_sm_p5_0,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44cn1_sm_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44cn1_sm_p6_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44cn1_sm_p6_0[] = {
+ 1, 4, 4, 7, 6, 6, 7, 6, 6, 4, 7, 6,10, 9, 9,11,
+ 9, 9, 4, 6, 7,10, 9, 9,11, 9, 9, 7,10,10,10,11,
+ 11,11,11,10, 6, 9, 9,11,10,10,11,10,10, 6, 9, 9,
+ 11,10,11,11,10,10, 7,11,11,11,11,11,12,11,11, 7,
+ 9, 9,11,10,10,12,10,10, 7, 9, 9,11,10,10,11,10,
+ 10,
+};
+
+static const static_codebook _44cn1_sm_p6_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44cn1_sm_p6_0,
+ 1, -529137664, 1618345984, 2, 0,
+ (long *)_vq_quantlist__44cn1_sm_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44cn1_sm_p6_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44cn1_sm_p6_1[] = {
+ 2, 4, 4, 5, 5, 7, 7, 7, 7, 8, 8,10, 5, 5, 6, 6,
+ 7, 7, 8, 8, 8, 8,10, 5, 5, 6, 6, 7, 7, 8, 8, 8,
+ 8,10, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8,10,10,10, 7,
+ 7, 7, 7, 8, 8, 8, 8,10,10,10, 8, 8, 8, 8, 8, 8,
+ 8, 8,10,10,10, 8, 8, 8, 8, 8, 8, 8, 8,10,10,10,
+ 8, 8, 8, 8, 8, 8, 9, 9,10,10,10,10,10, 8, 8, 8,
+ 8, 9, 9,10,10,10,10,10, 9, 9, 9, 9, 8, 9,10,10,
+ 10,10,10, 8, 9, 8, 8, 9, 8,
+};
+
+static const static_codebook _44cn1_sm_p6_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44cn1_sm_p6_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44cn1_sm_p6_1,
+ 0
+};
+
+static const long _vq_quantlist__44cn1_sm_p7_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44cn1_sm_p7_0[] = {
+ 1, 4, 4, 6, 6, 7, 7, 7, 7, 9, 9,10,10, 7, 5, 5,
+ 7, 7, 8, 8, 8, 8,10, 9,11,10, 7, 5, 5, 7, 7, 8,
+ 8, 8, 8, 9,10,11,11, 0, 8, 8, 8, 8, 9, 9, 9, 9,
+ 10,10,11,11, 0, 8, 8, 8, 8, 9, 9, 9, 9,10,10,11,
+ 11, 0,12,12, 9, 9, 9,10,10,10,11,11,12,12, 0,13,
+ 13, 9, 9, 9, 9,10,10,11,11,12,12, 0, 0, 0,10,10,
+ 10,10,11,11,12,12,12,13, 0, 0, 0,10,10,10,10,11,
+ 11,12,12,12,12, 0, 0, 0,14,14,11,11,11,11,12,13,
+ 13,13, 0, 0, 0,14,14,11,10,11,11,12,12,13,13, 0,
+ 0, 0, 0, 0,12,12,12,12,13,13,13,14, 0, 0, 0, 0,
+ 0,13,12,12,12,13,13,13,14,
+};
+
+static const static_codebook _44cn1_sm_p7_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44cn1_sm_p7_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44cn1_sm_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44cn1_sm_p7_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44cn1_sm_p7_1[] = {
+ 2, 4, 4, 4, 5, 6, 5, 5, 5, 5, 6, 5, 5, 5, 5, 6,
+ 5, 5, 5, 5, 6, 6, 6, 5, 5,
+};
+
+static const static_codebook _44cn1_sm_p7_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44cn1_sm_p7_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44cn1_sm_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44cn1_sm_p8_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44cn1_sm_p8_0[] = {
+ 1, 4, 4,12,11,13,13,14,14, 4, 7, 7,11,13,14,14,
+ 14,14, 3, 8, 3,14,14,14,14,14,14,14,10,12,14,14,
+ 14,14,14,14,14,14, 5,14, 8,14,14,14,14,14,12,14,
+ 13,14,14,14,14,14,14,14,13,14,10,14,14,14,14,14,
+ 14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,
+ 14,
+};
+
+static const static_codebook _44cn1_sm_p8_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44cn1_sm_p8_0,
+ 1, -516186112, 1627103232, 4, 0,
+ (long *)_vq_quantlist__44cn1_sm_p8_0,
+ 0
+};
+
+static const long _vq_quantlist__44cn1_sm_p8_1[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44cn1_sm_p8_1[] = {
+ 1, 4, 4, 6, 6, 8, 8, 9, 9,10,11,11,11, 6, 5, 5,
+ 7, 7, 8, 8,10,10,10,11,11,11, 6, 5, 5, 7, 7, 8,
+ 8,10,10,11,12,12,12,14, 7, 7, 7, 8, 9, 9,11,11,
+ 11,12,11,12,17, 7, 7, 8, 7, 9, 9,11,11,12,12,12,
+ 12,14,11,11, 8, 8,10,10,11,12,12,13,11,12,14,11,
+ 11, 8, 8,10,10,11,12,12,13,13,12,14,15,14,10,10,
+ 10,10,11,12,12,12,12,11,14,13,16,10,10,10, 9,12,
+ 11,12,12,13,14,14,15,14,14,13,10,10,11,11,12,11,
+ 13,11,14,12,15,13,14,11,10,12,10,12,12,13,13,13,
+ 13,14,15,15,12,12,11,11,12,11,13,12,14,14,14,14,
+ 17,12,12,11,10,13,11,13,13,
+};
+
+static const static_codebook _44cn1_sm_p8_1 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44cn1_sm_p8_1,
+ 1, -522616832, 1620115456, 4, 0,
+ (long *)_vq_quantlist__44cn1_sm_p8_1,
+ 0
+};
+
+static const long _vq_quantlist__44cn1_sm_p8_2[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44cn1_sm_p8_2[] = {
+ 3, 4, 4, 6, 6, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 9,
+ 9,10, 6, 6, 6, 6, 7, 7, 8, 8, 8, 9, 9, 9, 9, 9,
+ 9, 9,10, 6, 6, 6, 6, 7, 7, 8, 8, 8, 8, 9, 9, 9,
+ 9, 9, 9,10, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9,
+ 9, 9, 9, 9,10,10,10, 7, 7, 7, 8, 8, 8, 9, 9, 9,
+ 9, 9, 9, 9, 9,10,10,10, 8, 8, 8, 8, 8, 8, 9, 9,
+ 9, 9, 9, 9, 9, 9,10,10,10, 8, 8, 8, 8, 8, 8, 9,
+ 9, 9, 9, 9, 9, 9, 9,11,10,11, 8, 8, 8, 8, 8, 8,
+ 9, 9, 9, 9, 9, 9, 9, 9,10,10,10,11,11, 8, 8, 8,
+ 8, 9, 9, 9, 9, 9, 9, 9, 9,11,10,11,11,11, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,10,11,10,11,11, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,10,11,11,10,11,11,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,11,10,11,11,
+ 11,11,11, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,10,11,11,
+ 11,11,11,11, 9,10,10,10, 9, 9, 9, 9, 9, 9,11,10,
+ 11,11,11,11,11, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,11,
+ 11,11,11,11,11,11,10,10, 9, 9, 9, 9, 9, 9, 9, 9,
+ 10,11,11,11,11,11,11,11,11, 9, 9, 9, 9, 9, 9, 9,
+ 9,
+};
+
+static const static_codebook _44cn1_sm_p8_2 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44cn1_sm_p8_2,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44cn1_sm_p8_2,
+ 0
+};
+
+static const long _huff_lengthlist__44cn1_sm_short[] = {
+ 5, 6,12,14,12,14,16,17,18, 4, 2, 5,11, 7,10,12,
+ 14,15, 9, 4, 5,11, 7,10,13,15,18,15, 6, 7, 5, 6,
+ 8,11,13,16,11, 5, 6, 5, 5, 6, 9,13,15,12, 5, 7,
+ 6, 5, 6, 9,12,14,12, 6, 7, 8, 6, 7, 9,12,13,14,
+ 8, 8, 7, 5, 5, 8,10,12,16, 9, 9, 8, 6, 6, 7, 9,
+ 9,
+};
+
+static const static_codebook _huff_book__44cn1_sm_short = {
+ 2, 81,
+ (long *)_huff_lengthlist__44cn1_sm_short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2007 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: static codebooks autogenerated by huff/huffbuld
+ last modified: $Id: floor_books.h 16939 2010-03-01 08:38:14Z xiphmont $
+
+ ********************************************************************/
+
+#include "codebook.h"
+
+static const long _huff_lengthlist_line_256x7_0sub1[] = {
+ 0, 2, 3, 3, 3, 3, 4, 3, 4,
+};
+
+static const static_codebook _huff_book_line_256x7_0sub1 = {
+ 1, 9,
+ (long *)_huff_lengthlist_line_256x7_0sub1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_256x7_0sub2[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 3, 4, 3, 5, 3,
+ 6, 3, 6, 4, 6, 4, 7, 5, 7,
+};
+
+static const static_codebook _huff_book_line_256x7_0sub2 = {
+ 1, 25,
+ (long *)_huff_lengthlist_line_256x7_0sub2,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_256x7_0sub3[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 5, 2, 5, 3, 5, 3,
+ 6, 3, 6, 4, 7, 6, 7, 8, 7, 9, 8, 9, 9, 9,10, 9,
+ 11,13,11,13,10,10,13,13,13,13,13,13,12,12,12,12,
+};
+
+static const static_codebook _huff_book_line_256x7_0sub3 = {
+ 1, 64,
+ (long *)_huff_lengthlist_line_256x7_0sub3,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_256x7_1sub1[] = {
+ 0, 3, 3, 3, 3, 2, 4, 3, 4,
+};
+
+static const static_codebook _huff_book_line_256x7_1sub1 = {
+ 1, 9,
+ (long *)_huff_lengthlist_line_256x7_1sub1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_256x7_1sub2[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 3, 4, 3, 4, 4,
+ 5, 4, 6, 5, 6, 7, 6, 8, 8,
+};
+
+static const static_codebook _huff_book_line_256x7_1sub2 = {
+ 1, 25,
+ (long *)_huff_lengthlist_line_256x7_1sub2,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_256x7_1sub3[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 4, 3, 6, 3, 7,
+ 3, 8, 5, 8, 6, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 7,
+};
+
+static const static_codebook _huff_book_line_256x7_1sub3 = {
+ 1, 64,
+ (long *)_huff_lengthlist_line_256x7_1sub3,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_256x7_class0[] = {
+ 7, 5, 5, 9, 9, 6, 6, 9,12, 8, 7, 8,11, 8, 9,15,
+ 6, 3, 3, 7, 7, 4, 3, 6, 9, 6, 5, 6, 8, 6, 8,15,
+ 8, 5, 5, 9, 8, 5, 4, 6,10, 7, 5, 5,11, 8, 7,15,
+ 14,15,13,13,13,13, 8,11,15,10, 7, 6,11, 9,10,15,
+};
+
+static const static_codebook _huff_book_line_256x7_class0 = {
+ 1, 64,
+ (long *)_huff_lengthlist_line_256x7_class0,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_256x7_class1[] = {
+ 5, 6, 8,15, 6, 9,10,15,10,11,12,15,15,15,15,15,
+ 4, 6, 7,15, 6, 7, 8,15, 9, 8, 9,15,15,15,15,15,
+ 6, 8, 9,15, 7, 7, 8,15,10, 9,10,15,15,15,15,15,
+ 15,13,15,15,15,10,11,15,15,13,13,15,15,15,15,15,
+ 4, 6, 7,15, 6, 8, 9,15,10,10,12,15,15,15,15,15,
+ 2, 5, 6,15, 5, 6, 7,15, 8, 6, 7,15,15,15,15,15,
+ 5, 6, 8,15, 5, 6, 7,15, 9, 6, 7,15,15,15,15,15,
+ 14,12,13,15,12,10,11,15,15,15,15,15,15,15,15,15,
+ 7, 8, 9,15, 9,10,10,15,15,14,14,15,15,15,15,15,
+ 5, 6, 7,15, 7, 8, 9,15,12, 9,10,15,15,15,15,15,
+ 7, 7, 9,15, 7, 7, 8,15,12, 8, 9,15,15,15,15,15,
+ 13,13,14,15,12,11,12,15,15,15,15,15,15,15,15,15,
+ 15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
+ 13,13,13,15,15,15,15,15,15,15,15,15,15,15,15,15,
+ 15,12,13,15,15,12,13,15,15,14,15,15,15,15,15,15,
+ 15,15,15,15,15,15,13,15,15,15,15,15,15,15,15,15,
+};
+
+static const static_codebook _huff_book_line_256x7_class1 = {
+ 1, 256,
+ (long *)_huff_lengthlist_line_256x7_class1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_512x17_0sub0[] = {
+ 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 6, 5, 6, 6, 6, 6, 5, 6, 6, 7, 6, 7, 6, 7, 6,
+ 7, 6, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 9, 7, 9, 7,
+ 9, 7, 9, 8, 9, 8,10, 8,10, 8,10, 7,10, 6,10, 8,
+ 10, 8,11, 7,10, 7,11, 8,11,11,12,12,11,11,12,11,
+ 13,11,13,11,13,12,15,12,13,13,14,14,14,14,14,15,
+ 15,15,16,14,17,19,19,18,18,18,18,18,18,18,18,18,
+ 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
+};
+
+static const static_codebook _huff_book_line_512x17_0sub0 = {
+ 1, 128,
+ (long *)_huff_lengthlist_line_512x17_0sub0,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_512x17_1sub0[] = {
+ 2, 4, 5, 4, 5, 4, 5, 4, 5, 5, 5, 5, 5, 5, 6, 5,
+ 6, 5, 6, 6, 7, 6, 7, 6, 8, 7, 8, 7, 8, 7, 8, 7,
+};
+
+static const static_codebook _huff_book_line_512x17_1sub0 = {
+ 1, 32,
+ (long *)_huff_lengthlist_line_512x17_1sub0,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_512x17_1sub1[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 4, 3, 5, 3, 5, 4, 5, 4, 5, 4, 5, 5, 5, 5, 6, 5,
+ 6, 5, 7, 5, 8, 6, 8, 6, 8, 6, 8, 6, 8, 7, 9, 7,
+ 9, 7,11, 9,11,11,12,11,14,12,14,16,14,16,13,16,
+ 14,16,12,15,13,16,14,16,13,14,12,15,13,15,13,13,
+ 13,15,12,14,14,15,13,15,12,15,15,15,15,15,15,15,
+ 15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
+};
+
+static const static_codebook _huff_book_line_512x17_1sub1 = {
+ 1, 128,
+ (long *)_huff_lengthlist_line_512x17_1sub1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_512x17_2sub1[] = {
+ 0, 4, 5, 4, 4, 4, 5, 4, 4, 4, 5, 4, 5, 4, 5, 3,
+ 5, 3,
+};
+
+static const static_codebook _huff_book_line_512x17_2sub1 = {
+ 1, 18,
+ (long *)_huff_lengthlist_line_512x17_2sub1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_512x17_2sub2[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 4, 3, 4, 3, 4, 4, 5, 4, 5, 4, 6, 4, 6, 5,
+ 6, 5, 7, 5, 7, 6, 8, 6, 8, 6, 8, 7, 8, 7, 9, 7,
+ 9, 8,
+};
+
+static const static_codebook _huff_book_line_512x17_2sub2 = {
+ 1, 50,
+ (long *)_huff_lengthlist_line_512x17_2sub2,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_512x17_2sub3[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 3, 3, 3, 3, 4, 3, 4, 4, 5, 5, 6, 6, 7, 7,
+ 7, 8, 8,11, 8, 9, 9, 9,10,11,11,11, 9,10,10,11,
+ 11,11,11,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+};
+
+static const static_codebook _huff_book_line_512x17_2sub3 = {
+ 1, 128,
+ (long *)_huff_lengthlist_line_512x17_2sub3,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_512x17_3sub1[] = {
+ 0, 4, 4, 4, 4, 4, 4, 3, 4, 4, 4, 4, 4, 5, 4, 5,
+ 5, 5,
+};
+
+static const static_codebook _huff_book_line_512x17_3sub1 = {
+ 1, 18,
+ (long *)_huff_lengthlist_line_512x17_3sub1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_512x17_3sub2[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 2, 3, 3, 4, 3, 5, 4, 6, 4, 6, 5, 7, 6, 7,
+ 6, 8, 6, 8, 7, 9, 8,10, 8,12, 9,13,10,15,10,15,
+ 11,14,
+};
+
+static const static_codebook _huff_book_line_512x17_3sub2 = {
+ 1, 50,
+ (long *)_huff_lengthlist_line_512x17_3sub2,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_512x17_3sub3[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 4, 8, 4, 8, 4, 8, 4, 8, 5, 8, 5, 8, 6, 8,
+ 4, 8, 4, 8, 5, 8, 5, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+};
+
+static const static_codebook _huff_book_line_512x17_3sub3 = {
+ 1, 128,
+ (long *)_huff_lengthlist_line_512x17_3sub3,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_512x17_class1[] = {
+ 1, 2, 3, 6, 5, 4, 7, 7,
+};
+
+static const static_codebook _huff_book_line_512x17_class1 = {
+ 1, 8,
+ (long *)_huff_lengthlist_line_512x17_class1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_512x17_class2[] = {
+ 3, 3, 3,14, 5, 4, 4,11, 8, 6, 6,10,17,12,11,17,
+ 6, 5, 5,15, 5, 3, 4,11, 8, 5, 5, 8,16, 9,10,14,
+ 10, 8, 9,17, 8, 6, 6,13,10, 7, 7,10,16,11,13,14,
+ 17,17,17,17,17,16,16,16,16,15,16,16,16,16,16,16,
+};
+
+static const static_codebook _huff_book_line_512x17_class2 = {
+ 1, 64,
+ (long *)_huff_lengthlist_line_512x17_class2,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_512x17_class3[] = {
+ 2, 4, 6,17, 4, 5, 7,17, 8, 7,10,17,17,17,17,17,
+ 3, 4, 6,15, 3, 3, 6,15, 7, 6, 9,17,17,17,17,17,
+ 6, 8,10,17, 6, 6, 8,16, 9, 8,10,17,17,15,16,17,
+ 17,17,17,17,12,15,15,16,12,15,15,16,16,16,16,16,
+};
+
+static const static_codebook _huff_book_line_512x17_class3 = {
+ 1, 64,
+ (long *)_huff_lengthlist_line_512x17_class3,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x4_class0[] = {
+ 7, 7, 7,11, 6, 6, 7,11, 7, 6, 6,10,12,10,10,13,
+ 7, 7, 8,11, 7, 7, 7,11, 7, 6, 7,10,11,10,10,13,
+ 10,10, 9,12, 9, 9, 9,11, 8, 8, 8,11,13,11,10,14,
+ 15,15,14,15,15,14,13,14,15,12,12,17,17,17,17,17,
+ 7, 7, 6, 9, 6, 6, 6, 9, 7, 6, 6, 8,11,11,10,12,
+ 7, 7, 7, 9, 7, 6, 6, 9, 7, 6, 6, 9,13,10,10,11,
+ 10, 9, 8,10, 9, 8, 8,10, 8, 8, 7, 9,13,12,10,11,
+ 17,14,14,13,15,14,12,13,17,13,12,15,17,17,14,17,
+ 7, 6, 6, 7, 6, 6, 5, 7, 6, 6, 6, 6,11, 9, 9, 9,
+ 7, 7, 6, 7, 7, 6, 6, 7, 6, 6, 6, 6,10, 9, 8, 9,
+ 10, 9, 8, 8, 9, 8, 7, 8, 8, 7, 6, 8,11,10, 9,10,
+ 17,17,12,15,15,15,12,14,14,14,10,12,15,13,12,13,
+ 11,10, 8,10,11,10, 8, 8,10, 9, 7, 7,10, 9, 9,11,
+ 11,11, 9,10,11,10, 8, 9,10, 8, 6, 8,10, 9, 9,11,
+ 14,13,10,12,12,11,10,10, 8, 7, 8,10,10,11,11,12,
+ 17,17,15,17,17,17,17,17,17,13,12,17,17,17,14,17,
+};
+
+static const static_codebook _huff_book_line_128x4_class0 = {
+ 1, 256,
+ (long *)_huff_lengthlist_line_128x4_class0,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x4_0sub0[] = {
+ 2, 2, 2, 2,
+};
+
+static const static_codebook _huff_book_line_128x4_0sub0 = {
+ 1, 4,
+ (long *)_huff_lengthlist_line_128x4_0sub0,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x4_0sub1[] = {
+ 0, 0, 0, 0, 3, 2, 3, 2, 3, 3,
+};
+
+static const static_codebook _huff_book_line_128x4_0sub1 = {
+ 1, 10,
+ (long *)_huff_lengthlist_line_128x4_0sub1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x4_0sub2[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 4, 3, 4, 3,
+ 4, 4, 5, 4, 5, 4, 6, 5, 6,
+};
+
+static const static_codebook _huff_book_line_128x4_0sub2 = {
+ 1, 25,
+ (long *)_huff_lengthlist_line_128x4_0sub2,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x4_0sub3[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 4, 3, 5, 3, 5, 3,
+ 5, 4, 6, 5, 6, 5, 7, 6, 6, 7, 7, 9, 9,11,11,16,
+ 11,14,10,11,11,13,16,15,15,15,15,15,15,15,15,15,
+};
+
+static const static_codebook _huff_book_line_128x4_0sub3 = {
+ 1, 64,
+ (long *)_huff_lengthlist_line_128x4_0sub3,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_256x4_class0[] = {
+ 6, 7, 7,12, 6, 6, 7,12, 7, 6, 6,10,15,12,11,13,
+ 7, 7, 8,13, 7, 7, 8,12, 7, 7, 7,11,12,12,11,13,
+ 10, 9, 9,11, 9, 9, 9,10,10, 8, 8,12,14,12,12,14,
+ 11,11,12,14,11,12,11,15,15,12,13,15,15,15,15,15,
+ 6, 6, 7,10, 6, 6, 6,11, 7, 6, 6, 9,14,12,11,13,
+ 7, 7, 7,10, 6, 6, 7, 9, 7, 7, 6,10,13,12,10,12,
+ 9, 9, 9,11, 9, 9, 8, 9, 9, 8, 8,10,13,12,10,12,
+ 12,12,11,13,12,12,11,12,15,13,12,15,15,15,14,14,
+ 6, 6, 6, 8, 6, 6, 5, 6, 7, 7, 6, 5,11,10, 9, 8,
+ 7, 6, 6, 7, 6, 6, 5, 6, 7, 7, 6, 6,11,10, 9, 8,
+ 8, 8, 8, 9, 8, 8, 7, 8, 8, 8, 6, 7,11,10, 9, 9,
+ 14,11,10,14,14,11,10,15,13,11, 9,11,15,12,12,11,
+ 11, 9, 8, 8,10, 9, 8, 9,11,10, 9, 8,12,11,12,11,
+ 13,10, 8, 9,11,10, 8, 9,10, 9, 8, 9,10, 8,12,12,
+ 15,11,10,10,13,11,10,10, 8, 8, 7,12,10, 9,11,12,
+ 15,12,11,15,13,11,11,15,12,14,11,13,15,15,13,13,
+};
+
+static const static_codebook _huff_book_line_256x4_class0 = {
+ 1, 256,
+ (long *)_huff_lengthlist_line_256x4_class0,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_256x4_0sub0[] = {
+ 2, 2, 2, 2,
+};
+
+static const static_codebook _huff_book_line_256x4_0sub0 = {
+ 1, 4,
+ (long *)_huff_lengthlist_line_256x4_0sub0,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_256x4_0sub1[] = {
+ 0, 0, 0, 0, 2, 2, 3, 3, 3, 3,
+};
+
+static const static_codebook _huff_book_line_256x4_0sub1 = {
+ 1, 10,
+ (long *)_huff_lengthlist_line_256x4_0sub1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_256x4_0sub2[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 3, 4, 3, 4, 3,
+ 5, 3, 5, 4, 5, 4, 6, 4, 6,
+};
+
+static const static_codebook _huff_book_line_256x4_0sub2 = {
+ 1, 25,
+ (long *)_huff_lengthlist_line_256x4_0sub2,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_256x4_0sub3[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 4, 3, 5, 3, 5, 3,
+ 6, 4, 7, 4, 7, 5, 7, 6, 7, 6, 7, 8,10,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,12,12,12,12,12,
+};
+
+static const static_codebook _huff_book_line_256x4_0sub3 = {
+ 1, 64,
+ (long *)_huff_lengthlist_line_256x4_0sub3,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x7_class0[] = {
+ 10, 7, 8,13, 9, 6, 7,11,10, 8, 8,12,17,17,17,17,
+ 7, 5, 5, 9, 6, 4, 4, 8, 8, 5, 5, 8,16,14,13,16,
+ 7, 5, 5, 7, 6, 3, 3, 5, 8, 5, 4, 7,14,12,12,15,
+ 10, 7, 8, 9, 7, 5, 5, 6, 9, 6, 5, 5,15,12, 9,10,
+};
+
+static const static_codebook _huff_book_line_128x7_class0 = {
+ 1, 64,
+ (long *)_huff_lengthlist_line_128x7_class0,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x7_class1[] = {
+ 8,13,17,17, 8,11,17,17,11,13,17,17,17,17,17,17,
+ 6,10,16,17, 6,10,15,17, 8,10,16,17,17,17,17,17,
+ 9,13,15,17, 8,11,17,17,10,12,17,17,17,17,17,17,
+ 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
+ 6,11,15,17, 7,10,15,17, 8,10,17,17,17,15,17,17,
+ 4, 8,13,17, 4, 7,13,17, 6, 8,15,17,16,15,17,17,
+ 6,11,15,17, 6, 9,13,17, 8,10,17,17,15,17,17,17,
+ 16,17,17,17,12,14,15,17,13,14,15,17,17,17,17,17,
+ 5,10,14,17, 5, 9,14,17, 7, 9,15,17,15,15,17,17,
+ 3, 7,12,17, 3, 6,11,17, 5, 7,13,17,12,12,17,17,
+ 5, 9,14,17, 3, 7,11,17, 5, 8,13,17,13,11,16,17,
+ 12,17,17,17, 9,14,15,17,10,11,14,17,16,14,17,17,
+ 8,12,17,17, 8,12,17,17,10,12,17,17,17,17,17,17,
+ 5,10,17,17, 5, 9,15,17, 7, 9,17,17,13,13,17,17,
+ 7,11,17,17, 6,10,15,17, 7, 9,15,17,12,11,17,17,
+ 12,15,17,17,11,14,17,17,11,10,15,17,17,16,17,17,
+};
+
+static const static_codebook _huff_book_line_128x7_class1 = {
+ 1, 256,
+ (long *)_huff_lengthlist_line_128x7_class1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x7_0sub1[] = {
+ 0, 3, 3, 3, 3, 3, 3, 3, 3,
+};
+
+static const static_codebook _huff_book_line_128x7_0sub1 = {
+ 1, 9,
+ (long *)_huff_lengthlist_line_128x7_0sub1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x7_0sub2[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 4, 4, 4, 4,
+ 5, 4, 5, 4, 5, 4, 6, 4, 6,
+};
+
+static const static_codebook _huff_book_line_128x7_0sub2 = {
+ 1, 25,
+ (long *)_huff_lengthlist_line_128x7_0sub2,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x7_0sub3[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 5, 3, 5, 3, 5, 4,
+ 5, 4, 5, 5, 5, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5,
+ 7, 8, 9,11,13,13,13,13,13,13,13,13,13,13,13,13,
+};
+
+static const static_codebook _huff_book_line_128x7_0sub3 = {
+ 1, 64,
+ (long *)_huff_lengthlist_line_128x7_0sub3,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x7_1sub1[] = {
+ 0, 3, 3, 2, 3, 3, 4, 3, 4,
+};
+
+static const static_codebook _huff_book_line_128x7_1sub1 = {
+ 1, 9,
+ (long *)_huff_lengthlist_line_128x7_1sub1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x7_1sub2[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 3, 6, 3, 6, 3,
+ 6, 3, 7, 3, 8, 4, 9, 4, 9,
+};
+
+static const static_codebook _huff_book_line_128x7_1sub2 = {
+ 1, 25,
+ (long *)_huff_lengthlist_line_128x7_1sub2,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x7_1sub3[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 7, 2, 7, 3, 8, 4,
+ 9, 5, 9, 8,10,11,11,12,14,14,14,14,14,14,14,14,
+ 14,14,14,14,14,14,14,14,14,14,14,14,13,13,13,13,
+};
+
+static const static_codebook _huff_book_line_128x7_1sub3 = {
+ 1, 64,
+ (long *)_huff_lengthlist_line_128x7_1sub3,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x11_class1[] = {
+ 1, 6, 3, 7, 2, 4, 5, 7,
+};
+
+static const static_codebook _huff_book_line_128x11_class1 = {
+ 1, 8,
+ (long *)_huff_lengthlist_line_128x11_class1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x11_class2[] = {
+ 1, 6,12,16, 4,12,15,16, 9,15,16,16,16,16,16,16,
+ 2, 5,11,16, 5,11,13,16, 9,13,16,16,16,16,16,16,
+ 4, 8,12,16, 5, 9,12,16, 9,13,15,16,16,16,16,16,
+ 15,16,16,16,11,14,13,16,12,15,16,16,16,16,16,15,
+};
+
+static const static_codebook _huff_book_line_128x11_class2 = {
+ 1, 64,
+ (long *)_huff_lengthlist_line_128x11_class2,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x11_class3[] = {
+ 7, 6, 9,17, 7, 6, 8,17,12, 9,11,16,16,16,16,16,
+ 5, 4, 7,16, 5, 3, 6,14, 9, 6, 8,15,16,16,16,16,
+ 5, 4, 6,13, 3, 2, 4,11, 7, 4, 6,13,16,11,10,14,
+ 12,12,12,16, 9, 7,10,15,12, 9,11,16,16,15,15,16,
+};
+
+static const static_codebook _huff_book_line_128x11_class3 = {
+ 1, 64,
+ (long *)_huff_lengthlist_line_128x11_class3,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x11_0sub0[] = {
+ 5, 5, 5, 5, 5, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5,
+ 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 6, 6, 6, 7, 6,
+ 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 8, 6, 8, 6, 8, 7,
+ 8, 7, 8, 7, 8, 7, 9, 7, 9, 8, 9, 8, 9, 8,10, 8,
+ 10, 9,10, 9,10, 9,11, 9,11, 9,10,10,11,10,11,10,
+ 11,11,11,11,11,11,12,13,14,14,14,15,15,16,16,16,
+ 17,15,16,15,16,16,17,17,16,17,17,17,17,17,17,17,
+ 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
+};
+
+static const static_codebook _huff_book_line_128x11_0sub0 = {
+ 1, 128,
+ (long *)_huff_lengthlist_line_128x11_0sub0,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x11_1sub0[] = {
+ 2, 5, 5, 5, 5, 5, 5, 4, 5, 5, 5, 5, 5, 5, 5, 5,
+ 6, 5, 6, 5, 6, 5, 7, 6, 7, 6, 7, 6, 8, 6, 8, 6,
+};
+
+static const static_codebook _huff_book_line_128x11_1sub0 = {
+ 1, 32,
+ (long *)_huff_lengthlist_line_128x11_1sub0,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x11_1sub1[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 5, 3, 5, 3, 6, 4, 6, 4, 7, 4, 7, 4, 7, 4, 8, 4,
+ 8, 4, 9, 5, 9, 5, 9, 5, 9, 6,10, 6,10, 6,11, 7,
+ 10, 7,10, 8,11, 9,11, 9,11,10,11,11,12,11,11,12,
+ 15,15,12,14,11,14,12,14,11,14,13,14,12,14,11,14,
+ 11,14,12,14,11,14,11,14,13,13,14,14,14,14,14,14,
+ 14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,
+};
+
+static const static_codebook _huff_book_line_128x11_1sub1 = {
+ 1, 128,
+ (long *)_huff_lengthlist_line_128x11_1sub1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x11_2sub1[] = {
+ 0, 4, 5, 4, 5, 4, 5, 3, 5, 3, 5, 3, 5, 4, 4, 4,
+ 5, 5,
+};
+
+static const static_codebook _huff_book_line_128x11_2sub1 = {
+ 1, 18,
+ (long *)_huff_lengthlist_line_128x11_2sub1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x11_2sub2[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 3, 3, 3, 4, 4, 4, 4, 5, 4, 5, 4, 6, 5, 7,
+ 5, 7, 6, 8, 6, 8, 6, 9, 7, 9, 7,10, 7, 9, 8,11,
+ 8,11,
+};
+
+static const static_codebook _huff_book_line_128x11_2sub2 = {
+ 1, 50,
+ (long *)_huff_lengthlist_line_128x11_2sub2,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x11_2sub3[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 4, 8, 3, 8, 4, 8, 4, 8, 6, 8, 5, 8, 4, 8,
+ 4, 8, 6, 8, 7, 8, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+};
+
+static const static_codebook _huff_book_line_128x11_2sub3 = {
+ 1, 128,
+ (long *)_huff_lengthlist_line_128x11_2sub3,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x11_3sub1[] = {
+ 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 4,
+ 5, 4,
+};
+
+static const static_codebook _huff_book_line_128x11_3sub1 = {
+ 1, 18,
+ (long *)_huff_lengthlist_line_128x11_3sub1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x11_3sub2[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 5, 3, 5, 4, 6, 4, 6, 4, 7, 4, 7, 4, 8, 4,
+ 8, 4, 9, 4, 9, 4,10, 4,10, 5,10, 5,11, 5,12, 6,
+ 12, 6,
+};
+
+static const static_codebook _huff_book_line_128x11_3sub2 = {
+ 1, 50,
+ (long *)_huff_lengthlist_line_128x11_3sub2,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x11_3sub3[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 7, 1, 6, 3, 7, 3, 8, 4, 8, 5, 8, 8, 8, 9,
+ 7, 8, 8, 7, 7, 7, 8, 9,10, 9, 9,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10, 9, 9,
+};
+
+static const static_codebook _huff_book_line_128x11_3sub3 = {
+ 1, 128,
+ (long *)_huff_lengthlist_line_128x11_3sub3,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x17_class1[] = {
+ 1, 3, 4, 7, 2, 5, 6, 7,
+};
+
+static const static_codebook _huff_book_line_128x17_class1 = {
+ 1, 8,
+ (long *)_huff_lengthlist_line_128x17_class1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x17_class2[] = {
+ 1, 4,10,19, 3, 8,13,19, 7,12,19,19,19,19,19,19,
+ 2, 6,11,19, 8,13,19,19, 9,11,19,19,19,19,19,19,
+ 6, 7,13,19, 9,13,19,19,10,13,18,18,18,18,18,18,
+ 18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,
+};
+
+static const static_codebook _huff_book_line_128x17_class2 = {
+ 1, 64,
+ (long *)_huff_lengthlist_line_128x17_class2,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x17_class3[] = {
+ 3, 6,10,17, 4, 8,11,20, 8,10,11,20,20,20,20,20,
+ 2, 4, 8,18, 4, 6, 8,17, 7, 8,10,20,20,17,20,20,
+ 3, 5, 8,17, 3, 4, 6,17, 8, 8,10,17,17,12,16,20,
+ 13,13,15,20,10,10,12,20,15,14,15,20,20,20,19,19,
+};
+
+static const static_codebook _huff_book_line_128x17_class3 = {
+ 1, 64,
+ (long *)_huff_lengthlist_line_128x17_class3,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x17_0sub0[] = {
+ 5, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5,
+ 7, 5, 7, 5, 7, 5, 7, 5, 7, 5, 7, 5, 8, 5, 8, 5,
+ 8, 5, 8, 5, 8, 6, 8, 6, 8, 6, 9, 6, 9, 6, 9, 6,
+ 9, 6, 9, 7, 9, 7, 9, 7, 9, 7,10, 7,10, 8,10, 8,
+ 10, 8,10, 8,10, 8,11, 8,11, 8,11, 8,11, 8,11, 9,
+ 12, 9,12, 9,12, 9,12, 9,12,10,12,10,13,11,13,11,
+ 14,12,14,13,15,14,16,14,17,15,18,16,20,20,20,20,
+ 20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,
+};
+
+static const static_codebook _huff_book_line_128x17_0sub0 = {
+ 1, 128,
+ (long *)_huff_lengthlist_line_128x17_0sub0,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x17_1sub0[] = {
+ 2, 5, 5, 4, 5, 4, 5, 4, 5, 5, 5, 5, 5, 5, 6, 5,
+ 6, 5, 6, 5, 7, 6, 7, 6, 7, 6, 8, 6, 9, 7, 9, 7,
+};
+
+static const static_codebook _huff_book_line_128x17_1sub0 = {
+ 1, 32,
+ (long *)_huff_lengthlist_line_128x17_1sub0,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x17_1sub1[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 4, 3, 5, 3, 5, 3, 6, 3, 6, 4, 6, 4, 7, 4, 7, 5,
+ 8, 5, 8, 6, 9, 7, 9, 7, 9, 8,10, 9,10, 9,11,10,
+ 11,11,11,11,11,11,12,12,12,13,12,13,12,14,12,15,
+ 12,14,12,16,13,17,13,17,14,17,14,16,13,17,14,17,
+ 14,17,15,17,15,15,16,17,17,17,17,17,17,17,17,17,
+ 17,17,17,17,17,17,16,16,16,16,16,16,16,16,16,16,
+};
+
+static const static_codebook _huff_book_line_128x17_1sub1 = {
+ 1, 128,
+ (long *)_huff_lengthlist_line_128x17_1sub1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x17_2sub1[] = {
+ 0, 4, 5, 4, 6, 4, 8, 3, 9, 3, 9, 2, 9, 3, 8, 4,
+ 9, 4,
+};
+
+static const static_codebook _huff_book_line_128x17_2sub1 = {
+ 1, 18,
+ (long *)_huff_lengthlist_line_128x17_2sub1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x17_2sub2[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 5, 1, 5, 3, 5, 3, 5, 4, 7, 5,10, 7,10, 7,
+ 12,10,14,10,14, 9,14,11,14,14,14,13,13,13,13,13,
+ 13,13,
+};
+
+static const static_codebook _huff_book_line_128x17_2sub2 = {
+ 1, 50,
+ (long *)_huff_lengthlist_line_128x17_2sub2,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x17_2sub3[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+};
+
+static const static_codebook _huff_book_line_128x17_2sub3 = {
+ 1, 128,
+ (long *)_huff_lengthlist_line_128x17_2sub3,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x17_3sub1[] = {
+ 0, 4, 4, 4, 4, 4, 4, 4, 5, 3, 5, 3, 5, 4, 6, 4,
+ 6, 4,
+};
+
+static const static_codebook _huff_book_line_128x17_3sub1 = {
+ 1, 18,
+ (long *)_huff_lengthlist_line_128x17_3sub1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x17_3sub2[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 5, 3, 6, 3, 6, 4, 7, 4, 7, 4, 7, 4, 8, 4,
+ 8, 4, 8, 4, 8, 4, 9, 4, 9, 5,10, 5,10, 7,10, 8,
+ 10, 8,
+};
+
+static const static_codebook _huff_book_line_128x17_3sub2 = {
+ 1, 50,
+ (long *)_huff_lengthlist_line_128x17_3sub2,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_128x17_3sub3[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 3, 2, 4, 3, 4, 4, 4, 5, 4, 7, 5, 8, 5,11,
+ 6,10, 6,12, 7,12, 7,12, 8,12, 8,12,10,12,12,12,
+ 12,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+};
+
+static const static_codebook _huff_book_line_128x17_3sub3 = {
+ 1, 128,
+ (long *)_huff_lengthlist_line_128x17_3sub3,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_1024x27_class1[] = {
+ 2,10, 8,14, 7,12,11,14, 1, 5, 3, 7, 4, 9, 7,13,
+};
+
+static const static_codebook _huff_book_line_1024x27_class1 = {
+ 1, 16,
+ (long *)_huff_lengthlist_line_1024x27_class1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_1024x27_class2[] = {
+ 1, 4, 2, 6, 3, 7, 5, 7,
+};
+
+static const static_codebook _huff_book_line_1024x27_class2 = {
+ 1, 8,
+ (long *)_huff_lengthlist_line_1024x27_class2,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_1024x27_class3[] = {
+ 1, 5, 7,21, 5, 8, 9,21,10, 9,12,20,20,16,20,20,
+ 4, 8, 9,20, 6, 8, 9,20,11,11,13,20,20,15,17,20,
+ 9,11,14,20, 8,10,15,20,11,13,15,20,20,20,20,20,
+ 20,20,20,20,13,20,20,20,18,18,20,20,20,20,20,20,
+ 3, 6, 8,20, 6, 7, 9,20,10, 9,12,20,20,20,20,20,
+ 5, 7, 9,20, 6, 6, 9,20,10, 9,12,20,20,20,20,20,
+ 8,10,13,20, 8, 9,12,20,11,10,12,20,20,20,20,20,
+ 18,20,20,20,15,17,18,20,18,17,18,20,20,20,20,20,
+ 7,10,12,20, 8, 9,11,20,14,13,14,20,20,20,20,20,
+ 6, 9,12,20, 7, 8,11,20,12,11,13,20,20,20,20,20,
+ 9,11,15,20, 8,10,14,20,12,11,14,20,20,20,20,20,
+ 20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,
+ 11,16,18,20,15,15,17,20,20,17,20,20,20,20,20,20,
+ 9,14,16,20,12,12,15,20,17,15,18,20,20,20,20,20,
+ 16,19,18,20,15,16,20,20,17,17,20,20,20,20,20,20,
+ 20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,
+};
+
+static const static_codebook _huff_book_line_1024x27_class3 = {
+ 1, 256,
+ (long *)_huff_lengthlist_line_1024x27_class3,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_1024x27_class4[] = {
+ 2, 3, 7,13, 4, 4, 7,15, 8, 6, 9,17,21,16,15,21,
+ 2, 5, 7,11, 5, 5, 7,14, 9, 7,10,16,17,15,16,21,
+ 4, 7,10,17, 7, 7, 9,15,11, 9,11,16,21,18,15,21,
+ 18,21,21,21,15,17,17,19,21,19,18,20,21,21,21,20,
+};
+
+static const static_codebook _huff_book_line_1024x27_class4 = {
+ 1, 64,
+ (long *)_huff_lengthlist_line_1024x27_class4,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_1024x27_0sub0[] = {
+ 5, 5, 5, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5,
+ 6, 5, 6, 5, 6, 5, 6, 5, 7, 5, 7, 5, 7, 5, 7, 5,
+ 8, 6, 8, 6, 8, 6, 9, 6, 9, 6,10, 6,10, 6,11, 6,
+ 11, 7,11, 7,12, 7,12, 7,12, 7,12, 7,12, 7,12, 7,
+ 12, 7,12, 8,13, 8,12, 8,12, 8,13, 8,13, 9,13, 9,
+ 13, 9,13, 9,12,10,12,10,13,10,14,11,14,12,14,13,
+ 14,13,14,14,15,16,15,15,15,14,15,17,21,22,22,21,
+ 22,22,22,22,22,22,21,21,21,21,21,21,21,21,21,21,
+};
+
+static const static_codebook _huff_book_line_1024x27_0sub0 = {
+ 1, 128,
+ (long *)_huff_lengthlist_line_1024x27_0sub0,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_1024x27_1sub0[] = {
+ 2, 5, 5, 4, 5, 4, 5, 4, 5, 4, 6, 5, 6, 5, 6, 5,
+ 6, 5, 7, 5, 7, 6, 8, 6, 8, 6, 8, 6, 9, 6, 9, 6,
+};
+
+static const static_codebook _huff_book_line_1024x27_1sub0 = {
+ 1, 32,
+ (long *)_huff_lengthlist_line_1024x27_1sub0,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_1024x27_1sub1[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 8, 5, 8, 4, 9, 4, 9, 4, 9, 4, 9, 4, 9, 4, 9, 4,
+ 9, 4, 9, 4, 9, 4, 8, 4, 8, 4, 9, 5, 9, 5, 9, 5,
+ 9, 5, 9, 6,10, 6,10, 7,10, 8,11, 9,11,11,12,13,
+ 12,14,13,15,13,15,14,16,14,17,15,17,15,15,16,16,
+ 15,16,16,16,15,18,16,15,17,17,19,19,19,19,19,19,
+ 19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
+};
+
+static const static_codebook _huff_book_line_1024x27_1sub1 = {
+ 1, 128,
+ (long *)_huff_lengthlist_line_1024x27_1sub1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_1024x27_2sub0[] = {
+ 1, 5, 5, 5, 5, 5, 5, 5, 6, 5, 6, 5, 6, 5, 6, 5,
+ 6, 6, 7, 7, 7, 7, 8, 7, 8, 8, 9, 8,10, 9,10, 9,
+};
+
+static const static_codebook _huff_book_line_1024x27_2sub0 = {
+ 1, 32,
+ (long *)_huff_lengthlist_line_1024x27_2sub0,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_1024x27_2sub1[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 4, 3, 4, 3, 4, 4, 5, 4, 5, 4, 5, 5, 6, 5, 6, 5,
+ 7, 5, 7, 6, 7, 6, 8, 7, 8, 7, 8, 7, 9, 8, 9, 9,
+ 9, 9,10,10,10,11, 9,12, 9,12, 9,15,10,14, 9,13,
+ 10,13,10,12,10,12,10,13,10,12,11,13,11,14,12,13,
+ 13,14,14,13,14,15,14,16,13,13,14,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,15,15,
+};
+
+static const static_codebook _huff_book_line_1024x27_2sub1 = {
+ 1, 128,
+ (long *)_huff_lengthlist_line_1024x27_2sub1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_1024x27_3sub1[] = {
+ 0, 4, 5, 4, 5, 3, 5, 3, 5, 3, 5, 4, 4, 4, 4, 5,
+ 5, 5,
+};
+
+static const static_codebook _huff_book_line_1024x27_3sub1 = {
+ 1, 18,
+ (long *)_huff_lengthlist_line_1024x27_3sub1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_1024x27_3sub2[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 3, 3, 4, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6,
+ 5, 7, 5, 8, 6, 8, 6, 9, 7,10, 7,10, 8,10, 8,11,
+ 9,11,
+};
+
+static const static_codebook _huff_book_line_1024x27_3sub2 = {
+ 1, 50,
+ (long *)_huff_lengthlist_line_1024x27_3sub2,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_1024x27_3sub3[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 3, 7, 3, 8, 3,10, 3, 8, 3, 9, 3, 8, 4, 9,
+ 4, 9, 5, 9, 6,10, 6, 9, 7,11, 7,12, 9,13,10,13,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+};
+
+static const static_codebook _huff_book_line_1024x27_3sub3 = {
+ 1, 128,
+ (long *)_huff_lengthlist_line_1024x27_3sub3,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_1024x27_4sub1[] = {
+ 0, 4, 5, 4, 5, 4, 5, 4, 5, 3, 5, 3, 5, 3, 5, 4,
+ 5, 4,
+};
+
+static const static_codebook _huff_book_line_1024x27_4sub1 = {
+ 1, 18,
+ (long *)_huff_lengthlist_line_1024x27_4sub1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_1024x27_4sub2[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 4, 2, 4, 2, 5, 3, 5, 4, 6, 6, 6, 7, 7, 8,
+ 7, 8, 7, 8, 7, 9, 8, 9, 8, 9, 8,10, 8,11, 9,12,
+ 9,12,
+};
+
+static const static_codebook _huff_book_line_1024x27_4sub2 = {
+ 1, 50,
+ (long *)_huff_lengthlist_line_1024x27_4sub2,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_1024x27_4sub3[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 2, 5, 2, 6, 3, 6, 4, 7, 4, 7, 5, 9, 5,11,
+ 6,11, 6,11, 7,11, 6,11, 6,11, 9,11, 8,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,10,10,10,10,10,10,
+};
+
+static const static_codebook _huff_book_line_1024x27_4sub3 = {
+ 1, 128,
+ (long *)_huff_lengthlist_line_1024x27_4sub3,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_2048x27_class1[] = {
+ 2, 6, 8, 9, 7,11,13,13, 1, 3, 5, 5, 6, 6,12,10,
+};
+
+static const static_codebook _huff_book_line_2048x27_class1 = {
+ 1, 16,
+ (long *)_huff_lengthlist_line_2048x27_class1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_2048x27_class2[] = {
+ 1, 2, 3, 6, 4, 7, 5, 7,
+};
+
+static const static_codebook _huff_book_line_2048x27_class2 = {
+ 1, 8,
+ (long *)_huff_lengthlist_line_2048x27_class2,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_2048x27_class3[] = {
+ 3, 3, 6,16, 5, 5, 7,16, 9, 8,11,16,16,16,16,16,
+ 5, 5, 8,16, 5, 5, 7,16, 8, 7, 9,16,16,16,16,16,
+ 9, 9,12,16, 6, 8,11,16, 9,10,11,16,16,16,16,16,
+ 16,16,16,16,13,16,16,16,15,16,16,16,16,16,16,16,
+ 5, 4, 7,16, 6, 5, 8,16, 9, 8,10,16,16,16,16,16,
+ 5, 5, 7,15, 5, 4, 6,15, 7, 6, 8,16,16,16,16,16,
+ 9, 9,11,15, 7, 7, 9,16, 8, 8, 9,16,16,16,16,16,
+ 16,16,16,16,15,15,15,16,15,15,14,16,16,16,16,16,
+ 8, 8,11,16, 8, 9,10,16,11,10,14,16,16,16,16,16,
+ 6, 8,10,16, 6, 7,10,16, 8, 8,11,16,14,16,16,16,
+ 10,11,14,16, 9, 9,11,16,10,10,11,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,15,16,16,16,16,16,16,16,16,16,16,16,
+ 12,16,15,16,12,14,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+};
+
+static const static_codebook _huff_book_line_2048x27_class3 = {
+ 1, 256,
+ (long *)_huff_lengthlist_line_2048x27_class3,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_2048x27_class4[] = {
+ 2, 4, 7,13, 4, 5, 7,15, 8, 7,10,16,16,14,16,16,
+ 2, 4, 7,16, 3, 4, 7,14, 8, 8,10,16,16,16,15,16,
+ 6, 8,11,16, 7, 7, 9,16,11, 9,13,16,16,16,15,16,
+ 16,16,16,16,14,16,16,16,16,16,16,16,16,16,16,16,
+};
+
+static const static_codebook _huff_book_line_2048x27_class4 = {
+ 1, 64,
+ (long *)_huff_lengthlist_line_2048x27_class4,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_2048x27_0sub0[] = {
+ 5, 5, 5, 5, 5, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5,
+ 6, 5, 7, 5, 7, 5, 7, 5, 8, 5, 8, 5, 8, 5, 9, 5,
+ 9, 6,10, 6,10, 6,11, 6,11, 6,11, 6,11, 6,11, 6,
+ 11, 6,11, 6,12, 7,11, 7,11, 7,11, 7,11, 7,10, 7,
+ 11, 7,11, 7,12, 7,11, 8,11, 8,11, 8,11, 8,13, 8,
+ 12, 9,11, 9,11, 9,11,10,12,10,12, 9,12,10,12,11,
+ 14,12,16,12,12,11,14,16,17,17,17,17,17,17,17,17,
+ 17,17,17,17,17,17,17,17,17,17,17,17,16,16,16,16,
+};
+
+static const static_codebook _huff_book_line_2048x27_0sub0 = {
+ 1, 128,
+ (long *)_huff_lengthlist_line_2048x27_0sub0,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_2048x27_1sub0[] = {
+ 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 6, 6, 6, 6, 6, 6, 7, 6, 7, 6, 7, 6, 7, 6,
+};
+
+static const static_codebook _huff_book_line_2048x27_1sub0 = {
+ 1, 32,
+ (long *)_huff_lengthlist_line_2048x27_1sub0,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_2048x27_1sub1[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 6, 5, 7, 5, 7, 4, 7, 4, 8, 4, 8, 4, 8, 4, 8, 3,
+ 8, 4, 9, 4, 9, 4, 9, 4, 9, 4, 9, 5, 9, 5, 9, 6,
+ 9, 7, 9, 8, 9, 9, 9,10, 9,11, 9,14, 9,15,10,15,
+ 10,15,10,15,10,15,11,15,10,14,12,14,11,14,13,14,
+ 13,15,15,15,12,15,15,15,13,15,13,15,13,15,15,15,
+ 15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,14,
+};
+
+static const static_codebook _huff_book_line_2048x27_1sub1 = {
+ 1, 128,
+ (long *)_huff_lengthlist_line_2048x27_1sub1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_2048x27_2sub0[] = {
+ 2, 4, 5, 4, 5, 4, 5, 4, 5, 5, 5, 5, 5, 5, 6, 5,
+ 6, 5, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8,
+};
+
+static const static_codebook _huff_book_line_2048x27_2sub0 = {
+ 1, 32,
+ (long *)_huff_lengthlist_line_2048x27_2sub0,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_2048x27_2sub1[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 3, 4, 3, 4, 3, 4, 4, 5, 4, 5, 5, 5, 6, 6, 6, 7,
+ 6, 8, 6, 8, 6, 9, 7,10, 7,10, 7,10, 7,12, 7,12,
+ 7,12, 9,12,11,12,10,12,10,12,11,12,12,12,10,12,
+ 10,12,10,12, 9,12,11,12,12,12,12,12,11,12,11,12,
+ 12,12,12,12,12,12,12,12,10,10,12,12,12,12,12,10,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+};
+
+static const static_codebook _huff_book_line_2048x27_2sub1 = {
+ 1, 128,
+ (long *)_huff_lengthlist_line_2048x27_2sub1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_2048x27_3sub1[] = {
+ 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 5, 5,
+};
+
+static const static_codebook _huff_book_line_2048x27_3sub1 = {
+ 1, 18,
+ (long *)_huff_lengthlist_line_2048x27_3sub1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_2048x27_3sub2[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6,
+ 6, 7, 6, 7, 6, 8, 6, 9, 7, 9, 7, 9, 9,11, 9,12,
+ 10,12,
+};
+
+static const static_codebook _huff_book_line_2048x27_3sub2 = {
+ 1, 50,
+ (long *)_huff_lengthlist_line_2048x27_3sub2,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_2048x27_3sub3[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 3, 6, 3, 7, 3, 7, 5, 7, 7, 7, 7, 7, 6, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+};
+
+static const static_codebook _huff_book_line_2048x27_3sub3 = {
+ 1, 128,
+ (long *)_huff_lengthlist_line_2048x27_3sub3,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_2048x27_4sub1[] = {
+ 0, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5, 4, 5, 4, 5, 4,
+ 4, 5,
+};
+
+static const static_codebook _huff_book_line_2048x27_4sub1 = {
+ 1, 18,
+ (long *)_huff_lengthlist_line_2048x27_4sub1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_2048x27_4sub2[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 3, 2, 4, 3, 4, 4, 4, 5, 5, 6, 5, 6, 5, 7,
+ 6, 6, 6, 7, 7, 7, 8, 9, 9, 9,12,10,11,10,10,12,
+ 10,10,
+};
+
+static const static_codebook _huff_book_line_2048x27_4sub2 = {
+ 1, 50,
+ (long *)_huff_lengthlist_line_2048x27_4sub2,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_2048x27_4sub3[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 3, 6, 5, 7, 5, 7, 7, 7, 7, 7, 5, 7, 5, 7,
+ 5, 7, 5, 7, 7, 7, 7, 7, 4, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+};
+
+static const static_codebook _huff_book_line_2048x27_4sub3 = {
+ 1, 128,
+ (long *)_huff_lengthlist_line_2048x27_4sub3,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_256x4low_class0[] = {
+ 4, 5, 6,11, 5, 5, 6,10, 7, 7, 6, 6,14,13, 9, 9,
+ 6, 6, 6,10, 6, 6, 6, 9, 8, 7, 7, 9,14,12, 8,11,
+ 8, 7, 7,11, 8, 8, 7,11, 9, 9, 7, 9,13,11, 9,13,
+ 19,19,18,19,15,16,16,19,11,11,10,13,10,10, 9,15,
+ 5, 5, 6,13, 6, 6, 6,11, 8, 7, 6, 7,14,11,10,11,
+ 6, 6, 6,12, 7, 6, 6,11, 8, 7, 7,11,13,11, 9,11,
+ 9, 7, 6,12, 8, 7, 6,12, 9, 8, 8,11,13,10, 7,13,
+ 19,19,17,19,17,14,14,19,12,10, 8,12,13,10, 9,16,
+ 7, 8, 7,12, 7, 7, 7,11, 8, 7, 7, 8,12,12,11,11,
+ 8, 8, 7,12, 8, 7, 6,11, 8, 7, 7,10,10,11,10,11,
+ 9, 8, 8,13, 9, 8, 7,12,10, 9, 7,11, 9, 8, 7,11,
+ 18,18,15,18,18,16,17,18,15,11,10,18,11, 9, 9,18,
+ 16,16,13,16,12,11,10,16,12,11, 9, 6,15,12,11,13,
+ 16,16,14,14,13,11,12,16,12, 9, 9,13,13,10,10,12,
+ 17,18,17,17,14,15,14,16,14,12,14,15,12,10,11,12,
+ 18,18,18,18,18,18,18,18,18,12,13,18,16,11, 9,18,
+};
+
+static const static_codebook _huff_book_line_256x4low_class0 = {
+ 1, 256,
+ (long *)_huff_lengthlist_line_256x4low_class0,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_256x4low_0sub0[] = {
+ 1, 3, 2, 3,
+};
+
+static const static_codebook _huff_book_line_256x4low_0sub0 = {
+ 1, 4,
+ (long *)_huff_lengthlist_line_256x4low_0sub0,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_256x4low_0sub1[] = {
+ 0, 0, 0, 0, 2, 3, 2, 3, 3, 3,
+};
+
+static const static_codebook _huff_book_line_256x4low_0sub1 = {
+ 1, 10,
+ (long *)_huff_lengthlist_line_256x4low_0sub1,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_256x4low_0sub2[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 4, 3, 4,
+ 4, 4, 4, 4, 5, 5, 5, 6, 6,
+};
+
+static const static_codebook _huff_book_line_256x4low_0sub2 = {
+ 1, 25,
+ (long *)_huff_lengthlist_line_256x4low_0sub2,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist_line_256x4low_0sub3[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 2, 4, 3, 5, 4,
+ 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 8, 6, 9,
+ 7,12,11,16,13,16,12,15,13,15,12,14,12,15,15,15,
+};
+
+static const static_codebook _huff_book_line_256x4low_0sub3 = {
+ 1, 64,
+ (long *)_huff_lengthlist_line_256x4low_0sub3,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2007 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: static codebooks autogenerated by huff/huffbuld
+ last modified: $Id: res_books_uncoupled.h 17022 2010-03-25 03:45:42Z xiphmont $
+
+ ********************************************************************/
+
+#include "codebook.h"
+
+static const long _vq_quantlist__16u0__p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__16u0__p1_0[] = {
+ 1, 4, 4, 5, 7, 7, 5, 7, 8, 5, 8, 8, 8,10,10, 8,
+ 10,11, 5, 8, 8, 8,10,10, 8,10,10, 4, 9, 9, 9,12,
+ 11, 8,11,11, 8,12,11,10,12,14,10,13,13, 7,11,11,
+ 10,14,12,11,14,14, 4, 9, 9, 8,11,11, 9,11,12, 7,
+ 11,11,10,13,14,10,12,14, 8,11,12,10,14,14,10,13,
+ 12,
+};
+
+static const static_codebook _16u0__p1_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__16u0__p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__16u0__p1_0,
+ 0
+};
+
+static const long _vq_quantlist__16u0__p2_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__16u0__p2_0[] = {
+ 2, 4, 4, 5, 6, 6, 5, 6, 6, 5, 7, 7, 7, 8, 9, 7,
+ 8, 9, 5, 7, 7, 7, 9, 8, 7, 9, 7, 4, 7, 7, 7, 9,
+ 9, 7, 8, 8, 6, 9, 8, 7, 8,11, 9,11,10, 6, 8, 9,
+ 8,11, 8, 9,10,11, 4, 7, 7, 7, 8, 8, 7, 9, 9, 6,
+ 9, 8, 9,11,10, 8, 8,11, 6, 8, 9, 9,10,11, 8,11,
+ 8,
+};
+
+static const static_codebook _16u0__p2_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__16u0__p2_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__16u0__p2_0,
+ 0
+};
+
+static const long _vq_quantlist__16u0__p3_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__16u0__p3_0[] = {
+ 1, 5, 5, 7, 7, 6, 7, 7, 8, 8, 6, 7, 8, 8, 8, 8,
+ 9, 9,11,11, 8, 9, 9,11,11, 6, 9, 8,10,10, 8,10,
+ 10,11,11, 8,10,10,11,11,10,11,10,13,12, 9,11,10,
+ 13,13, 6, 8, 9,10,10, 8,10,10,11,11, 8,10,10,11,
+ 11, 9,10,11,13,12,10,10,11,12,12, 8,11,11,14,13,
+ 10,12,11,15,13, 9,12,11,15,14,12,14,13,16,14,12,
+ 13,13,17,14, 8,11,11,13,14, 9,11,12,14,15,10,11,
+ 12,13,15,11,13,13,14,16,12,13,14,14,16, 5, 9, 9,
+ 11,11, 9,11,11,12,12, 8,11,11,12,12,11,12,12,15,
+ 14,10,12,12,15,15, 8,11,11,13,12,10,12,12,13,13,
+ 10,12,12,14,13,12,12,13,14,15,11,13,13,17,16, 7,
+ 11,11,13,13,10,12,12,14,13,10,12,12,13,14,12,13,
+ 12,15,14,11,13,13,15,14, 9,12,12,16,15,11,13,13,
+ 17,16,10,13,13,16,16,13,14,15,15,16,13,15,14,19,
+ 17, 9,12,12,14,16,11,13,13,15,16,10,13,13,17,16,
+ 13,14,13,17,15,12,15,15,16,17, 5, 9, 9,11,11, 8,
+ 11,11,13,12, 9,11,11,12,12,10,12,12,14,15,11,12,
+ 12,14,14, 7,11,10,13,12,10,12,12,14,13,10,11,12,
+ 13,13,11,13,13,15,16,12,12,13,15,15, 7,11,11,13,
+ 13,10,13,13,14,14,10,12,12,13,13,11,13,13,16,15,
+ 12,13,13,15,14, 9,12,12,15,15,10,13,13,17,16,11,
+ 12,13,15,15,12,15,14,18,18,13,14,14,16,17, 9,12,
+ 12,15,16,10,13,13,15,16,11,13,13,15,16,13,15,15,
+ 17,17,13,15,14,16,15, 7,11,11,15,16,10,13,12,16,
+ 17,10,12,13,15,17,15,16,16,18,17,13,15,15,17,18,
+ 8,12,12,16,16,11,13,14,17,18,11,13,13,18,16,15,
+ 17,16,17,19,14,15,15,17,16, 8,12,12,16,15,11,14,
+ 13,18,17,11,13,14,18,17,15,16,16,18,17,13,16,16,
+ 18,18,11,15,14,18,17,13,14,15,18, 0,12,15,15, 0,
+ 17,17,16,17,17,18,14,16,18,18, 0,11,14,14,17, 0,
+ 12,15,14,17,19,12,15,14,18, 0,15,18,16, 0,17,14,
+ 18,16,18, 0, 7,11,11,16,15,10,12,12,18,16,10,13,
+ 13,16,15,13,15,14,17,17,14,16,16,19,18, 8,12,12,
+ 16,16,11,13,13,18,16,11,13,14,17,16,14,15,15,19,
+ 18,15,16,16, 0,19, 8,12,12,16,17,11,13,13,17,17,
+ 11,14,13,17,17,13,15,15,17,19,15,17,17,19, 0,11,
+ 14,15,19,17,12,15,16,18,18,12,14,15,19,17,14,16,
+ 17, 0,18,16,16,19,17, 0,11,14,14,18,19,12,15,14,
+ 17,17,13,16,14,17,16,14,17,16,18,18,15,18,15, 0,
+ 18,
+};
+
+static const static_codebook _16u0__p3_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__16u0__p3_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__16u0__p3_0,
+ 0
+};
+
+static const long _vq_quantlist__16u0__p4_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__16u0__p4_0[] = {
+ 3, 5, 5, 8, 8, 6, 6, 6, 9, 9, 6, 6, 6, 9, 9, 9,
+ 10, 9,11,11, 9, 9, 9,11,11, 6, 7, 7,10,10, 7, 7,
+ 8,10,10, 7, 7, 8,10,10,10,10,10,11,12, 9,10,10,
+ 11,12, 6, 7, 7,10,10, 7, 8, 7,10,10, 7, 8, 7,10,
+ 10,10,11,10,12,11,10,10,10,13,10, 9,10,10,12,12,
+ 10,11,10,14,12, 9,11,11,13,13,11,12,13,13,13,11,
+ 12,12,15,13, 9,10,10,12,13, 9,11,10,12,13,10,10,
+ 11,12,13,11,12,12,12,13,11,12,12,13,13, 5, 7, 7,
+ 10,10, 7, 8, 8,10,10, 7, 8, 8,10,10,10,11,10,12,
+ 13,10,10,11,12,12, 6, 8, 8,11,10, 7, 8, 9,10,12,
+ 8, 9, 9,11,11,11,10,11,11,12,10,11,11,13,12, 7,
+ 8, 8,10,11, 8, 9, 8,11,10, 8, 9, 9,11,11,10,12,
+ 10,13,11,10,11,11,13,13,10,11,10,14,13,10,10,11,
+ 13,13,10,12,11,14,13,12,11,13,12,13,13,12,13,14,
+ 14,10,11,11,13,13,10,11,10,12,13,10,12,12,12,14,
+ 12,12,12,14,12,12,13,12,17,15, 5, 7, 7,10,10, 7,
+ 8, 8,10,10, 7, 8, 8,11,10,10,10,11,12,12,10,11,
+ 11,12,13, 6, 8, 8,11,10, 8, 9, 9,11,11, 7, 8, 9,
+ 10,11,11,11,11,12,12,10,10,11,12,13, 6, 8, 8,10,
+ 11, 8, 9, 9,11,11, 7, 9, 7,11,10,10,12,12,13,13,
+ 11,11,10,13,11, 9,11,10,14,13,11,11,11,15,13,10,
+ 10,11,13,13,12,13,13,14,14,12,11,12,12,13,10,11,
+ 11,12,13,10,11,12,13,13,10,11,10,13,12,12,12,13,
+ 14, 0,12,13,11,13,11, 8,10,10,13,13,10,11,11,14,
+ 13,10,11,11,13,12,13,14,14,14,15,12,12,12,15,14,
+ 9,11,10,13,12,10,10,11,13,14,11,11,11,15,12,13,
+ 12,14,15,16,13,13,13,14,13, 9,11,11,12,12,10,12,
+ 11,13,13,10,11,11,13,14,13,13,13,15,15,13,13,14,
+ 17,15,11,12,12,14,14,10,11,12,13,15,12,13,13, 0,
+ 15,13,11,14,12,16,14,16,14, 0,15,11,12,12,14,16,
+ 11,13,12,16,15,12,13,13,14,15,12,14,12,15,13,15,
+ 14,14,16,16, 8,10,10,13,13,10,11,10,13,14,10,11,
+ 11,13,13,13,13,12,14,14,14,13,13,16,17, 9,10,10,
+ 12,14,10,12,11,14,13,10,11,12,13,14,12,12,12,15,
+ 15,13,13,13,14,14, 9,10,10,13,13,10,11,12,12,14,
+ 10,11,10,13,13,13,13,13,14,16,13,13,13,14,14,11,
+ 12,13,15,13,12,14,13,14,16,12,12,13,13,14,13,14,
+ 14,17,15,13,12,17,13,16,11,12,13,14,15,12,13,14,
+ 14,17,11,12,11,14,14,13,16,14,16, 0,14,15,11,15,
+ 11,
+};
+
+static const static_codebook _16u0__p4_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__16u0__p4_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__16u0__p4_0,
+ 0
+};
+
+static const long _vq_quantlist__16u0__p5_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__16u0__p5_0[] = {
+ 1, 4, 4, 7, 7, 7, 7, 9, 9, 4, 6, 6, 8, 8, 8, 8,
+ 9, 9, 4, 6, 6, 8, 8, 8, 8, 9, 9, 7, 8, 8, 9, 9,
+ 9, 9,11,10, 7, 8, 8, 9, 9, 9, 9,10,11, 7, 8, 8,
+ 9, 9,10,10,11,11, 7, 8, 8, 9, 9,10,10,11,11, 9,
+ 9, 9,10,10,11,11,12,12, 9, 9, 9,10,10,11,11,12,
+ 12,
+};
+
+static const static_codebook _16u0__p5_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__16u0__p5_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__16u0__p5_0,
+ 0
+};
+
+static const long _vq_quantlist__16u0__p6_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__16u0__p6_0[] = {
+ 1, 4, 4, 7, 7,10,10,12,12,13,13,18,17, 3, 6, 6,
+ 9, 9,11,11,13,13,14,14,18,17, 3, 6, 6, 9, 9,11,
+ 11,13,13,14,14,17,18, 7, 9, 9,11,11,13,13,14,14,
+ 15,15, 0, 0, 7, 9, 9,11,11,13,13,14,14,15,16,19,
+ 18,10,11,11,13,13,14,14,16,15,17,18, 0, 0,10,11,
+ 11,13,13,14,14,15,15,16,18, 0, 0,11,13,13,14,14,
+ 15,15,17,17, 0,19, 0, 0,11,13,13,14,14,14,15,16,
+ 18, 0,19, 0, 0,13,14,14,15,15,18,17,18,18, 0,19,
+ 0, 0,13,14,14,15,16,16,16,18,18,19, 0, 0, 0,16,
+ 17,17, 0,17,19,19, 0,19, 0, 0, 0, 0,16,19,16,17,
+ 18, 0,19, 0, 0, 0, 0, 0, 0,
+};
+
+static const static_codebook _16u0__p6_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__16u0__p6_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__16u0__p6_0,
+ 0
+};
+
+static const long _vq_quantlist__16u0__p6_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__16u0__p6_1[] = {
+ 1, 4, 5, 6, 6, 4, 6, 6, 6, 6, 4, 6, 6, 6, 6, 6,
+ 6, 6, 7, 7, 6, 6, 6, 7, 7,
+};
+
+static const static_codebook _16u0__p6_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__16u0__p6_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__16u0__p6_1,
+ 0
+};
+
+static const long _vq_quantlist__16u0__p7_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__16u0__p7_0[] = {
+ 1, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7,
+};
+
+static const static_codebook _16u0__p7_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__16u0__p7_0,
+ 1, -518803456, 1628680192, 2, 0,
+ (long *)_vq_quantlist__16u0__p7_0,
+ 0
+};
+
+static const long _vq_quantlist__16u0__p7_1[] = {
+ 7,
+ 6,
+ 8,
+ 5,
+ 9,
+ 4,
+ 10,
+ 3,
+ 11,
+ 2,
+ 12,
+ 1,
+ 13,
+ 0,
+ 14,
+};
+
+static const long _vq_lengthlist__16u0__p7_1[] = {
+ 1, 5, 5, 6, 5, 9,10,11,11,10,10,10,10,10,10, 5,
+ 8, 8, 8,10,10,10,10,10,10,10,10,10,10,10, 5, 8,
+ 9, 9, 9,10,10,10,10,10,10,10,10,10,10, 5,10, 8,
+ 10,10,10,10,10,10,10,10,10,10,10,10, 4, 8, 9,10,
+ 10,10,10,10,10,10,10,10,10,10,10, 9,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10, 9,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,
+};
+
+static const static_codebook _16u0__p7_1 = {
+ 2, 225,
+ (long *)_vq_lengthlist__16u0__p7_1,
+ 1, -520986624, 1620377600, 4, 0,
+ (long *)_vq_quantlist__16u0__p7_1,
+ 0
+};
+
+static const long _vq_quantlist__16u0__p7_2[] = {
+ 10,
+ 9,
+ 11,
+ 8,
+ 12,
+ 7,
+ 13,
+ 6,
+ 14,
+ 5,
+ 15,
+ 4,
+ 16,
+ 3,
+ 17,
+ 2,
+ 18,
+ 1,
+ 19,
+ 0,
+ 20,
+};
+
+static const long _vq_lengthlist__16u0__p7_2[] = {
+ 1, 6, 6, 7, 8, 7, 7,10, 9,10, 9,11,10, 9,11,10,
+ 9, 9, 9, 9,10, 6, 8, 7, 9, 9, 8, 8,10,10, 9,11,
+ 11,12,12,10, 9,11, 9,12,10, 9, 6, 9, 8, 9,12, 8,
+ 8,11, 9,11,11,12,11,12,12,10,11,11,10,10,11, 7,
+ 10, 9, 9, 9, 9, 9,10, 9,10, 9,10,10,12,10,10,10,
+ 11,12,10,10, 7, 9, 9, 9,10, 9, 9,10,10, 9, 9, 9,
+ 11,11,10,10,10,10, 9, 9,12, 7, 9,10, 9,11, 9,10,
+ 9,10,11,11,11,10,11,12, 9,12,11,10,10,10, 7, 9,
+ 9, 9, 9,10,12,10, 9,11,12,10,11,12,12,11, 9,10,
+ 11,10,11, 7, 9,10,10,11,10, 9,10,11,11,11,10,12,
+ 12,12,11,11,10,11,11,12, 8, 9,10,12,11,10,10,12,
+ 12,12,12,12,10,11,11, 9,11,10,12,11,11, 8, 9,10,
+ 10,11,12,11,11,10,10,10,12,12,12, 9,10,12,12,12,
+ 12,12, 8,10,11,10,10,12, 9,11,12,12,11,12,12,12,
+ 12,10,12,10,10,10,10, 8,12,11,11,11,10,10,11,12,
+ 12,12,12,11,12,12,12,11,11,11,12,10, 9,10,10,12,
+ 10,12,10,12,12,10,10,10,11,12,12,12,11,12,12,12,
+ 11,10,11,12,12,12,11,12,12,11,12,12,11,12,12,12,
+ 12,11,12,12,10,10,10,10,11,11,12,11,12,12,12,12,
+ 12,12,12,11,12,11,10,11,11,12,11,11, 9,10,10,10,
+ 12,10,10,11, 9,11,12,11,12,11,12,12,10,11,10,12,
+ 9, 9, 9,12,11,10,11,10,12,10,12,10,12,12,12,11,
+ 11,11,11,11,10, 9,10,10,11,10,11,11,12,11,10,11,
+ 12,12,12,11,11, 9,12,10,12, 9,10,12,10,10,11,10,
+ 11,11,12,11,10,11,10,11,11,11,11,12,11,11,10, 9,
+ 10,10,10, 9,11,11,10, 9,12,10,11,12,11,12,12,11,
+ 12,11,12,11,10,11,10,12,11,12,11,12,11,12,10,11,
+ 10,10,12,11,10,11,11,11,10,
+};
+
+static const static_codebook _16u0__p7_2 = {
+ 2, 441,
+ (long *)_vq_lengthlist__16u0__p7_2,
+ 1, -529268736, 1611661312, 5, 0,
+ (long *)_vq_quantlist__16u0__p7_2,
+ 0
+};
+
+static const long _huff_lengthlist__16u0__single[] = {
+ 3, 5, 8, 7,14, 8, 9,19, 5, 2, 5, 5, 9, 6, 9,19,
+ 8, 4, 5, 7, 8, 9,13,19, 7, 4, 6, 5, 9, 6, 9,19,
+ 12, 8, 7, 9,10,11,13,19, 8, 5, 8, 6, 9, 6, 7,19,
+ 8, 8,10, 7, 7, 4, 5,19,12,17,19,15,18,13,11,18,
+};
+
+static const static_codebook _huff_book__16u0__single = {
+ 2, 64,
+ (long *)_huff_lengthlist__16u0__single,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__16u1__long[] = {
+ 3, 6,10, 8,12, 8,14, 8,14,19, 5, 3, 5, 5, 7, 6,
+ 11, 7,16,19, 7, 5, 6, 7, 7, 9,11,12,19,19, 6, 4,
+ 7, 5, 7, 6,10, 7,18,18, 8, 6, 7, 7, 7, 7, 8, 9,
+ 18,18, 7, 5, 8, 5, 7, 5, 8, 6,18,18,12, 9,10, 9,
+ 9, 9, 8, 9,18,18, 8, 7,10, 6, 8, 5, 6, 4,11,18,
+ 11,15,16,12,11, 8, 8, 6, 9,18,14,18,18,18,16,16,
+ 16,13,16,18,
+};
+
+static const static_codebook _huff_book__16u1__long = {
+ 2, 100,
+ (long *)_huff_lengthlist__16u1__long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__16u1__p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__16u1__p1_0[] = {
+ 1, 4, 4, 5, 7, 7, 5, 7, 7, 5, 8, 7, 7,10,10, 7,
+ 9,10, 5, 7, 8, 7,10, 9, 7,10,10, 5, 8, 8, 8,10,
+ 10, 8,10,10, 7,10,10,10,11,12,10,12,13, 7,10,10,
+ 9,13,11,10,12,13, 5, 8, 8, 8,10,10, 8,10,10, 7,
+ 10,10,10,12,12, 9,11,12, 7,10,11,10,12,12,10,13,
+ 11,
+};
+
+static const static_codebook _16u1__p1_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__16u1__p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__16u1__p1_0,
+ 0
+};
+
+static const long _vq_quantlist__16u1__p2_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__16u1__p2_0[] = {
+ 3, 4, 4, 5, 6, 6, 5, 6, 6, 5, 6, 6, 6, 7, 8, 6,
+ 7, 8, 5, 6, 6, 6, 8, 7, 6, 8, 7, 5, 6, 6, 6, 8,
+ 8, 6, 8, 8, 6, 8, 8, 7, 7,10, 8, 9, 9, 6, 8, 8,
+ 7, 9, 8, 8, 9,10, 5, 6, 6, 6, 8, 8, 7, 8, 8, 6,
+ 8, 8, 8,10, 9, 7, 8, 9, 6, 8, 8, 8, 9, 9, 7,10,
+ 8,
+};
+
+static const static_codebook _16u1__p2_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__16u1__p2_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__16u1__p2_0,
+ 0
+};
+
+static const long _vq_quantlist__16u1__p3_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__16u1__p3_0[] = {
+ 1, 5, 5, 8, 8, 6, 7, 7, 9, 9, 5, 7, 7, 9, 9, 9,
+ 10, 9,11,11, 9, 9,10,11,11, 6, 8, 8,10,10, 8, 9,
+ 10,11,11, 8, 9,10,11,11,10,11,11,12,13,10,11,11,
+ 13,13, 6, 8, 8,10,10, 8,10, 9,11,11, 8,10, 9,11,
+ 11,10,11,11,13,13,10,11,11,13,12, 9,11,11,14,13,
+ 10,12,12,15,14,10,12,11,14,13,12,13,13,15,15,12,
+ 13,13,16,14, 9,11,11,13,14,10,11,12,14,14,10,12,
+ 12,14,15,12,13,13,14,15,12,13,14,15,16, 5, 8, 8,
+ 11,11, 8,10,10,12,12, 8,10,10,12,12,11,12,12,14,
+ 14,11,12,12,14,14, 8,10,10,12,12, 9,11,12,12,13,
+ 10,12,12,13,13,12,12,13,14,15,11,13,13,15,15, 7,
+ 10,10,12,12, 9,12,11,13,12,10,11,12,13,13,12,13,
+ 12,15,14,11,12,13,15,15,10,12,12,15,14,11,13,13,
+ 16,15,11,13,13,16,15,14,13,14,15,16,13,15,15,17,
+ 17,10,12,12,14,15,11,12,12,15,15,11,13,13,15,16,
+ 13,15,13,16,15,13,15,15,16,17, 5, 8, 8,11,11, 8,
+ 10,10,12,12, 8,10,10,12,12,11,12,12,14,14,11,12,
+ 12,14,14, 7,10,10,12,12,10,12,12,14,13, 9,11,12,
+ 12,13,12,13,13,15,15,12,12,13,13,15, 7,10,10,12,
+ 13,10,11,12,13,13,10,12,11,13,13,11,13,13,15,15,
+ 12,13,12,15,14, 9,12,12,15,14,11,13,13,15,15,11,
+ 12,13,15,15,13,14,14,17,19,13,13,14,16,16,10,12,
+ 12,14,15,11,13,13,15,16,11,13,12,16,15,13,15,15,
+ 17,18,14,15,13,16,15, 8,11,11,15,14,10,12,12,16,
+ 15,10,12,12,16,16,14,15,15,18,17,13,14,15,16,18,
+ 9,12,12,15,15,11,12,14,16,17,11,13,13,16,15,15,
+ 15,15,17,18,14,15,16,17,17, 9,12,12,15,15,11,14,
+ 13,16,16,11,13,13,16,16,15,16,15,17,18,14,16,15,
+ 17,16,12,14,14,17,16,12,14,15,18,17,13,15,15,17,
+ 17,15,15,18,16,20,15,16,17,18,18,11,14,14,16,17,
+ 13,15,14,18,17,13,15,15,17,17,15,17,15,18,17,15,
+ 17,16,19,18, 8,11,11,14,15,10,12,12,15,15,10,12,
+ 12,16,16,13,14,14,17,16,14,15,15,17,17, 9,12,12,
+ 15,16,11,13,13,16,16,11,12,13,16,16,14,16,15,20,
+ 17,14,16,16,17,17, 9,12,12,15,16,11,13,13,16,17,
+ 11,13,13,17,16,14,15,15,17,18,15,15,15,18,18,11,
+ 14,14,17,16,13,15,15,17,17,13,14,14,18,17,15,16,
+ 16,18,19,15,15,17,17,19,11,14,14,16,17,13,15,14,
+ 17,19,13,15,14,18,17,15,17,16,18,18,15,17,15,18,
+ 16,
+};
+
+static const static_codebook _16u1__p3_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__16u1__p3_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__16u1__p3_0,
+ 0
+};
+
+static const long _vq_quantlist__16u1__p4_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__16u1__p4_0[] = {
+ 4, 5, 5, 8, 8, 6, 6, 7, 9, 9, 6, 6, 6, 9, 9, 9,
+ 10, 9,11,11, 9, 9,10,11,11, 6, 7, 7,10, 9, 7, 7,
+ 8, 9,10, 7, 7, 8,10,10,10,10,10,10,12, 9, 9,10,
+ 11,12, 6, 7, 7, 9, 9, 7, 8, 7,10,10, 7, 8, 7,10,
+ 10, 9,10, 9,12,11,10,10, 9,12,10, 9,10,10,12,11,
+ 10,10,10,12,12, 9,10,10,12,12,12,11,12,13,13,11,
+ 11,12,12,13, 9,10,10,11,12, 9,10,10,12,12,10,10,
+ 10,12,12,11,12,11,14,13,11,12,12,14,13, 5, 7, 7,
+ 10,10, 7, 8, 8,10,10, 7, 8, 7,10,10,10,10,10,12,
+ 12,10,10,10,12,12, 6, 8, 7,10,10, 7, 7, 9,10,11,
+ 8, 9, 9,11,10,10,10,11,11,13,10,10,11,12,13, 6,
+ 8, 8,10,10, 7, 9, 8,11,10, 8, 9, 9,10,11,10,11,
+ 10,13,11,10,11,10,12,12,10,11,10,12,11,10,10,10,
+ 12,13,10,11,11,13,12,11,11,13,11,14,12,12,13,14,
+ 14, 9,10,10,12,13,10,11,10,13,12,10,11,11,12,13,
+ 11,12,11,14,12,12,13,13,15,14, 5, 7, 7,10,10, 7,
+ 7, 8,10,10, 7, 8, 8,10,10,10,10,10,11,12,10,10,
+ 10,12,12, 7, 8, 8,10,10, 8, 9, 8,11,10, 7, 8, 9,
+ 10,11,10,11,11,12,12,10,10,11,11,13, 7, 7, 8,10,
+ 10, 8, 8, 9,10,11, 7, 9, 7,11,10,10,11,11,13,12,
+ 11,11,10,13,11, 9,10,10,12,12,10,11,11,13,12,10,
+ 10,11,12,12,12,13,13,14,14,11,11,12,12,14,10,10,
+ 11,12,12,10,11,11,12,13,10,10,10,13,12,12,13,13,
+ 15,14,12,13,10,14,11, 8,10,10,12,12,10,11,10,13,
+ 13, 9,10,10,12,12,12,13,13,15,14,11,12,12,13,13,
+ 9,10,10,13,12,10,10,11,13,13,10,11,10,13,12,12,
+ 12,13,14,15,12,13,12,15,13, 9,10,10,12,13,10,11,
+ 10,13,12,10,10,11,12,13,12,14,12,15,13,12,12,13,
+ 14,15,11,12,11,14,13,11,11,12,14,15,12,13,12,15,
+ 14,13,11,15,11,16,13,14,14,16,15,11,12,12,14,14,
+ 11,12,11,14,13,12,12,13,14,15,13,14,12,16,12,14,
+ 14,14,15,15, 8,10,10,12,12, 9,10,10,12,12,10,10,
+ 11,13,13,11,12,12,13,13,12,13,13,14,15, 9,10,10,
+ 13,12,10,11,11,13,12,10,10,11,13,13,12,13,12,15,
+ 14,12,12,13,13,16, 9, 9,10,12,13,10,10,11,12,13,
+ 10,11,10,13,13,12,12,13,13,15,13,13,12,15,13,11,
+ 12,12,14,14,12,13,12,15,14,11,11,12,13,14,14,14,
+ 14,16,15,13,12,15,12,16,11,11,12,13,14,12,13,13,
+ 14,15,10,12,11,14,13,14,15,14,16,16,13,14,11,15,
+ 11,
+};
+
+static const static_codebook _16u1__p4_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__16u1__p4_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__16u1__p4_0,
+ 0
+};
+
+static const long _vq_quantlist__16u1__p5_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__16u1__p5_0[] = {
+ 1, 4, 4, 7, 7, 7, 7, 9, 9, 4, 6, 6, 8, 8, 8, 8,
+ 10,10, 4, 5, 6, 8, 8, 8, 8,10,10, 7, 8, 8, 9, 9,
+ 9, 9,11,11, 7, 8, 8, 9, 9, 9, 9,11,11, 7, 8, 8,
+ 10, 9,11,11,12,11, 7, 8, 8, 9, 9,11,11,12,12, 9,
+ 10,10,11,11,12,12,13,12, 9,10,10,11,11,12,12,12,
+ 13,
+};
+
+static const static_codebook _16u1__p5_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__16u1__p5_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__16u1__p5_0,
+ 0
+};
+
+static const long _vq_quantlist__16u1__p6_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__16u1__p6_0[] = {
+ 3, 4, 4, 6, 6, 7, 7, 9, 9, 4, 4, 4, 6, 6, 8, 8,
+ 9, 9, 4, 4, 4, 6, 6, 7, 7, 9, 9, 6, 6, 6, 7, 7,
+ 8, 8,10, 9, 6, 6, 6, 7, 7, 8, 8, 9,10, 7, 8, 7,
+ 8, 8, 9, 9,10,10, 7, 8, 8, 8, 8, 9, 9,10,10, 9,
+ 9, 9,10,10,10,10,11,11, 9, 9, 9,10,10,10,10,11,
+ 11,
+};
+
+static const static_codebook _16u1__p6_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__16u1__p6_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__16u1__p6_0,
+ 0
+};
+
+static const long _vq_quantlist__16u1__p7_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__16u1__p7_0[] = {
+ 1, 4, 4, 4, 8, 8, 4, 8, 8, 5,11, 9, 8,12,11, 8,
+ 12,11, 5,10,11, 8,11,12, 8,11,12, 4,11,11,11,14,
+ 13,10,13,13, 8,14,13,12,14,16,12,16,15, 8,14,14,
+ 13,16,14,12,15,16, 4,11,11,10,14,13,11,14,14, 8,
+ 15,14,12,15,15,12,14,16, 8,14,14,11,16,15,12,15,
+ 13,
+};
+
+static const static_codebook _16u1__p7_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__16u1__p7_0,
+ 1, -529137664, 1618345984, 2, 0,
+ (long *)_vq_quantlist__16u1__p7_0,
+ 0
+};
+
+static const long _vq_quantlist__16u1__p7_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__16u1__p7_1[] = {
+ 2, 4, 4, 6, 6, 7, 7, 8, 8, 8, 8, 4, 6, 5, 7, 7,
+ 8, 8, 8, 8, 8, 8, 4, 5, 6, 7, 7, 8, 8, 8, 8, 8,
+ 8, 6, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 6, 7, 7, 8,
+ 8, 8, 8, 9, 9, 9, 9, 7, 8, 8, 8, 8, 9, 9, 9,10,
+ 9,10, 7, 8, 8, 8, 8, 9, 9, 9, 9,10, 9, 8, 8, 8,
+ 9, 9,10,10,10,10,10,10, 8, 8, 8, 9, 9, 9, 9,10,
+ 10,10,10, 8, 8, 8, 9, 9, 9,10,10,10,10,10, 8, 8,
+ 8, 9, 9,10,10,10,10,10,10,
+};
+
+static const static_codebook _16u1__p7_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__16u1__p7_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__16u1__p7_1,
+ 0
+};
+
+static const long _vq_quantlist__16u1__p8_0[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__16u1__p8_0[] = {
+ 1, 4, 4, 5, 5, 8, 8,10,10,12,12, 4, 7, 7, 8, 8,
+ 9, 9,12,11,14,13, 4, 7, 7, 7, 8, 9,10,11,11,13,
+ 12, 5, 8, 8, 9, 9,11,11,12,13,15,14, 5, 7, 8, 9,
+ 9,11,11,13,13,17,15, 8, 9,10,11,11,12,13,17,14,
+ 17,16, 8,10, 9,11,11,12,12,13,15,15,17,10,11,11,
+ 12,13,14,15,15,16,16,17, 9,11,11,12,12,14,15,17,
+ 15,15,16,11,14,12,14,15,16,15,16,16,16,15,11,13,
+ 13,14,14,15,15,16,16,15,16,
+};
+
+static const static_codebook _16u1__p8_0 = {
+ 2, 121,
+ (long *)_vq_lengthlist__16u1__p8_0,
+ 1, -524582912, 1618345984, 4, 0,
+ (long *)_vq_quantlist__16u1__p8_0,
+ 0
+};
+
+static const long _vq_quantlist__16u1__p8_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__16u1__p8_1[] = {
+ 2, 5, 5, 6, 6, 7, 7, 8, 8, 8, 8, 4, 6, 6, 7, 7,
+ 8, 7, 8, 8, 8, 8, 4, 6, 6, 7, 7, 7, 7, 8, 8, 8,
+ 8, 6, 7, 7, 7, 7, 8, 8, 8, 8, 8, 9, 6, 7, 7, 7,
+ 7, 8, 8, 8, 8, 9, 9, 7, 7, 7, 8, 8, 8, 8, 9, 9,
+ 9, 9, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 8, 8, 8,
+ 8, 8, 9, 9, 9, 9, 9, 9, 8, 8, 8, 8, 8, 9, 9, 9,
+ 9, 9, 9, 8, 8, 8, 9, 8, 9, 9, 9, 9, 9, 9, 8, 8,
+ 8, 9, 9, 9, 9, 9, 9, 9, 9,
+};
+
+static const static_codebook _16u1__p8_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__16u1__p8_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__16u1__p8_1,
+ 0
+};
+
+static const long _vq_quantlist__16u1__p9_0[] = {
+ 7,
+ 6,
+ 8,
+ 5,
+ 9,
+ 4,
+ 10,
+ 3,
+ 11,
+ 2,
+ 12,
+ 1,
+ 13,
+ 0,
+ 14,
+};
+
+static const long _vq_lengthlist__16u1__p9_0[] = {
+ 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8,
+};
+
+static const static_codebook _16u1__p9_0 = {
+ 2, 225,
+ (long *)_vq_lengthlist__16u1__p9_0,
+ 1, -514071552, 1627381760, 4, 0,
+ (long *)_vq_quantlist__16u1__p9_0,
+ 0
+};
+
+static const long _vq_quantlist__16u1__p9_1[] = {
+ 7,
+ 6,
+ 8,
+ 5,
+ 9,
+ 4,
+ 10,
+ 3,
+ 11,
+ 2,
+ 12,
+ 1,
+ 13,
+ 0,
+ 14,
+};
+
+static const long _vq_lengthlist__16u1__p9_1[] = {
+ 1, 6, 5, 9, 9,10,10, 6, 7, 9, 9,10,10,10,10, 5,
+ 10, 8,10, 8,10,10, 8, 8,10, 9,10,10,10,10, 5, 8,
+ 9,10,10,10,10, 8,10,10,10,10,10,10,10, 9,10,10,
+ 10,10,10,10, 9, 9,10,10,10,10,10,10, 9, 9, 8, 9,
+ 10,10,10, 9,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10, 8,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10, 6, 8, 8,10,10,10, 8,
+ 10,10,10,10,10,10,10,10, 5, 8, 8,10,10,10, 9, 9,
+ 10,10,10,10,10,10,10,10, 9,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9,
+};
+
+static const static_codebook _16u1__p9_1 = {
+ 2, 225,
+ (long *)_vq_lengthlist__16u1__p9_1,
+ 1, -522338304, 1620115456, 4, 0,
+ (long *)_vq_quantlist__16u1__p9_1,
+ 0
+};
+
+static const long _vq_quantlist__16u1__p9_2[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__16u1__p9_2[] = {
+ 1, 6, 6, 7, 8, 8,11,10, 9, 9,11, 9,10, 9,11,11,
+ 9, 6, 7, 6,11, 8,11, 9,10,10,11, 9,11,10,10,10,
+ 11, 9, 5, 7, 7, 8, 8,10,11, 8, 8,11, 9, 9,10,11,
+ 9,10,11, 8, 9, 6, 8, 8, 9, 9,10,10,11,11,11, 9,
+ 11,10, 9,11, 8, 8, 8, 9, 8, 9,10,11, 9, 9,11,11,
+ 10, 9, 9,11,10, 8,11, 8, 9, 8,11, 9,10, 9,10,11,
+ 11,10,10, 9,10,10, 8, 8, 9,10,10,10, 9,11, 9,10,
+ 11,11,11,11,10, 9,11, 9, 9,11,11,10, 8,11,11,11,
+ 9,10,10,11,10,11,11, 9,11,10, 9,11,10,10,10,10,
+ 9,11,10,11,10, 9, 9,10,11, 9, 8,10,11,11,10,10,
+ 11, 9,11,10,11,11,10,11, 9, 9, 8,10, 8, 9,11, 9,
+ 8,10,10, 9,11,10,11,10,11, 9,11, 8,10,11,11,11,
+ 11,10,10,11,11,11,11,10,11,11,10, 9, 8,10,10, 9,
+ 11,10,11,11,11, 9, 9, 9,11,11,11,10,10, 9, 9,10,
+ 9,11,11,11,11, 8,10,11,10,11,11,10,11,11, 9, 9,
+ 9,10, 9,11, 9,11,11,11,11,11,10,11,11,10,11,10,
+ 11,11, 9,11,10,11,10, 9,10, 9,10,10,11,11,11,11,
+ 9,10, 9,10,11,11,10,11,11,11,11,11,11,10,11,11,
+ 10,
+};
+
+static const static_codebook _16u1__p9_2 = {
+ 2, 289,
+ (long *)_vq_lengthlist__16u1__p9_2,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__16u1__p9_2,
+ 0
+};
+
+static const long _huff_lengthlist__16u1__short[] = {
+ 5, 7,10, 9,11,10,15,11,13,16, 6, 4, 6, 6, 7, 7,
+ 10, 9,12,16,10, 6, 5, 6, 6, 7,10,11,16,16, 9, 6,
+ 7, 6, 7, 7,10, 8,14,16,11, 6, 5, 4, 5, 6, 8, 9,
+ 15,16, 9, 6, 6, 5, 6, 6, 9, 8,14,16,12, 7, 6, 6,
+ 5, 6, 6, 7,13,16, 8, 6, 7, 6, 5, 5, 4, 4,11,16,
+ 9, 8, 9, 9, 7, 7, 6, 5,13,16,14,14,16,15,16,15,
+ 16,16,16,16,
+};
+
+static const static_codebook _huff_book__16u1__short = {
+ 2, 100,
+ (long *)_huff_lengthlist__16u1__short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__16u2__long[] = {
+ 5, 8,10,10,10,11,11,12,14,18, 7, 5, 5, 6, 8, 9,
+ 10,12,14,17, 9, 5, 4, 5, 6, 8,10,11,13,19, 9, 5,
+ 4, 4, 5, 6, 9,10,12,17, 8, 6, 5, 4, 4, 5, 7,10,
+ 11,15, 8, 7, 7, 6, 5, 5, 6, 9,11,14, 8, 9, 8, 7,
+ 6, 5, 6, 7,11,14, 9,11,11, 9, 7, 6, 6, 6, 9,14,
+ 11,14,15,13, 9, 8, 7, 7, 9,14,13,15,19,17,12,11,
+ 10, 9,10,14,
+};
+
+static const static_codebook _huff_book__16u2__long = {
+ 2, 100,
+ (long *)_huff_lengthlist__16u2__long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__16u2_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__16u2_p1_0[] = {
+ 1, 5, 5, 5, 7, 7, 5, 7, 7, 5, 7, 7, 7, 9, 9, 7,
+ 9, 9, 5, 7, 7, 7, 9, 9, 8, 9, 9, 5, 7, 7, 8, 9,
+ 9, 7, 9, 9, 7, 9, 9, 9,10,11, 9,10,10, 7, 9, 9,
+ 9,10, 9, 9,10,11, 5, 8, 7, 7, 9, 9, 8, 9, 9, 7,
+ 9, 9, 9,11,10, 9, 9,10, 7, 9, 9, 9,10,10, 9,11,
+ 10,
+};
+
+static const static_codebook _16u2_p1_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__16u2_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__16u2_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__16u2_p2_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__16u2_p2_0[] = {
+ 3, 5, 5, 8, 8, 5, 7, 7, 9, 9, 5, 7, 7, 9, 9, 9,
+ 10, 9,11,11, 9, 9, 9,11,11, 5, 7, 7, 9, 9, 7, 8,
+ 8,10,10, 7, 8, 8,10,10,10,10,10,12,12, 9,10,10,
+ 11,12, 5, 7, 7, 9, 9, 7, 8, 8,10,10, 7, 8, 8,10,
+ 10, 9,10,10,12,11,10,10,10,12,12, 9,10,10,12,12,
+ 10,10,10,12,12, 9,10,10,12,12,12,12,12,14,14,11,
+ 12,12,13,14, 9,10,10,12,12, 9,10,10,12,12,10,10,
+ 10,12,12,11,12,12,14,13,12,12,12,14,13, 5, 7, 7,
+ 9, 9, 7, 8, 8,10,10, 7, 8, 8,10,10,10,10,10,12,
+ 12,10,10,10,12,12, 7, 8, 8,11,10, 8, 9, 9,11,11,
+ 8, 9, 9,11,11,10,11,11,12,13,10,11,11,12,13, 7,
+ 8, 8,10,10, 8, 9, 8,11,10, 8, 9, 9,11,11,10,11,
+ 10,13,12,10,11,11,13,13,10,11,10,13,12,10,11,11,
+ 13,13,10,11,11,13,13,12,12,13,13,14,12,13,13,14,
+ 14, 9,10,10,12,12,10,11,10,13,12,10,11,11,13,13,
+ 12,13,12,14,13,12,13,13,14,15, 5, 7, 7, 9,10, 7,
+ 8, 8,10,10, 7, 8, 8,10,10,10,10,10,12,12,10,10,
+ 11,12,12, 7, 8, 8,10,10, 8, 9, 9,11,11, 8, 8, 9,
+ 10,11,10,11,11,13,13,10,10,11,12,13, 7, 8, 8,10,
+ 10, 8, 9, 9,11,11, 8, 9, 9,11,11,10,11,11,13,12,
+ 10,11,11,13,12, 9,10,10,12,12,10,11,11,13,13,10,
+ 10,11,12,13,12,13,13,15,14,12,12,13,12,14, 9,10,
+ 11,12,13,10,11,11,13,13,10,11,11,13,13,12,13,13,
+ 14,14,12,13,12,14,13, 8,10,10,12,12, 9,11,10,13,
+ 12, 9,10,10,12,13,12,13,13,14,14,12,12,12,14,14,
+ 9,10,10,13,13,10,11,11,13,13,10,11,11,13,13,13,
+ 13,13,14,15,12,13,13,14,15, 9,10,10,12,13,10,11,
+ 10,13,13,10,11,11,12,13,12,13,12,15,14,12,13,13,
+ 14,15,11,12,12,15,14,12,12,13,14,15,12,13,13,15,
+ 14,13,13,15,14,16,14,14,14,16,15,11,12,12,14,14,
+ 11,12,12,14,14,12,13,13,14,15,13,14,13,15,13,14,
+ 14,14,15,16, 8, 9,10,12,12, 9,10,10,13,12, 9,10,
+ 11,12,13,12,12,12,14,14,12,13,13,14,14, 9,10,10,
+ 13,12,10,11,11,13,13,10,10,11,13,13,12,13,13,15,
+ 14,12,12,13,14,15, 9,10,10,13,13,10,11,11,13,13,
+ 10,11,11,13,13,12,13,13,14,14,13,13,13,15,15,11,
+ 12,12,14,13,12,13,13,15,14,11,12,12,14,14,14,14,
+ 14,16,15,13,13,14,13,16,11,12,12,14,14,12,13,13,
+ 14,15,12,13,12,14,14,14,14,14,16,16,14,15,13,16,
+ 14,
+};
+
+static const static_codebook _16u2_p2_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__16u2_p2_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__16u2_p2_0,
+ 0
+};
+
+static const long _vq_quantlist__16u2_p3_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__16u2_p3_0[] = {
+ 2, 4, 4, 6, 6, 7, 7, 9, 9, 4, 5, 5, 6, 6, 8, 7,
+ 9, 9, 4, 5, 5, 6, 6, 7, 8, 9, 9, 6, 6, 6, 7, 7,
+ 8, 8,10,10, 6, 6, 6, 7, 7, 8, 8,10,10, 7, 8, 7,
+ 8, 8, 9, 9,11,10, 7, 7, 8, 8, 8, 9, 9,10,11, 9,
+ 9, 9,10,10,11,10,11,11, 9, 9, 9,10,10,10,11,11,
+ 11,
+};
+
+static const static_codebook _16u2_p3_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__16u2_p3_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__16u2_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__16u2_p4_0[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__16u2_p4_0[] = {
+ 2, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9,10,10,11,11,11,
+ 11, 5, 5, 5, 7, 6, 8, 7, 9, 9, 9, 9,10,10,11,11,
+ 12,12, 5, 5, 5, 6, 6, 7, 8, 8, 9, 9, 9,10,10,11,
+ 11,12,12, 6, 7, 6, 7, 7, 8, 8, 9, 9, 9, 9,10,10,
+ 11,11,12,12, 6, 6, 7, 7, 7, 8, 8, 9, 9, 9, 9,10,
+ 10,11,11,12,12, 7, 8, 8, 8, 8, 9, 9, 9, 9,10,10,
+ 11,11,11,11,12,12, 7, 7, 8, 8, 8, 9, 9, 9, 9,10,
+ 10,11,11,11,11,12,12, 8, 9, 9, 9, 9, 9, 9,10,10,
+ 10,10,11,11,12,12,12,12, 8, 9, 9, 9, 9, 9, 9,10,
+ 10,10,10,11,11,12,12,12,12, 9, 9, 9, 9, 9,10,10,
+ 10,10,10,11,11,11,12,12,13,13, 9, 9, 9, 9, 9,10,
+ 10,10,10,11,10,11,11,12,12,13,13,10,10,10,10,10,
+ 11,11,11,11,11,11,11,12,12,12,13,13,10,10,10,10,
+ 10,11,11,11,11,11,11,12,11,12,12,13,13,11,11,11,
+ 11,11,11,11,12,12,12,12,12,12,13,13,13,13,11,11,
+ 11,11,11,11,11,12,12,12,12,13,12,13,13,13,13,11,
+ 12,12,12,12,12,12,12,12,13,13,13,13,13,13,14,14,
+ 11,12,12,12,12,12,12,12,13,13,13,13,13,13,13,14,
+ 14,
+};
+
+static const static_codebook _16u2_p4_0 = {
+ 2, 289,
+ (long *)_vq_lengthlist__16u2_p4_0,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__16u2_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__16u2_p5_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__16u2_p5_0[] = {
+ 1, 4, 4, 5, 7, 7, 5, 7, 7, 5, 8, 8, 7, 9, 9, 7,
+ 9,10, 5, 8, 8, 7,10, 9, 7,10, 9, 5, 8, 8, 8,11,
+ 10, 8,10,10, 7,10,10, 9, 9,12,10,12,12, 7,10,10,
+ 9,12,10,10,11,12, 5, 8, 8, 8,10,10, 8,11,11, 7,
+ 11,10,10,12,11, 9,10,12, 7,10,11,10,12,12, 9,12,
+ 9,
+};
+
+static const static_codebook _16u2_p5_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__16u2_p5_0,
+ 1, -529137664, 1618345984, 2, 0,
+ (long *)_vq_quantlist__16u2_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__16u2_p5_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__16u2_p5_1[] = {
+ 2, 5, 5, 6, 6, 7, 7, 8, 8, 8, 8, 5, 6, 6, 7, 7,
+ 7, 7, 8, 8, 8, 8, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8,
+ 8, 6, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 6, 7, 7, 7,
+ 7, 8, 8, 8, 8, 8, 8, 7, 7, 7, 8, 8, 8, 8, 8, 8,
+ 8, 8, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 9, 9, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 9, 9, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 8, 8,
+ 8, 8, 8, 8, 8, 9, 9, 9, 9,
+};
+
+static const static_codebook _16u2_p5_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__16u2_p5_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__16u2_p5_1,
+ 0
+};
+
+static const long _vq_quantlist__16u2_p6_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__16u2_p6_0[] = {
+ 1, 5, 4, 7, 7, 8, 8, 8, 8,10,10,11,11, 4, 6, 6,
+ 7, 7, 9, 9, 9, 9,10,10,11,11, 4, 6, 6, 7, 7, 9,
+ 9, 9, 9,10,10,11,11, 7, 8, 8, 9, 9, 9, 9,10,10,
+ 11,11,12,12, 7, 7, 7, 9, 8,10, 9,10,10,11,11,12,
+ 12, 8, 9, 9, 9,10,10,10,11,11,12,12,13,13, 8, 9,
+ 9,10, 9,10,10,11,11,12,12,13,13, 8, 9, 9,10,10,
+ 11,11,11,11,12,12,13,13, 8, 9, 9,10,10,11,11,12,
+ 11,12,12,13,13,10,10,10,11,11,12,12,12,12,13,13,
+ 14,14,10,10,10,11,11,12,12,12,12,13,13,14,14,11,
+ 11,11,12,12,13,13,13,13,14,14,14,14,11,11,11,12,
+ 12,13,13,13,13,14,14,14,14,
+};
+
+static const static_codebook _16u2_p6_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__16u2_p6_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__16u2_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__16u2_p6_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__16u2_p6_1[] = {
+ 2, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5,
+};
+
+static const static_codebook _16u2_p6_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__16u2_p6_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__16u2_p6_1,
+ 0
+};
+
+static const long _vq_quantlist__16u2_p7_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__16u2_p7_0[] = {
+ 1, 4, 4, 7, 7, 8, 8, 8, 8, 9, 9,10,10, 4, 6, 6,
+ 8, 8, 9, 9, 9, 9,10,10,11,10, 4, 6, 6, 8, 8, 9,
+ 9, 9, 9,10,10,11,11, 7, 8, 8,10, 9,10,10,10,10,
+ 11,11,12,12, 7, 8, 8,10,10,10,10,10,10,11,11,12,
+ 12, 8, 9, 9,10,10,11,11,11,11,12,12,13,13, 8, 9,
+ 9,10,10,11,11,11,11,12,12,13,13, 8, 9, 9,11,10,
+ 11,11,12,12,13,13,14,13, 8, 9, 9,10,10,11,11,12,
+ 12,13,13,13,13, 9,10,10,11,11,12,12,13,13,13,13,
+ 14,14, 9,10,10,11,11,12,12,13,13,13,13,14,14,10,
+ 11,11,12,12,13,13,14,13,14,14,15,14,10,11,11,12,
+ 12,13,13,14,13,14,14,15,14,
+};
+
+static const static_codebook _16u2_p7_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__16u2_p7_0,
+ 1, -523206656, 1618345984, 4, 0,
+ (long *)_vq_quantlist__16u2_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__16u2_p7_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__16u2_p7_1[] = {
+ 2, 5, 5, 7, 7, 7, 7, 7, 7, 8, 8, 5, 6, 6, 7, 7,
+ 7, 7, 8, 8, 8, 8, 5, 6, 6, 7, 7, 7, 7, 8, 8, 8,
+ 8, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 7, 7, 7, 7,
+ 7, 8, 8, 8, 8, 8, 8, 7, 7, 7, 8, 8, 8, 8, 8, 8,
+ 8, 8, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 7, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 7, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8,
+};
+
+static const static_codebook _16u2_p7_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__16u2_p7_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__16u2_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__16u2_p8_0[] = {
+ 7,
+ 6,
+ 8,
+ 5,
+ 9,
+ 4,
+ 10,
+ 3,
+ 11,
+ 2,
+ 12,
+ 1,
+ 13,
+ 0,
+ 14,
+};
+
+static const long _vq_lengthlist__16u2_p8_0[] = {
+ 1, 4, 4, 7, 7, 8, 8, 7, 7, 9, 8,10, 9,11,11, 4,
+ 7, 6, 9, 8, 9, 9, 9, 9,10, 9,11, 9,12, 9, 4, 6,
+ 7, 8, 8, 9, 9, 9, 9,10,10,10,11,11,12, 7, 9, 8,
+ 10,10,11,11,10,10,11,11,12,12,13,12, 7, 8, 8,10,
+ 10,10,11,10,10,11,11,11,12,12,13, 8, 9, 9,11,11,
+ 11,11,11,11,12,12,13,13,13,13, 8, 9, 9,11,11,11,
+ 11,11,11,12,12,13,13,13,14, 8, 9, 9,10,10,11,11,
+ 12,11,13,13,14,13,14,14, 8, 9, 9,10,10,11,11,12,
+ 12,12,12,13,13,14,14, 9,10,10,11,11,12,12,13,12,
+ 13,13,14,14,15,15, 9,10,10,11,11,12,12,12,13,13,
+ 13,14,14,14,15,10,11,11,12,12,13,13,14,13,14,14,
+ 15,14,15,15,10,11,11,12,12,13,12,13,14,14,14,14,
+ 14,15,15,11,12,12,13,13,13,13,14,14,15,14,15,15,
+ 16,16,11,12,12,13,13,13,13,14,14,14,15,15,15,16,
+ 16,
+};
+
+static const static_codebook _16u2_p8_0 = {
+ 2, 225,
+ (long *)_vq_lengthlist__16u2_p8_0,
+ 1, -520986624, 1620377600, 4, 0,
+ (long *)_vq_quantlist__16u2_p8_0,
+ 0
+};
+
+static const long _vq_quantlist__16u2_p8_1[] = {
+ 10,
+ 9,
+ 11,
+ 8,
+ 12,
+ 7,
+ 13,
+ 6,
+ 14,
+ 5,
+ 15,
+ 4,
+ 16,
+ 3,
+ 17,
+ 2,
+ 18,
+ 1,
+ 19,
+ 0,
+ 20,
+};
+
+static const long _vq_lengthlist__16u2_p8_1[] = {
+ 3, 5, 5, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 5, 6, 6, 7, 7, 8, 8, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9,10,10,10,10, 5, 6, 6, 7, 7, 8,
+ 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 7,
+ 7, 7, 8, 8, 9, 8, 9, 9, 9, 9, 9, 9,10,10,10,10,
+ 10,10,10,10, 7, 7, 7, 8, 8, 9, 9, 9, 9, 9, 9, 9,
+ 9,10, 9,10,10,10, 9,10, 9, 8, 8, 8, 9, 8, 9, 9,
+ 9, 9,10, 9,10,10,10,10,10,10,10,10,10,10, 8, 8,
+ 8, 8, 9, 9, 9, 9, 9, 9, 9,10,10,10,10,10,10,10,
+ 10,10,10, 8, 9, 9, 9, 9, 9, 9, 9, 9,10,10,10,10,
+ 10,10,10,10,10,10,10,10, 8, 9, 9, 9, 9, 9, 9, 9,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10, 9, 9, 9,
+ 9, 9, 9, 9,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10, 9, 9, 9, 9, 9, 9, 9,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10, 9, 9, 9, 9, 9,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10, 9, 9, 9, 9,
+ 9,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10, 9, 9, 9,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10, 9, 9, 9,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10, 9, 9,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 9,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10, 9,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10, 9,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10, 9,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10, 9,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,
+};
+
+static const static_codebook _16u2_p8_1 = {
+ 2, 441,
+ (long *)_vq_lengthlist__16u2_p8_1,
+ 1, -529268736, 1611661312, 5, 0,
+ (long *)_vq_quantlist__16u2_p8_1,
+ 0
+};
+
+static const long _vq_quantlist__16u2_p9_0[] = {
+ 7,
+ 6,
+ 8,
+ 5,
+ 9,
+ 4,
+ 10,
+ 3,
+ 11,
+ 2,
+ 12,
+ 1,
+ 13,
+ 0,
+ 14,
+};
+
+static const long _vq_lengthlist__16u2_p9_0[] = {
+ 1, 5, 3, 9, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 5,
+ 7, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 5, 7,
+ 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,
+};
+
+static const static_codebook _16u2_p9_0 = {
+ 2, 225,
+ (long *)_vq_lengthlist__16u2_p9_0,
+ 1, -510036736, 1631393792, 4, 0,
+ (long *)_vq_quantlist__16u2_p9_0,
+ 0
+};
+
+static const long _vq_quantlist__16u2_p9_1[] = {
+ 9,
+ 8,
+ 10,
+ 7,
+ 11,
+ 6,
+ 12,
+ 5,
+ 13,
+ 4,
+ 14,
+ 3,
+ 15,
+ 2,
+ 16,
+ 1,
+ 17,
+ 0,
+ 18,
+};
+
+static const long _vq_lengthlist__16u2_p9_1[] = {
+ 1, 4, 4, 7, 7, 7, 7, 7, 6, 9, 7,10, 8,12,12,13,
+ 13,14,14, 4, 7, 7, 9, 9, 9, 8, 9, 8,10, 9,11, 9,
+ 14, 9,14,10,13,11, 4, 7, 7, 9, 9, 9, 9, 8, 9,10,
+ 10,11,11,12,13,12,13,14,15, 7, 9, 9,10,11,10,10,
+ 10,10,11,12,13,13,13,14,17,14,15,16, 7, 9, 9,10,
+ 10,10,10,10,10,11,12,13,13,14,14,15,15,18,18, 8,
+ 9, 9,11,10,11,11,11,12,13,12,14,14,16,15,15,17,
+ 18,15, 8, 9, 9,10,10,11,11,11,11,13,13,14,14,15,
+ 15,15,16,16,18, 7, 9, 8,10,10,11,11,12,12,14,14,
+ 15,15,16,16,15,17,16,18, 8, 9, 9,10,10,11,12,12,
+ 12,13,13,16,15,17,16,17,18,17,18, 9,10,10,12,11,
+ 13,13,14,13,14,14,15,17,16,18,17,18,17,18, 9,10,
+ 10,12,11,12,13,13,14,15,16,14,15,16,18,18,18,18,
+ 17,11,11,11,13,13,14,14,16,15,15,15,16,15,15,18,
+ 18,18,17,16,11,11,12,13,13,15,14,15,16,16,16,17,
+ 16,15,18,17,18,16,18,12,13,13,15,15,15,16,18,16,
+ 17,16,17,16,17,17,17,18,18,17,13,13,13,15,13,16,
+ 15,17,16,16,16,18,18,18,18,16,17,17,18,13,15,14,
+ 15,15,18,17,18,18,18,16,18,17,18,17,18,16,17,17,
+ 14,14,14,15,16,17,16,18,18,18,17,18,17,18,18,18,
+ 16,16,16,14,17,16,17,15,16,18,18,17,18,17,18,17,
+ 18,18,18,17,18,17,15,16,15,18,15,18,17,16,18,18,
+ 18,18,18,18,17,18,16,18,17,
+};
+
+static const static_codebook _16u2_p9_1 = {
+ 2, 361,
+ (long *)_vq_lengthlist__16u2_p9_1,
+ 1, -518287360, 1622704128, 5, 0,
+ (long *)_vq_quantlist__16u2_p9_1,
+ 0
+};
+
+static const long _vq_quantlist__16u2_p9_2[] = {
+ 24,
+ 23,
+ 25,
+ 22,
+ 26,
+ 21,
+ 27,
+ 20,
+ 28,
+ 19,
+ 29,
+ 18,
+ 30,
+ 17,
+ 31,
+ 16,
+ 32,
+ 15,
+ 33,
+ 14,
+ 34,
+ 13,
+ 35,
+ 12,
+ 36,
+ 11,
+ 37,
+ 10,
+ 38,
+ 9,
+ 39,
+ 8,
+ 40,
+ 7,
+ 41,
+ 6,
+ 42,
+ 5,
+ 43,
+ 4,
+ 44,
+ 3,
+ 45,
+ 2,
+ 46,
+ 1,
+ 47,
+ 0,
+ 48,
+};
+
+static const long _vq_lengthlist__16u2_p9_2[] = {
+ 2, 3, 4, 4, 4, 5, 5, 6, 5, 6, 6, 6, 6, 6, 6, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 7, 8, 8, 8, 8, 8,
+ 8,
+};
+
+static const static_codebook _16u2_p9_2 = {
+ 1, 49,
+ (long *)_vq_lengthlist__16u2_p9_2,
+ 1, -526909440, 1611661312, 6, 0,
+ (long *)_vq_quantlist__16u2_p9_2,
+ 0
+};
+
+static const long _huff_lengthlist__16u2__short[] = {
+ 8,11,13,13,15,16,19,19,19,19,11, 8, 8, 9, 9,11,
+ 13,15,19,20,14, 8, 7, 7, 8, 9,12,13,15,20,15, 9,
+ 6, 5, 5, 7,10,12,14,18,14, 9, 7, 5, 3, 4, 7,10,
+ 12,16,13,10, 8, 6, 3, 3, 5, 8,11,14,11,10, 9, 7,
+ 5, 4, 4, 6,11,14,10,10,10, 8, 6, 5, 5, 6,10,14,
+ 10,10,10, 9, 8, 7, 7, 7,10,14,11,12,12,12,11,10,
+ 10,10,12,16,
+};
+
+static const static_codebook _huff_book__16u2__short = {
+ 2, 100,
+ (long *)_huff_lengthlist__16u2__short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__8u0__p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__8u0__p1_0[] = {
+ 1, 4, 4, 5, 7, 7, 5, 7, 7, 5, 8, 8, 8,10,10, 7,
+ 10,10, 5, 8, 8, 7,10,10, 8,10,10, 4, 9, 8, 8,11,
+ 11, 8,11,11, 7,11,11,10,11,13,10,13,13, 7,11,11,
+ 10,13,12,10,13,13, 5, 9, 8, 8,11,11, 8,11,11, 7,
+ 11,11, 9,13,13,10,12,13, 7,11,11,10,13,13,10,13,
+ 11,
+};
+
+static const static_codebook _8u0__p1_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__8u0__p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__8u0__p1_0,
+ 0
+};
+
+static const long _vq_quantlist__8u0__p2_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__8u0__p2_0[] = {
+ 2, 4, 4, 5, 6, 6, 5, 6, 6, 5, 7, 7, 6, 7, 8, 6,
+ 7, 8, 5, 7, 7, 6, 8, 8, 7, 9, 7, 5, 7, 7, 7, 9,
+ 9, 7, 8, 8, 6, 9, 8, 7, 7,10, 8,10,10, 6, 8, 8,
+ 8,10, 8, 8,10,10, 5, 7, 7, 7, 8, 8, 7, 8, 9, 6,
+ 8, 8, 8,10,10, 8, 8,10, 6, 8, 9, 8,10,10, 7,10,
+ 8,
+};
+
+static const static_codebook _8u0__p2_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__8u0__p2_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__8u0__p2_0,
+ 0
+};
+
+static const long _vq_quantlist__8u0__p3_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__8u0__p3_0[] = {
+ 1, 5, 5, 7, 7, 6, 7, 7, 9, 9, 6, 7, 7, 9, 9, 8,
+ 10, 9,11,11, 8, 9, 9,11,11, 6, 8, 8,10,10, 8,10,
+ 10,11,11, 8,10,10,11,11,10,11,11,12,12,10,11,11,
+ 12,13, 6, 8, 8,10,10, 8,10,10,11,11, 8,10,10,11,
+ 11, 9,10,11,12,12,10,11,11,12,12, 8,11,11,14,13,
+ 10,12,11,15,13,10,12,11,14,14,12,13,12,16,14,12,
+ 14,12,16,15, 8,11,11,13,14,10,11,12,13,15,10,11,
+ 12,13,15,11,12,13,14,15,12,12,14,14,16, 5, 8, 8,
+ 11,11, 9,11,11,12,12, 8,10,11,12,12,11,12,12,15,
+ 14,11,12,12,14,14, 7,11,10,13,12,10,11,12,13,14,
+ 10,12,12,14,13,12,13,13,14,15,12,13,13,15,15, 7,
+ 10,11,12,13,10,12,11,14,13,10,12,13,13,15,12,13,
+ 12,14,14,11,13,13,15,16, 9,12,12,15,14,11,13,13,
+ 15,16,11,13,13,16,16,13,14,15,15,15,12,14,15,17,
+ 16, 9,12,12,14,15,11,13,13,15,16,11,13,13,16,18,
+ 13,14,14,17,16,13,15,15,17,18, 5, 8, 9,11,11, 8,
+ 11,11,12,12, 8,10,11,12,12,11,12,12,14,14,11,12,
+ 12,14,15, 7,11,10,12,13,10,12,12,14,13,10,11,12,
+ 13,14,11,13,13,15,14,12,13,13,14,15, 7,10,11,13,
+ 13,10,12,12,13,14,10,12,12,13,13,11,13,13,16,16,
+ 12,13,13,15,14, 9,12,12,16,15,10,13,13,15,15,11,
+ 13,13,17,15,12,15,15,18,17,13,14,14,15,16, 9,12,
+ 12,15,15,11,13,13,15,16,11,13,13,15,15,12,15,15,
+ 16,16,13,15,14,17,15, 7,11,11,15,15,10,13,13,16,
+ 15,10,13,13,15,16,14,15,15,17,19,13,15,14,15,18,
+ 9,12,12,16,16,11,13,14,17,16,11,13,13,17,16,15,
+ 15,16,17,19,13,15,16, 0,18, 9,12,12,16,15,11,14,
+ 13,17,17,11,13,14,16,16,15,16,16,19,18,13,15,15,
+ 17,19,11,14,14,19,16,12,14,15, 0,18,12,16,15,18,
+ 17,15,15,18,16,19,14,15,17,19,19,11,14,14,18,19,
+ 13,15,14,19,19,12,16,15,18,17,15,17,15, 0,16,14,
+ 17,16,19, 0, 7,11,11,14,14,10,12,12,15,15,10,13,
+ 13,16,15,13,15,15,17, 0,14,15,15,16,19, 9,12,12,
+ 16,16,11,14,14,16,16,11,13,13,16,16,14,17,16,19,
+ 0,14,18,17,17,19, 9,12,12,15,16,11,13,13,15,17,
+ 12,14,13,19,16,13,15,15,17,19,15,17,16,17,19,11,
+ 14,14,19,16,12,15,15,19,17,13,14,15,17,19,14,16,
+ 17,19,19,16,15,16,17,19,11,15,14,16,16,12,15,15,
+ 19, 0,12,14,15,19,19,14,16,16, 0,18,15,19,14,18,
+ 16,
+};
+
+static const static_codebook _8u0__p3_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__8u0__p3_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__8u0__p3_0,
+ 0
+};
+
+static const long _vq_quantlist__8u0__p4_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__8u0__p4_0[] = {
+ 3, 5, 5, 8, 8, 5, 6, 7, 9, 9, 6, 7, 6, 9, 9, 9,
+ 9, 9,10,11, 9, 9, 9,11,10, 6, 7, 7,10,10, 7, 7,
+ 8,10,10, 7, 8, 8,10,10,10,10,10,10,11, 9,10,10,
+ 11,12, 6, 7, 7,10,10, 7, 8, 8,10,10, 7, 8, 7,10,
+ 10, 9,10,10,12,11,10,10,10,11,10, 9,10,10,12,11,
+ 10,10,10,13,11, 9,10,10,12,12,11,11,12,12,13,11,
+ 11,11,12,13, 9,10,10,12,12,10,10,11,12,12,10,10,
+ 11,12,12,11,11,11,13,13,11,12,12,13,13, 5, 7, 7,
+ 10,10, 7, 8, 8,10,10, 7, 8, 8,10,10,10,11,11,12,
+ 12,10,11,10,12,12, 7, 8, 8,11,11, 7, 8, 9,10,11,
+ 8, 9, 9,11,11,11,10,11,10,12,10,11,11,12,13, 7,
+ 8, 8,10,11, 8, 9, 8,12,10, 8, 9, 9,11,12,10,11,
+ 10,13,11,10,11,11,13,12, 9,11,10,13,12,10,10,11,
+ 12,12,10,11,11,13,13,12,10,13,11,14,11,12,12,15,
+ 13, 9,11,11,13,13,10,11,11,13,12,10,11,11,12,14,
+ 12,13,11,14,12,12,12,12,14,14, 5, 7, 7,10,10, 7,
+ 8, 8,10,10, 7, 8, 8,11,10,10,11,11,12,12,10,11,
+ 10,12,12, 7, 8, 8,10,11, 8, 9, 9,12,11, 8, 8, 9,
+ 10,11,10,11,11,12,13,11,10,11,11,13, 6, 8, 8,10,
+ 11, 8, 9, 9,11,11, 7, 9, 7,11,10,10,11,11,12,12,
+ 10,11,10,13,10, 9,11,10,13,12,10,12,11,13,13,10,
+ 10,11,12,13,11,12,13,15,14,11,11,13,12,13, 9,10,
+ 11,12,13,10,11,11,12,13,10,11,10,13,12,12,13,13,
+ 13,14,12,12,11,14,11, 8,10,10,12,13,10,11,11,13,
+ 13,10,11,10,13,13,12,13,14,15,14,12,12,12,14,13,
+ 9,10,10,13,12,10,10,12,13,13,10,11,11,15,12,12,
+ 12,13,15,14,12,13,13,15,13, 9,10,11,12,13,10,12,
+ 10,13,12,10,11,11,12,13,12,14,12,15,13,12,12,12,
+ 15,14,11,12,11,14,13,11,11,12,14,14,12,13,13,14,
+ 13,13,11,15,11,15,14,14,14,16,15,11,12,12,13,14,
+ 11,13,11,14,14,12,12,13,14,15,12,14,12,15,12,13,
+ 15,14,16,15, 8,10,10,12,12,10,10,10,12,13,10,11,
+ 11,13,13,12,12,12,13,14,13,13,13,15,15, 9,10,10,
+ 12,12,10,11,11,13,12,10,10,11,13,13,12,12,12,14,
+ 14,12,12,13,15,14, 9,10,10,13,12,10,10,12,12,13,
+ 10,11,10,13,13,12,13,13,14,14,12,13,12,14,13,11,
+ 12,12,14,13,12,13,12,14,14,10,12,12,14,14,14,14,
+ 14,16,14,13,12,14,12,15,10,12,12,14,15,12,13,13,
+ 14,16,11,12,11,15,14,13,14,14,14,15,13,14,11,14,
+ 12,
+};
+
+static const static_codebook _8u0__p4_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__8u0__p4_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__8u0__p4_0,
+ 0
+};
+
+static const long _vq_quantlist__8u0__p5_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__8u0__p5_0[] = {
+ 1, 4, 4, 7, 7, 7, 7, 9, 9, 4, 6, 6, 8, 7, 8, 8,
+ 10,10, 4, 6, 6, 8, 8, 8, 8,10,10, 6, 8, 8, 9, 9,
+ 9, 9,11,11, 7, 8, 8, 9, 9, 9, 9,11,11, 7, 8, 8,
+ 9, 9,10,10,12,11, 7, 8, 8, 9, 9,10,10,11,11, 9,
+ 10,10,11,11,11,12,12,12, 9,10,10,11,11,12,12,12,
+ 12,
+};
+
+static const static_codebook _8u0__p5_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__8u0__p5_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__8u0__p5_0,
+ 0
+};
+
+static const long _vq_quantlist__8u0__p6_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__8u0__p6_0[] = {
+ 1, 4, 4, 7, 7, 9, 9,11,11,12,12,16,16, 3, 6, 6,
+ 9, 9,11,11,12,12,13,14,18,16, 3, 6, 7, 9, 9,11,
+ 11,13,12,14,14,17,16, 7, 9, 9,11,11,12,12,14,14,
+ 14,14,17,16, 7, 9, 9,11,11,13,12,13,13,14,14,17,
+ 0, 9,11,11,12,13,14,14,14,13,15,14,17,17, 9,11,
+ 11,12,12,14,14,13,14,14,15, 0, 0,11,12,12,15,14,
+ 15,14,15,14,15,16,17, 0,11,12,13,13,13,14,14,15,
+ 14,15,15, 0, 0,12,14,14,15,15,14,16,15,15,17,16,
+ 0,18,13,14,14,15,14,15,14,15,16,17,16, 0, 0,17,
+ 17,18, 0,16,18,16, 0, 0, 0,17, 0, 0,16, 0, 0,16,
+ 16, 0,15, 0,17, 0, 0, 0, 0,
+};
+
+static const static_codebook _8u0__p6_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__8u0__p6_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__8u0__p6_0,
+ 0
+};
+
+static const long _vq_quantlist__8u0__p6_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__8u0__p6_1[] = {
+ 1, 4, 4, 6, 6, 4, 6, 5, 7, 7, 4, 5, 6, 7, 7, 6,
+ 7, 7, 7, 7, 6, 7, 7, 7, 7,
+};
+
+static const static_codebook _8u0__p6_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__8u0__p6_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__8u0__p6_1,
+ 0
+};
+
+static const long _vq_quantlist__8u0__p7_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__8u0__p7_0[] = {
+ 1, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7,
+};
+
+static const static_codebook _8u0__p7_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__8u0__p7_0,
+ 1, -518803456, 1628680192, 2, 0,
+ (long *)_vq_quantlist__8u0__p7_0,
+ 0
+};
+
+static const long _vq_quantlist__8u0__p7_1[] = {
+ 7,
+ 6,
+ 8,
+ 5,
+ 9,
+ 4,
+ 10,
+ 3,
+ 11,
+ 2,
+ 12,
+ 1,
+ 13,
+ 0,
+ 14,
+};
+
+static const long _vq_lengthlist__8u0__p7_1[] = {
+ 1, 5, 5, 5, 5,10,10,11,11,11,11,11,11,11,11, 5,
+ 7, 6, 8, 8, 9,10,11,11,11,11,11,11,11,11, 6, 6,
+ 7, 9, 7,11,10,11,11,11,11,11,11,11,11, 5, 6, 6,
+ 11, 8,11,11,11,11,11,11,11,11,11,11, 5, 6, 6, 9,
+ 10,11,10,11,11,11,11,11,11,11,11, 7,10,10,11,11,
+ 11,11,11,11,11,11,11,11,11,11, 7,11, 8,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,
+};
+
+static const static_codebook _8u0__p7_1 = {
+ 2, 225,
+ (long *)_vq_lengthlist__8u0__p7_1,
+ 1, -520986624, 1620377600, 4, 0,
+ (long *)_vq_quantlist__8u0__p7_1,
+ 0
+};
+
+static const long _vq_quantlist__8u0__p7_2[] = {
+ 10,
+ 9,
+ 11,
+ 8,
+ 12,
+ 7,
+ 13,
+ 6,
+ 14,
+ 5,
+ 15,
+ 4,
+ 16,
+ 3,
+ 17,
+ 2,
+ 18,
+ 1,
+ 19,
+ 0,
+ 20,
+};
+
+static const long _vq_lengthlist__8u0__p7_2[] = {
+ 1, 6, 5, 7, 7, 9, 9, 9, 9,10,12,12,10,11,11,10,
+ 11,11,11,10,11, 6, 8, 8, 9, 9,10,10, 9,10,11,11,
+ 10,11,11,11,11,10,11,11,11,11, 6, 7, 8, 9, 9, 9,
+ 10,11,10,11,12,11,10,11,11,11,11,11,11,12,10, 8,
+ 9, 9,10, 9,10,10, 9,10,10,10,10,10, 9,10,10,10,
+ 10, 9,10,10, 9, 9, 9, 9,10,10, 9, 9,10,10,11,10,
+ 9,12,10,11,10, 9,10,10,10, 8, 9, 9,10, 9,10, 9,
+ 9,10,10, 9,10, 9,11,10,10,10,10,10, 9,10, 8, 8,
+ 9, 9,10, 9,11, 9, 8, 9, 9,10,11,10,10,10,11,12,
+ 9, 9,11, 8, 9, 8,11,10,11,10,10, 9,11,10,10,10,
+ 10,10,10,10,11,11,11,11, 8, 9, 9, 9,10,10,10,11,
+ 11,12,11,12,11,10,10,10,12,11,11,11,10, 8,10, 9,
+ 11,10,10,11,12,10,11,12,11,11,12,11,12,12,10,11,
+ 11,10, 9, 9,10,11,12,10,10,10,11,10,11,11,10,12,
+ 12,10,11,10,11,12,10, 9,10,10,11,10,11,11,11,11,
+ 11,12,11,11,11, 9,11,10,11,10,11,10, 9, 9,10,11,
+ 11,11,10,10,11,12,12,11,12,11,11,11,12,12,12,12,
+ 11, 9,11,11,12,10,11,11,11,11,11,11,12,11,11,12,
+ 11,11,11,10,11,11, 9,11,10,11,11,11,10,10,10,11,
+ 11,11,12,10,11,10,11,11,11,11,12, 9,11,10,11,11,
+ 10,10,11,11, 9,11,11,12,10,10,10,10,10,11,11,10,
+ 9,10,11,11,12,11,10,10,12,11,11,12,11,12,11,11,
+ 10,10,11,11,10,12,11,10,11,10,11,10,10,10,11,11,
+ 10,10,11,11,11,11,10,10,10,12,11,11,11,11,10, 9,
+ 10,11,11,11,12,11,11,11,12,10,11,11,11, 9,10,11,
+ 11,11,11,11,11,10,10,11,11,12,11,10,11,12,11,10,
+ 10,11, 9,10,11,11,11,11,11,10,11,11,10,12,11,11,
+ 11,12,11,11,11,10,10,11,11,
+};
+
+static const static_codebook _8u0__p7_2 = {
+ 2, 441,
+ (long *)_vq_lengthlist__8u0__p7_2,
+ 1, -529268736, 1611661312, 5, 0,
+ (long *)_vq_quantlist__8u0__p7_2,
+ 0
+};
+
+static const long _huff_lengthlist__8u0__single[] = {
+ 4, 7,11, 9,12, 8, 7,10, 6, 4, 5, 5, 7, 5, 6,16,
+ 9, 5, 5, 6, 7, 7, 9,16, 7, 4, 6, 5, 7, 5, 7,17,
+ 10, 7, 7, 8, 7, 7, 8,18, 7, 5, 6, 4, 5, 4, 5,15,
+ 7, 6, 7, 5, 6, 4, 5,15,12,13,18,12,17,11, 9,17,
+};
+
+static const static_codebook _huff_book__8u0__single = {
+ 2, 64,
+ (long *)_huff_lengthlist__8u0__single,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__8u1__p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__8u1__p1_0[] = {
+ 1, 4, 4, 5, 7, 7, 5, 7, 7, 5, 8, 8, 7, 9,10, 7,
+ 9, 9, 5, 8, 8, 7,10, 9, 7, 9, 9, 5, 8, 8, 8,10,
+ 10, 8,10,10, 7,10,10, 9,10,12,10,12,12, 7,10,10,
+ 9,12,11,10,12,12, 5, 8, 8, 8,10,10, 8,10,10, 7,
+ 10,10,10,12,12, 9,11,12, 7,10,10,10,12,12, 9,12,
+ 10,
+};
+
+static const static_codebook _8u1__p1_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__8u1__p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__8u1__p1_0,
+ 0
+};
+
+static const long _vq_quantlist__8u1__p2_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__8u1__p2_0[] = {
+ 3, 4, 5, 5, 6, 6, 5, 6, 6, 5, 7, 6, 6, 7, 8, 6,
+ 7, 8, 5, 6, 6, 6, 8, 7, 6, 8, 7, 5, 6, 6, 7, 8,
+ 8, 6, 7, 7, 6, 8, 7, 7, 7, 9, 8, 9, 9, 6, 7, 8,
+ 7, 9, 7, 8, 9, 9, 5, 6, 6, 6, 7, 7, 7, 8, 8, 6,
+ 8, 7, 8, 9, 9, 7, 7, 9, 6, 7, 8, 8, 9, 9, 7, 9,
+ 7,
+};
+
+static const static_codebook _8u1__p2_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__8u1__p2_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__8u1__p2_0,
+ 0
+};
+
+static const long _vq_quantlist__8u1__p3_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__8u1__p3_0[] = {
+ 1, 5, 5, 7, 7, 6, 7, 7, 9, 9, 6, 7, 7, 9, 9, 8,
+ 10, 9,11,11, 9, 9, 9,11,11, 6, 8, 8,10,10, 8,10,
+ 10,11,11, 8, 9,10,11,11,10,11,11,12,12,10,11,11,
+ 12,13, 6, 8, 8,10,10, 8,10, 9,11,11, 8,10, 9,11,
+ 11,10,11,11,12,12,10,11,11,12,12, 9,11,11,14,13,
+ 10,12,11,14,14,10,12,11,14,13,12,13,13,15,14,12,
+ 13,13,15,14, 8,11,11,13,14,10,11,12,13,15,10,11,
+ 12,14,14,12,13,13,14,15,12,13,13,14,15, 5, 8, 8,
+ 11,11, 8,10,10,12,12, 8,10,10,12,12,11,12,12,14,
+ 13,11,12,12,13,14, 8,10,10,12,12, 9,11,12,13,14,
+ 10,12,12,13,13,12,12,13,14,14,11,13,13,15,15, 7,
+ 10,10,12,12, 9,12,11,14,12,10,11,12,13,14,12,13,
+ 12,14,14,12,13,13,15,16,10,12,12,15,14,11,12,13,
+ 15,15,11,13,13,15,16,14,14,15,15,16,13,14,15,17,
+ 15, 9,12,12,14,15,11,13,12,15,15,11,13,13,15,15,
+ 13,14,13,15,14,13,14,14,17, 0, 5, 8, 8,11,11, 8,
+ 10,10,12,12, 8,10,10,12,12,11,12,12,14,14,11,12,
+ 12,14,14, 7,10,10,12,12,10,12,12,13,13, 9,11,12,
+ 12,13,11,12,13,15,15,11,12,13,14,15, 8,10,10,12,
+ 12,10,12,11,13,13,10,12,11,13,13,11,13,13,15,14,
+ 12,13,12,15,13, 9,12,12,14,14,11,13,13,16,15,11,
+ 12,13,16,15,13,14,15,16,16,13,13,15,15,16,10,12,
+ 12,15,14,11,13,13,14,16,11,13,13,15,16,13,15,15,
+ 16,17,13,15,14,16,15, 8,11,11,14,15,10,12,12,15,
+ 15,10,12,12,15,16,14,15,15,16,17,13,14,14,16,16,
+ 9,12,12,15,15,11,13,14,15,17,11,13,13,15,16,14,
+ 15,16,19,17,13,15,15, 0,17, 9,12,12,15,15,11,14,
+ 13,16,15,11,13,13,15,16,15,15,15,18,17,13,15,15,
+ 17,17,11,15,14,18,16,12,14,15,17,17,12,15,15,18,
+ 18,15,15,16,15,19,14,16,16, 0, 0,11,14,14,16,17,
+ 12,15,14,18,17,12,15,15,18,18,15,17,15,18,16,14,
+ 16,16,18,18, 7,11,11,14,14,10,12,12,15,15,10,12,
+ 13,15,15,13,14,15,16,16,14,15,15,18,18, 9,12,12,
+ 15,15,11,13,13,16,15,11,12,13,16,16,14,15,15,17,
+ 16,15,16,16,17,17, 9,12,12,15,15,11,13,13,15,17,
+ 11,14,13,16,15,13,15,15,17,17,15,15,15,18,17,11,
+ 14,14,17,15,12,14,15,17,18,13,13,15,17,17,14,16,
+ 16,19,18,16,15,17,17, 0,11,14,14,17,17,12,15,15,
+ 18, 0,12,15,14,18,16,14,17,17,19, 0,16,18,15, 0,
+ 16,
+};
+
+static const static_codebook _8u1__p3_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__8u1__p3_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__8u1__p3_0,
+ 0
+};
+
+static const long _vq_quantlist__8u1__p4_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__8u1__p4_0[] = {
+ 4, 5, 5, 9, 9, 6, 7, 7, 9, 9, 6, 7, 7, 9, 9, 9,
+ 9, 9,11,11, 9, 9, 9,11,11, 6, 7, 7, 9, 9, 7, 7,
+ 8, 9,10, 7, 7, 8, 9,10, 9, 9,10,10,11, 9, 9,10,
+ 10,12, 6, 7, 7, 9, 9, 7, 8, 7,10, 9, 7, 8, 7,10,
+ 9, 9,10, 9,12,11,10,10, 9,12,10, 9,10,10,12,11,
+ 9,10,10,12,11, 9,10,10,12,12,11,11,12,12,13,11,
+ 11,12,12,13, 9, 9,10,12,11, 9,10,10,12,12,10,10,
+ 10,12,12,11,12,11,13,12,11,12,11,13,12, 6, 7, 7,
+ 9, 9, 7, 8, 8,10,10, 7, 8, 7,10, 9,10,10,10,12,
+ 12,10,10,10,12,11, 7, 8, 7,10,10, 7, 7, 9,10,11,
+ 8, 9, 9,11,10,10,10,11,10,12,10,10,11,12,12, 7,
+ 8, 8,10,10, 7, 9, 8,11,10, 8, 8, 9,11,11,10,11,
+ 10,12,11,10,11,11,12,12, 9,10,10,12,12, 9,10,10,
+ 12,12,10,11,11,13,12,11,10,12,10,14,12,12,12,13,
+ 14, 9,10,10,12,12, 9,11,10,12,12,10,11,11,12,12,
+ 11,12,11,14,12,12,12,12,14,14, 5, 7, 7, 9, 9, 7,
+ 7, 7, 9,10, 7, 8, 8,10,10,10,10,10,11,11,10,10,
+ 10,12,12, 7, 8, 8,10,10, 8, 9, 8,11,10, 7, 8, 9,
+ 10,11,10,10,10,11,12,10,10,11,11,13, 6, 7, 8,10,
+ 10, 8, 9, 9,10,10, 7, 9, 7,11,10,10,11,10,12,12,
+ 10,11,10,12,10, 9,10,10,12,12,10,11,11,13,12, 9,
+ 10,10,12,12,12,12,12,14,13,11,11,12,11,14, 9,10,
+ 10,11,12,10,11,11,12,13, 9,10,10,12,12,12,12,12,
+ 14,13,11,12,10,14,11, 9, 9,10,11,12, 9,10,10,12,
+ 12, 9,10,10,12,12,12,12,12,14,14,11,12,12,13,12,
+ 9,10, 9,12,12, 9,10,11,12,13,10,11,10,13,11,12,
+ 12,13,13,14,12,12,12,13,13, 9,10,10,12,12,10,11,
+ 10,13,12,10,10,11,12,13,12,13,12,14,13,12,12,12,
+ 13,14,11,12,11,14,13,10,10,11,13,13,12,12,12,14,
+ 13,12,10,14,10,15,13,14,14,14,14,11,11,12,13,14,
+ 10,12,11,13,13,12,12,12,13,15,12,13,11,15,12,13,
+ 13,14,14,14, 9,10, 9,12,12, 9,10,10,12,12,10,10,
+ 10,12,12,11,11,12,12,13,12,12,12,14,14, 9,10,10,
+ 12,12,10,11,10,13,12,10,10,11,12,13,12,12,12,14,
+ 13,12,12,13,13,14, 9,10,10,12,13,10,10,11,11,12,
+ 9,11,10,13,12,12,12,12,13,14,12,13,12,14,13,11,
+ 12,11,13,13,12,13,12,14,13,10,11,12,13,13,13,13,
+ 13,14,15,12,11,14,12,14,11,11,12,12,13,12,12,12,
+ 13,14,10,12,10,14,13,13,13,13,14,15,12,14,11,15,
+ 10,
+};
+
+static const static_codebook _8u1__p4_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__8u1__p4_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__8u1__p4_0,
+ 0
+};
+
+static const long _vq_quantlist__8u1__p5_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__8u1__p5_0[] = {
+ 1, 4, 4, 7, 7, 7, 7, 9, 9, 4, 6, 5, 8, 7, 8, 8,
+ 10,10, 4, 6, 6, 8, 8, 8, 8,10,10, 7, 8, 8, 9, 9,
+ 9, 9,11,11, 7, 8, 8, 9, 9, 9, 9,11,11, 8, 8, 8,
+ 9, 9,10,10,12,11, 8, 8, 8, 9, 9,10,10,11,11, 9,
+ 10,10,11,11,11,11,13,12, 9,10,10,11,11,12,12,12,
+ 13,
+};
+
+static const static_codebook _8u1__p5_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__8u1__p5_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__8u1__p5_0,
+ 0
+};
+
+static const long _vq_quantlist__8u1__p6_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__8u1__p6_0[] = {
+ 3, 4, 4, 6, 6, 7, 7, 9, 9, 4, 4, 5, 6, 6, 7, 7,
+ 9, 9, 4, 4, 4, 6, 6, 7, 7, 9, 9, 6, 6, 6, 7, 7,
+ 8, 8, 9, 9, 6, 6, 6, 7, 7, 8, 8, 9, 9, 7, 7, 7,
+ 8, 8, 8, 9,10,10, 7, 7, 7, 8, 8, 9, 8,10,10, 9,
+ 9, 9, 9, 9,10,10,10,10, 9, 9, 9, 9, 9,10,10,10,
+ 10,
+};
+
+static const static_codebook _8u1__p6_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__8u1__p6_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__8u1__p6_0,
+ 0
+};
+
+static const long _vq_quantlist__8u1__p7_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__8u1__p7_0[] = {
+ 1, 4, 4, 5, 7, 7, 5, 7, 7, 5, 9, 9, 8,10,10, 8,
+ 10,10, 5, 9, 9, 7,10,10, 8,10,10, 4,10,10, 9,12,
+ 12, 9,11,11, 7,12,11,10,11,13,10,13,13, 7,12,12,
+ 10,13,12,10,13,13, 4,10,10, 9,12,12, 9,12,12, 7,
+ 12,12,10,13,13,10,12,13, 7,11,12,10,13,13,10,13,
+ 11,
+};
+
+static const static_codebook _8u1__p7_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__8u1__p7_0,
+ 1, -529137664, 1618345984, 2, 0,
+ (long *)_vq_quantlist__8u1__p7_0,
+ 0
+};
+
+static const long _vq_quantlist__8u1__p7_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__8u1__p7_1[] = {
+ 2, 4, 4, 6, 6, 7, 7, 8, 8, 8, 8, 4, 5, 5, 7, 7,
+ 8, 8, 9, 9, 9, 9, 4, 5, 5, 7, 7, 8, 8, 9, 9, 9,
+ 9, 6, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 6, 7, 7, 8,
+ 8, 8, 8, 9, 9, 9, 9, 8, 8, 8, 8, 8, 9, 9, 9, 9,
+ 9, 9, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 8, 9, 9,
+ 9, 9, 9, 9,10,10,10,10, 8, 9, 9, 9, 9, 9, 9,10,
+ 10,10,10, 8, 9, 9, 9, 9, 9, 9,10,10,10,10, 8, 9,
+ 9, 9, 9, 9, 9,10,10,10,10,
+};
+
+static const static_codebook _8u1__p7_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__8u1__p7_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__8u1__p7_1,
+ 0
+};
+
+static const long _vq_quantlist__8u1__p8_0[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__8u1__p8_0[] = {
+ 1, 4, 4, 6, 6, 8, 8,10,10,11,11, 4, 6, 6, 7, 7,
+ 9, 9,11,11,13,12, 4, 6, 6, 7, 7, 9, 9,11,11,12,
+ 12, 6, 7, 7, 9, 9,11,11,12,12,13,13, 6, 7, 7, 9,
+ 9,11,11,12,12,13,13, 8, 9, 9,11,11,12,12,13,13,
+ 14,14, 8, 9, 9,11,11,12,12,13,13,14,14, 9,11,11,
+ 12,12,13,13,14,14,15,15, 9,11,11,12,12,13,13,14,
+ 14,15,14,11,12,12,13,13,14,14,15,15,16,16,11,12,
+ 12,13,13,14,14,15,15,15,15,
+};
+
+static const static_codebook _8u1__p8_0 = {
+ 2, 121,
+ (long *)_vq_lengthlist__8u1__p8_0,
+ 1, -524582912, 1618345984, 4, 0,
+ (long *)_vq_quantlist__8u1__p8_0,
+ 0
+};
+
+static const long _vq_quantlist__8u1__p8_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__8u1__p8_1[] = {
+ 2, 5, 5, 6, 6, 7, 7, 7, 7, 8, 8, 5, 6, 6, 7, 7,
+ 7, 7, 8, 8, 8, 8, 5, 6, 6, 7, 7, 7, 7, 8, 8, 8,
+ 8, 6, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 6, 7, 7, 7,
+ 7, 8, 8, 8, 8, 8, 8, 7, 7, 7, 8, 8, 8, 8, 8, 8,
+ 8, 8, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 9, 8, 9, 9, 7, 8, 8, 8, 8, 8, 8, 9,
+ 8, 9, 9, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 8, 8,
+ 8, 8, 8, 8, 8, 9, 9, 9, 9,
+};
+
+static const static_codebook _8u1__p8_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__8u1__p8_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__8u1__p8_1,
+ 0
+};
+
+static const long _vq_quantlist__8u1__p9_0[] = {
+ 7,
+ 6,
+ 8,
+ 5,
+ 9,
+ 4,
+ 10,
+ 3,
+ 11,
+ 2,
+ 12,
+ 1,
+ 13,
+ 0,
+ 14,
+};
+
+static const long _vq_lengthlist__8u1__p9_0[] = {
+ 1, 4, 4,11,11,11,11,11,11,11,11,11,11,11,11, 3,
+ 11, 8,11,11,11,11,11,11,11,11,11,11,11,11, 3, 9,
+ 9,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,
+};
+
+static const static_codebook _8u1__p9_0 = {
+ 2, 225,
+ (long *)_vq_lengthlist__8u1__p9_0,
+ 1, -514071552, 1627381760, 4, 0,
+ (long *)_vq_quantlist__8u1__p9_0,
+ 0
+};
+
+static const long _vq_quantlist__8u1__p9_1[] = {
+ 7,
+ 6,
+ 8,
+ 5,
+ 9,
+ 4,
+ 10,
+ 3,
+ 11,
+ 2,
+ 12,
+ 1,
+ 13,
+ 0,
+ 14,
+};
+
+static const long _vq_lengthlist__8u1__p9_1[] = {
+ 1, 4, 4, 7, 7, 9, 9, 7, 7, 8, 8,10,10,11,11, 4,
+ 7, 7, 9, 9,10,10, 8, 8,10,10,10,11,10,11, 4, 7,
+ 7, 9, 9,10,10, 8, 8,10, 9,11,11,11,11, 7, 9, 9,
+ 12,12,11,12,10,10,11,10,12,11,11,11, 7, 9, 9,11,
+ 11,13,12, 9, 9,11,10,11,11,12,11, 9,10,10,12,12,
+ 14,14,10,10,11,12,12,11,11,11, 9,10,11,11,13,14,
+ 13,10,11,11,11,12,11,12,12, 7, 8, 8,10, 9,11,10,
+ 11,12,12,11,12,14,12,13, 7, 8, 8, 9,10,10,11,12,
+ 12,12,11,12,12,12,13, 9, 9, 9,11,11,13,12,12,12,
+ 12,11,12,12,13,12, 8,10,10,11,10,11,12,12,12,12,
+ 12,12,14,12,12, 9,11,11,11,12,12,12,12,13,13,12,
+ 12,13,13,12,10,11,11,12,11,12,12,12,11,12,13,12,
+ 12,12,13,11,11,12,12,12,13,12,12,11,12,13,13,12,
+ 12,13,12,11,12,12,13,13,12,13,12,13,13,13,13,14,
+ 13,
+};
+
+static const static_codebook _8u1__p9_1 = {
+ 2, 225,
+ (long *)_vq_lengthlist__8u1__p9_1,
+ 1, -522338304, 1620115456, 4, 0,
+ (long *)_vq_quantlist__8u1__p9_1,
+ 0
+};
+
+static const long _vq_quantlist__8u1__p9_2[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__8u1__p9_2[] = {
+ 2, 5, 4, 6, 6, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9,
+ 9, 5, 6, 6, 7, 7, 8, 8, 9, 8, 9, 9, 9, 9, 9, 9,
+ 9, 9, 5, 6, 6, 7, 7, 8, 8, 8, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 7, 7, 7, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9,10,10, 9, 7, 7, 7, 8, 8, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9,10,10, 8, 8, 8, 9, 9, 9, 9,10,10,10, 9,
+ 10,10,10,10,10,10, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9,
+ 10,10,10,10,10,10,10, 9, 9, 9, 9, 9, 9, 9, 9,10,
+ 10,10,10,10,10,10,10,10, 9, 9, 9, 9, 9,10,10,10,
+ 10,10,10,10,10,10,10,10,10, 9, 9, 9, 9, 9, 9,10,
+ 10,10,10,10,10,10,10,10,10,10, 9, 9, 9, 9, 9,10,
+ 10,10,10,10,10,10,10,10,10,10,10, 9, 9, 9, 9,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10, 9, 9, 9, 9,
+ 9,10,10,10,10,10,10,10,10,10,10,10,10, 9, 9, 9,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10, 9,10,
+ 9, 9, 9,10,10,10,10,10,10,10,10,10,10,10,10, 9,
+ 10, 9,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 9, 9,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,
+};
+
+static const static_codebook _8u1__p9_2 = {
+ 2, 289,
+ (long *)_vq_lengthlist__8u1__p9_2,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__8u1__p9_2,
+ 0
+};
+
+static const long _huff_lengthlist__8u1__single[] = {
+ 4, 7,13, 9,15, 9,16, 8,10,13, 7, 5, 8, 6, 9, 7,
+ 10, 7,10,11,11, 6, 7, 8, 8, 9, 9, 9,12,16, 8, 5,
+ 8, 6, 8, 6, 9, 7,10,12,11, 7, 7, 7, 6, 7, 7, 7,
+ 11,15, 7, 5, 8, 6, 7, 5, 7, 6, 9,13,13, 9, 9, 8,
+ 6, 6, 5, 5, 9,14, 8, 6, 8, 6, 6, 4, 5, 3, 5,13,
+ 9, 9,11, 8,10, 7, 8, 4, 5,12,11,16,17,15,17,12,
+ 13, 8, 8,15,
+};
+
+static const static_codebook _huff_book__8u1__single = {
+ 2, 100,
+ (long *)_huff_lengthlist__8u1__single,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44u0__long[] = {
+ 5, 8,13,10,17,11,11,15, 7, 2, 4, 5, 8, 7, 9,16,
+ 13, 4, 3, 5, 6, 8,11,20,10, 4, 5, 5, 7, 6, 8,18,
+ 15, 7, 6, 7, 8,10,14,20,10, 6, 7, 6, 9, 7, 8,17,
+ 9, 8,10, 8,10, 5, 4,11,12,17,19,14,16,10, 7,12,
+};
+
+static const static_codebook _huff_book__44u0__long = {
+ 2, 64,
+ (long *)_huff_lengthlist__44u0__long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44u0__p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44u0__p1_0[] = {
+ 1, 4, 4, 5, 8, 7, 5, 7, 8, 5, 8, 8, 8,11,11, 8,
+ 10,10, 5, 8, 8, 8,11,10, 8,11,11, 4, 8, 8, 8,11,
+ 11, 8,11,11, 8,12,11,11,13,13,11,13,14, 7,11,11,
+ 10,13,12,11,13,14, 4, 8, 8, 8,11,11, 8,11,12, 8,
+ 11,11,11,13,13,10,12,13, 8,11,11,11,14,13,11,14,
+ 13,
+};
+
+static const static_codebook _44u0__p1_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44u0__p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44u0__p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44u0__p2_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44u0__p2_0[] = {
+ 2, 4, 4, 5, 6, 6, 5, 6, 6, 5, 7, 7, 7, 8, 8, 6,
+ 8, 8, 5, 7, 7, 6, 8, 8, 7, 8, 8, 4, 7, 7, 7, 8,
+ 8, 7, 8, 8, 7, 8, 8, 8, 9,10, 8,10,10, 6, 8, 8,
+ 8,10, 8, 8,10,10, 5, 7, 7, 7, 8, 8, 7, 8, 8, 6,
+ 8, 8, 8,10,10, 8, 8,10, 6, 8, 8, 8,10,10, 8,10,
+ 9,
+};
+
+static const static_codebook _44u0__p2_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44u0__p2_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44u0__p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44u0__p3_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44u0__p3_0[] = {
+ 1, 5, 5, 8, 8, 5, 8, 7, 9, 9, 5, 7, 8, 9, 9, 9,
+ 10, 9,12,12, 9, 9,10,12,12, 6, 8, 8,11,10, 8,10,
+ 10,11,11, 8, 9,10,11,11,10,11,11,14,13,10,11,11,
+ 13,13, 5, 8, 8,10,10, 8,10,10,11,11, 8,10,10,11,
+ 11,10,11,11,13,13,10,11,11,13,13, 9,11,11,15,14,
+ 10,12,12,15,14,10,12,11,15,14,13,14,14,16,16,12,
+ 14,13,17,15, 9,11,11,14,15,10,11,12,14,16,10,11,
+ 12,14,16,12,13,14,16,16,13,13,15,15,18, 5, 8, 8,
+ 11,11, 8,10,10,12,12, 8,10,10,12,13,11,12,12,14,
+ 14,11,12,12,15,15, 8,10,10,13,13,10,12,12,13,13,
+ 10,12,12,14,14,12,13,13,15,15,12,13,13,16,16, 7,
+ 10,10,12,12,10,12,11,13,13,10,12,12,13,14,12,13,
+ 12,15,14,12,13,13,16,16,10,12,12,17,16,12,13,13,
+ 16,15,11,13,13,17,17,15,15,15,16,17,14,15,15,19,
+ 19,10,12,12,15,16,11,13,12,15,18,11,13,13,16,16,
+ 14,15,15,17,17,14,15,15,17,19, 5, 8, 8,11,11, 8,
+ 10,10,12,12, 8,10,10,12,12,11,12,12,16,15,11,12,
+ 12,14,15, 7,10,10,13,13,10,12,12,14,13,10,11,12,
+ 13,13,12,13,13,16,16,12,12,13,15,15, 8,10,10,13,
+ 13,10,12,12,14,14,10,12,12,13,13,12,13,13,16,16,
+ 12,13,13,15,15,10,12,12,16,15,11,13,13,17,16,11,
+ 12,13,16,15,13,15,15,19,17,14,15,14,17,16,10,12,
+ 12,16,16,11,13,13,16,17,12,13,13,15,17,14,15,15,
+ 17,19,14,15,15,17,17, 8,11,11,16,16,10,13,12,17,
+ 17,10,12,13,16,16,15,17,16,20,19,14,15,17,18,19,
+ 9,12,12,16,17,11,13,14,17,18,11,13,13,19,18,16,
+ 17,18,19,19,15,16,16,19,19, 9,12,12,16,17,11,14,
+ 13,18,17,11,13,13,17,17,16,17,16,20,19,14,16,16,
+ 18,18,12,15,15,19,17,14,15,16, 0,20,13,15,16,20,
+ 17,18,16,20, 0, 0,15,16,19,20, 0,12,15,14,18,19,
+ 13,16,15,20,19,13,16,15,20,18,17,18,17, 0,20,16,
+ 17,16, 0, 0, 8,11,11,16,15,10,12,12,17,17,10,13,
+ 13,17,16,14,16,15,18,20,15,16,16,19,19, 9,12,12,
+ 16,16,11,13,13,17,16,11,13,14,17,18,15,15,16,20,
+ 20,16,16,17,19,19, 9,13,12,16,17,11,14,13,17,17,
+ 11,14,14,18,17,14,16,15,18,19,16,17,18,18,19,12,
+ 14,15,19,18,13,15,16,18, 0,13,14,15, 0, 0,16,16,
+ 17,20, 0,17,17,20,20, 0,12,15,15,19,20,13,15,15,
+ 0, 0,14,16,15, 0, 0,15,18,16, 0, 0,17,18,16, 0,
+ 19,
+};
+
+static const static_codebook _44u0__p3_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44u0__p3_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44u0__p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44u0__p4_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44u0__p4_0[] = {
+ 4, 5, 5, 9, 9, 5, 6, 6, 9, 9, 5, 6, 6, 9, 9, 9,
+ 10, 9,12,12, 9, 9,10,12,12, 5, 7, 7,10,10, 7, 7,
+ 8,10,10, 6, 7, 8,10,10,10,10,10,11,13,10, 9,10,
+ 12,13, 5, 7, 7,10,10, 6, 8, 7,10,10, 7, 8, 7,10,
+ 10, 9,10,10,12,12,10,10,10,13,11, 9,10,10,13,13,
+ 10,11,10,13,13,10,10,10,13,13,12,12,13,14,14,12,
+ 12,13,14,14, 9,10,10,13,13,10,10,10,13,13,10,10,
+ 10,13,13,12,13,12,15,14,12,13,12,15,15, 5, 7, 6,
+ 10,10, 7, 8, 8,10,10, 7, 8, 8,10,10,10,11,10,13,
+ 13,10,10,10,12,12, 7, 8, 8,11,10, 8, 8, 9,10,11,
+ 8, 9, 9,11,11,11,10,11,11,14,11,11,11,13,13, 6,
+ 8, 8,10,10, 7, 9, 8,11,10, 8, 9, 9,11,11,10,11,
+ 10,14,11,10,11,11,13,13,10,11,11,14,13,10,10,11,
+ 14,13,10,11,11,14,14,12,11,13,12,16,13,14,14,15,
+ 15,10,10,11,13,14,10,11,10,14,13,10,11,11,14,14,
+ 12,13,12,15,13,13,13,14,15,16, 5, 7, 7,10,10, 7,
+ 8, 8,10,10, 7, 8, 8,10,10,10,10,10,13,13,10,10,
+ 11,12,13, 6, 8, 8,11,10, 8, 9, 9,11,11, 7, 8, 9,
+ 10,11,10,11,11,13,13,10,10,11,11,13, 6, 8, 8,10,
+ 11, 8, 9, 9,11,11, 8, 9, 8,12,10,10,11,11,13,13,
+ 10,11,10,14,11,10,10,10,14,13,10,11,11,14,13,10,
+ 10,11,13,13,12,14,14,16,16,12,12,13,13,15,10,11,
+ 11,13,14,10,11,11,14,15,10,11,10,13,13,13,14,13,
+ 16,16,12,13,11,15,12, 9,10,10,13,13,10,11,11,14,
+ 13,10,10,11,13,14,13,14,13,16,16,13,13,13,15,16,
+ 9,10,10,13,13,10,10,11,13,14,10,11,11,15,13,13,
+ 13,14,14,18,13,13,14,16,15, 9,10,10,13,14,10,11,
+ 10,14,13,10,11,11,13,14,13,14,13,16,15,13,13,14,
+ 15,16,12,13,12,16,14,11,11,13,15,15,13,14,13,16,
+ 15,15,12,16,12,17,14,15,15,17,17,12,13,13,14,16,
+ 11,13,11,16,15,12,13,14,15,16,14,15,13, 0,14,14,
+ 16,16, 0, 0, 9,10,10,13,13,10,11,10,14,14,10,11,
+ 11,13,13,12,13,13,14,16,13,14,14,16,16, 9,10,10,
+ 14,14,11,11,11,14,13,10,10,11,14,14,13,13,13,16,
+ 16,13,13,14,14,17, 9,10,10,13,14,10,11,11,13,15,
+ 10,11,10,14,14,13,13,13,14,17,13,14,13,17,14,12,
+ 13,13,16,14,13,14,13,16,15,12,12,13,15,16,15,15,
+ 16,18,16,15,13,15,14, 0,12,12,13,14,16,13,13,14,
+ 15,16,11,12,11,16,14,15,16,16,17,17,14,15,12,17,
+ 12,
+};
+
+static const static_codebook _44u0__p4_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44u0__p4_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44u0__p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44u0__p5_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44u0__p5_0[] = {
+ 1, 4, 4, 7, 7, 7, 7, 9, 9, 4, 6, 6, 8, 8, 8, 8,
+ 9, 9, 4, 6, 6, 8, 8, 8, 8, 9, 9, 7, 8, 8, 9, 9,
+ 9, 9,11,10, 7, 8, 8, 9, 9, 9, 9,10,10, 7, 8, 8,
+ 9, 9,10,10,11,11, 7, 8, 8, 9, 9,10,10,11,11, 9,
+ 9, 9,10,10,11,11,12,12, 9, 9, 9,10,11,11,11,12,
+ 12,
+};
+
+static const static_codebook _44u0__p5_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44u0__p5_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44u0__p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44u0__p6_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44u0__p6_0[] = {
+ 1, 4, 4, 6, 6, 8, 8,10, 9,11,10,14,13, 4, 6, 5,
+ 8, 8, 9, 9,11,10,11,11,14,14, 4, 5, 6, 8, 8, 9,
+ 9,10,10,11,11,14,14, 6, 8, 8, 9, 9,10,10,11,11,
+ 12,12,16,15, 7, 8, 8, 9, 9,10,10,11,11,12,12,15,
+ 15, 9,10,10,10,10,11,11,12,12,12,12,15,15, 9,10,
+ 9,10,11,11,11,12,12,12,13,15,15,10,10,11,11,11,
+ 12,12,13,12,13,13,16,15,10,11,11,11,11,12,12,13,
+ 12,13,13,16,17,11,11,12,12,12,13,13,13,14,14,15,
+ 17,17,11,11,12,12,12,13,13,13,14,14,14,16,18,14,
+ 15,15,15,15,16,16,16,16,17,18, 0, 0,14,15,15,15,
+ 15,17,16,17,18,17,17,18, 0,
+};
+
+static const static_codebook _44u0__p6_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44u0__p6_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44u0__p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44u0__p6_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44u0__p6_1[] = {
+ 2, 4, 4, 5, 5, 4, 5, 5, 5, 5, 4, 5, 5, 5, 5, 5,
+ 6, 6, 6, 6, 5, 6, 6, 6, 6,
+};
+
+static const static_codebook _44u0__p6_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44u0__p6_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44u0__p6_1,
+ 0
+};
+
+static const long _vq_quantlist__44u0__p7_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44u0__p7_0[] = {
+ 1, 4, 4,11,11, 9,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11, 9,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,10,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,
+};
+
+static const static_codebook _44u0__p7_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44u0__p7_0,
+ 1, -518709248, 1626677248, 3, 0,
+ (long *)_vq_quantlist__44u0__p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44u0__p7_1[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44u0__p7_1[] = {
+ 1, 4, 4, 6, 6, 6, 6, 7, 7, 8, 8, 9, 9, 5, 7, 7,
+ 8, 7, 7, 7, 9, 8,10, 9,10,11, 5, 7, 7, 8, 8, 7,
+ 7, 8, 9,10,10,11,11, 6, 8, 8, 9, 9, 9, 9,11,10,
+ 12,12,15,12, 6, 8, 8, 9, 9, 9, 9,11,11,12,11,14,
+ 12, 7, 8, 8,10,10,12,12,13,13,13,15,13,13, 7, 8,
+ 8,10,10,11,11,13,12,14,15,15,15, 9,10,10,11,12,
+ 13,13,14,15,14,15,14,15, 8,10,10,12,12,14,14,15,
+ 14,14,15,15,14,10,12,12,14,14,15,14,15,15,15,14,
+ 15,15,10,12,12,13,14,15,14,15,15,14,15,15,15,12,
+ 15,13,15,14,15,15,15,15,15,15,15,15,13,13,15,15,
+ 15,15,15,15,15,15,15,15,15,
+};
+
+static const static_codebook _44u0__p7_1 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44u0__p7_1,
+ 1, -523010048, 1618608128, 4, 0,
+ (long *)_vq_quantlist__44u0__p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44u0__p7_2[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44u0__p7_2[] = {
+ 2, 5, 4, 6, 6, 7, 7, 8, 8, 8, 8, 9, 8, 5, 5, 6,
+ 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 5, 6, 5, 7, 7, 8,
+ 8, 8, 8, 9, 9, 9, 9, 6, 7, 7, 8, 8, 8, 8, 9, 8,
+ 9, 9, 9, 9, 6, 7, 7, 8, 7, 8, 8, 9, 9, 9, 9, 9,
+ 9, 7, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 7, 8,
+ 8, 9, 8, 9, 8, 9, 9, 9, 9, 9, 9, 8, 9, 8, 9, 9,
+ 9, 9, 9, 9, 9, 9,10,10, 8, 8, 9, 9, 9, 9, 9, 9,
+ 9, 9,10, 9,10, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9,10,10,10, 9, 9, 9, 9, 9,
+ 9, 9, 9,10, 9, 9,10,10, 9,
+};
+
+static const static_codebook _44u0__p7_2 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44u0__p7_2,
+ 1, -531103744, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44u0__p7_2,
+ 0
+};
+
+static const long _huff_lengthlist__44u0__short[] = {
+ 12,13,14,13,17,12,15,17, 5, 5, 6,10,10,11,15,16,
+ 4, 3, 3, 7, 5, 7,10,16, 7, 7, 7,10, 9,11,12,16,
+ 6, 5, 5, 9, 5, 6,10,16, 8, 7, 7, 9, 6, 7, 9,16,
+ 11, 7, 3, 6, 4, 5, 8,16,12, 9, 4, 8, 5, 7, 9,16,
+};
+
+static const static_codebook _huff_book__44u0__short = {
+ 2, 64,
+ (long *)_huff_lengthlist__44u0__short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44u1__long[] = {
+ 5, 8,13,10,17,11,11,15, 7, 2, 4, 5, 8, 7, 9,16,
+ 13, 4, 3, 5, 6, 8,11,20,10, 4, 5, 5, 7, 6, 8,18,
+ 15, 7, 6, 7, 8,10,14,20,10, 6, 7, 6, 9, 7, 8,17,
+ 9, 8,10, 8,10, 5, 4,11,12,17,19,14,16,10, 7,12,
+};
+
+static const static_codebook _huff_book__44u1__long = {
+ 2, 64,
+ (long *)_huff_lengthlist__44u1__long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44u1__p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44u1__p1_0[] = {
+ 1, 4, 4, 5, 8, 7, 5, 7, 8, 5, 8, 8, 8,11,11, 8,
+ 10,10, 5, 8, 8, 8,11,10, 8,11,11, 4, 8, 8, 8,11,
+ 11, 8,11,11, 8,12,11,11,13,13,11,13,14, 7,11,11,
+ 10,13,12,11,13,14, 4, 8, 8, 8,11,11, 8,11,12, 8,
+ 11,11,11,13,13,10,12,13, 8,11,11,11,14,13,11,14,
+ 13,
+};
+
+static const static_codebook _44u1__p1_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44u1__p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44u1__p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44u1__p2_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44u1__p2_0[] = {
+ 2, 4, 4, 5, 6, 6, 5, 6, 6, 5, 7, 7, 7, 8, 8, 6,
+ 8, 8, 5, 7, 7, 6, 8, 8, 7, 8, 8, 4, 7, 7, 7, 8,
+ 8, 7, 8, 8, 7, 8, 8, 8, 9,10, 8,10,10, 6, 8, 8,
+ 8,10, 8, 8,10,10, 5, 7, 7, 7, 8, 8, 7, 8, 8, 6,
+ 8, 8, 8,10,10, 8, 8,10, 6, 8, 8, 8,10,10, 8,10,
+ 9,
+};
+
+static const static_codebook _44u1__p2_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44u1__p2_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44u1__p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44u1__p3_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44u1__p3_0[] = {
+ 1, 5, 5, 8, 8, 5, 8, 7, 9, 9, 5, 7, 8, 9, 9, 9,
+ 10, 9,12,12, 9, 9,10,12,12, 6, 8, 8,11,10, 8,10,
+ 10,11,11, 8, 9,10,11,11,10,11,11,14,13,10,11,11,
+ 13,13, 5, 8, 8,10,10, 8,10,10,11,11, 8,10,10,11,
+ 11,10,11,11,13,13,10,11,11,13,13, 9,11,11,15,14,
+ 10,12,12,15,14,10,12,11,15,14,13,14,14,16,16,12,
+ 14,13,17,15, 9,11,11,14,15,10,11,12,14,16,10,11,
+ 12,14,16,12,13,14,16,16,13,13,15,15,18, 5, 8, 8,
+ 11,11, 8,10,10,12,12, 8,10,10,12,13,11,12,12,14,
+ 14,11,12,12,15,15, 8,10,10,13,13,10,12,12,13,13,
+ 10,12,12,14,14,12,13,13,15,15,12,13,13,16,16, 7,
+ 10,10,12,12,10,12,11,13,13,10,12,12,13,14,12,13,
+ 12,15,14,12,13,13,16,16,10,12,12,17,16,12,13,13,
+ 16,15,11,13,13,17,17,15,15,15,16,17,14,15,15,19,
+ 19,10,12,12,15,16,11,13,12,15,18,11,13,13,16,16,
+ 14,15,15,17,17,14,15,15,17,19, 5, 8, 8,11,11, 8,
+ 10,10,12,12, 8,10,10,12,12,11,12,12,16,15,11,12,
+ 12,14,15, 7,10,10,13,13,10,12,12,14,13,10,11,12,
+ 13,13,12,13,13,16,16,12,12,13,15,15, 8,10,10,13,
+ 13,10,12,12,14,14,10,12,12,13,13,12,13,13,16,16,
+ 12,13,13,15,15,10,12,12,16,15,11,13,13,17,16,11,
+ 12,13,16,15,13,15,15,19,17,14,15,14,17,16,10,12,
+ 12,16,16,11,13,13,16,17,12,13,13,15,17,14,15,15,
+ 17,19,14,15,15,17,17, 8,11,11,16,16,10,13,12,17,
+ 17,10,12,13,16,16,15,17,16,20,19,14,15,17,18,19,
+ 9,12,12,16,17,11,13,14,17,18,11,13,13,19,18,16,
+ 17,18,19,19,15,16,16,19,19, 9,12,12,16,17,11,14,
+ 13,18,17,11,13,13,17,17,16,17,16,20,19,14,16,16,
+ 18,18,12,15,15,19,17,14,15,16, 0,20,13,15,16,20,
+ 17,18,16,20, 0, 0,15,16,19,20, 0,12,15,14,18,19,
+ 13,16,15,20,19,13,16,15,20,18,17,18,17, 0,20,16,
+ 17,16, 0, 0, 8,11,11,16,15,10,12,12,17,17,10,13,
+ 13,17,16,14,16,15,18,20,15,16,16,19,19, 9,12,12,
+ 16,16,11,13,13,17,16,11,13,14,17,18,15,15,16,20,
+ 20,16,16,17,19,19, 9,13,12,16,17,11,14,13,17,17,
+ 11,14,14,18,17,14,16,15,18,19,16,17,18,18,19,12,
+ 14,15,19,18,13,15,16,18, 0,13,14,15, 0, 0,16,16,
+ 17,20, 0,17,17,20,20, 0,12,15,15,19,20,13,15,15,
+ 0, 0,14,16,15, 0, 0,15,18,16, 0, 0,17,18,16, 0,
+ 19,
+};
+
+static const static_codebook _44u1__p3_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44u1__p3_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44u1__p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44u1__p4_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44u1__p4_0[] = {
+ 4, 5, 5, 9, 9, 5, 6, 6, 9, 9, 5, 6, 6, 9, 9, 9,
+ 10, 9,12,12, 9, 9,10,12,12, 5, 7, 7,10,10, 7, 7,
+ 8,10,10, 6, 7, 8,10,10,10,10,10,11,13,10, 9,10,
+ 12,13, 5, 7, 7,10,10, 6, 8, 7,10,10, 7, 8, 7,10,
+ 10, 9,10,10,12,12,10,10,10,13,11, 9,10,10,13,13,
+ 10,11,10,13,13,10,10,10,13,13,12,12,13,14,14,12,
+ 12,13,14,14, 9,10,10,13,13,10,10,10,13,13,10,10,
+ 10,13,13,12,13,12,15,14,12,13,12,15,15, 5, 7, 6,
+ 10,10, 7, 8, 8,10,10, 7, 8, 8,10,10,10,11,10,13,
+ 13,10,10,10,12,12, 7, 8, 8,11,10, 8, 8, 9,10,11,
+ 8, 9, 9,11,11,11,10,11,11,14,11,11,11,13,13, 6,
+ 8, 8,10,10, 7, 9, 8,11,10, 8, 9, 9,11,11,10,11,
+ 10,14,11,10,11,11,13,13,10,11,11,14,13,10,10,11,
+ 14,13,10,11,11,14,14,12,11,13,12,16,13,14,14,15,
+ 15,10,10,11,13,14,10,11,10,14,13,10,11,11,14,14,
+ 12,13,12,15,13,13,13,14,15,16, 5, 7, 7,10,10, 7,
+ 8, 8,10,10, 7, 8, 8,10,10,10,10,10,13,13,10,10,
+ 11,12,13, 6, 8, 8,11,10, 8, 9, 9,11,11, 7, 8, 9,
+ 10,11,10,11,11,13,13,10,10,11,11,13, 6, 8, 8,10,
+ 11, 8, 9, 9,11,11, 8, 9, 8,12,10,10,11,11,13,13,
+ 10,11,10,14,11,10,10,10,14,13,10,11,11,14,13,10,
+ 10,11,13,13,12,14,14,16,16,12,12,13,13,15,10,11,
+ 11,13,14,10,11,11,14,15,10,11,10,13,13,13,14,13,
+ 16,16,12,13,11,15,12, 9,10,10,13,13,10,11,11,14,
+ 13,10,10,11,13,14,13,14,13,16,16,13,13,13,15,16,
+ 9,10,10,13,13,10,10,11,13,14,10,11,11,15,13,13,
+ 13,14,14,18,13,13,14,16,15, 9,10,10,13,14,10,11,
+ 10,14,13,10,11,11,13,14,13,14,13,16,15,13,13,14,
+ 15,16,12,13,12,16,14,11,11,13,15,15,13,14,13,16,
+ 15,15,12,16,12,17,14,15,15,17,17,12,13,13,14,16,
+ 11,13,11,16,15,12,13,14,15,16,14,15,13, 0,14,14,
+ 16,16, 0, 0, 9,10,10,13,13,10,11,10,14,14,10,11,
+ 11,13,13,12,13,13,14,16,13,14,14,16,16, 9,10,10,
+ 14,14,11,11,11,14,13,10,10,11,14,14,13,13,13,16,
+ 16,13,13,14,14,17, 9,10,10,13,14,10,11,11,13,15,
+ 10,11,10,14,14,13,13,13,14,17,13,14,13,17,14,12,
+ 13,13,16,14,13,14,13,16,15,12,12,13,15,16,15,15,
+ 16,18,16,15,13,15,14, 0,12,12,13,14,16,13,13,14,
+ 15,16,11,12,11,16,14,15,16,16,17,17,14,15,12,17,
+ 12,
+};
+
+static const static_codebook _44u1__p4_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44u1__p4_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44u1__p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44u1__p5_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44u1__p5_0[] = {
+ 1, 4, 4, 7, 7, 7, 7, 9, 9, 4, 6, 6, 8, 8, 8, 8,
+ 9, 9, 4, 6, 6, 8, 8, 8, 8, 9, 9, 7, 8, 8, 9, 9,
+ 9, 9,11,10, 7, 8, 8, 9, 9, 9, 9,10,10, 7, 8, 8,
+ 9, 9,10,10,11,11, 7, 8, 8, 9, 9,10,10,11,11, 9,
+ 9, 9,10,10,11,11,12,12, 9, 9, 9,10,11,11,11,12,
+ 12,
+};
+
+static const static_codebook _44u1__p5_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44u1__p5_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44u1__p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44u1__p6_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44u1__p6_0[] = {
+ 1, 4, 4, 6, 6, 8, 8,10, 9,11,10,14,13, 4, 6, 5,
+ 8, 8, 9, 9,11,10,11,11,14,14, 4, 5, 6, 8, 8, 9,
+ 9,10,10,11,11,14,14, 6, 8, 8, 9, 9,10,10,11,11,
+ 12,12,16,15, 7, 8, 8, 9, 9,10,10,11,11,12,12,15,
+ 15, 9,10,10,10,10,11,11,12,12,12,12,15,15, 9,10,
+ 9,10,11,11,11,12,12,12,13,15,15,10,10,11,11,11,
+ 12,12,13,12,13,13,16,15,10,11,11,11,11,12,12,13,
+ 12,13,13,16,17,11,11,12,12,12,13,13,13,14,14,15,
+ 17,17,11,11,12,12,12,13,13,13,14,14,14,16,18,14,
+ 15,15,15,15,16,16,16,16,17,18, 0, 0,14,15,15,15,
+ 15,17,16,17,18,17,17,18, 0,
+};
+
+static const static_codebook _44u1__p6_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44u1__p6_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44u1__p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44u1__p6_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44u1__p6_1[] = {
+ 2, 4, 4, 5, 5, 4, 5, 5, 5, 5, 4, 5, 5, 5, 5, 5,
+ 6, 6, 6, 6, 5, 6, 6, 6, 6,
+};
+
+static const static_codebook _44u1__p6_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44u1__p6_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44u1__p6_1,
+ 0
+};
+
+static const long _vq_quantlist__44u1__p7_0[] = {
+ 3,
+ 2,
+ 4,
+ 1,
+ 5,
+ 0,
+ 6,
+};
+
+static const long _vq_lengthlist__44u1__p7_0[] = {
+ 1, 3, 2, 9, 9, 7, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8,
+};
+
+static const static_codebook _44u1__p7_0 = {
+ 2, 49,
+ (long *)_vq_lengthlist__44u1__p7_0,
+ 1, -518017024, 1626677248, 3, 0,
+ (long *)_vq_quantlist__44u1__p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44u1__p7_1[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44u1__p7_1[] = {
+ 1, 4, 4, 6, 6, 6, 6, 7, 7, 8, 8, 9, 9, 5, 7, 7,
+ 8, 7, 7, 7, 9, 8,10, 9,10,11, 5, 7, 7, 8, 8, 7,
+ 7, 8, 9,10,10,11,11, 6, 8, 8, 9, 9, 9, 9,11,10,
+ 12,12,15,12, 6, 8, 8, 9, 9, 9, 9,11,11,12,11,14,
+ 12, 7, 8, 8,10,10,12,12,13,13,13,15,13,13, 7, 8,
+ 8,10,10,11,11,13,12,14,15,15,15, 9,10,10,11,12,
+ 13,13,14,15,14,15,14,15, 8,10,10,12,12,14,14,15,
+ 14,14,15,15,14,10,12,12,14,14,15,14,15,15,15,14,
+ 15,15,10,12,12,13,14,15,14,15,15,14,15,15,15,12,
+ 15,13,15,14,15,15,15,15,15,15,15,15,13,13,15,15,
+ 15,15,15,15,15,15,15,15,15,
+};
+
+static const static_codebook _44u1__p7_1 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44u1__p7_1,
+ 1, -523010048, 1618608128, 4, 0,
+ (long *)_vq_quantlist__44u1__p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44u1__p7_2[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44u1__p7_2[] = {
+ 2, 5, 4, 6, 6, 7, 7, 8, 8, 8, 8, 9, 8, 5, 5, 6,
+ 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 5, 6, 5, 7, 7, 8,
+ 8, 8, 8, 9, 9, 9, 9, 6, 7, 7, 8, 8, 8, 8, 9, 8,
+ 9, 9, 9, 9, 6, 7, 7, 8, 7, 8, 8, 9, 9, 9, 9, 9,
+ 9, 7, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 7, 8,
+ 8, 9, 8, 9, 8, 9, 9, 9, 9, 9, 9, 8, 9, 8, 9, 9,
+ 9, 9, 9, 9, 9, 9,10,10, 8, 8, 9, 9, 9, 9, 9, 9,
+ 9, 9,10, 9,10, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9,10,10,10, 9, 9, 9, 9, 9,
+ 9, 9, 9,10, 9, 9,10,10, 9,
+};
+
+static const static_codebook _44u1__p7_2 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44u1__p7_2,
+ 1, -531103744, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44u1__p7_2,
+ 0
+};
+
+static const long _huff_lengthlist__44u1__short[] = {
+ 12,13,14,13,17,12,15,17, 5, 5, 6,10,10,11,15,16,
+ 4, 3, 3, 7, 5, 7,10,16, 7, 7, 7,10, 9,11,12,16,
+ 6, 5, 5, 9, 5, 6,10,16, 8, 7, 7, 9, 6, 7, 9,16,
+ 11, 7, 3, 6, 4, 5, 8,16,12, 9, 4, 8, 5, 7, 9,16,
+};
+
+static const static_codebook _huff_book__44u1__short = {
+ 2, 64,
+ (long *)_huff_lengthlist__44u1__short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44u2__long[] = {
+ 5, 9,14,12,15,13,10,13, 7, 4, 5, 6, 8, 7, 8,12,
+ 13, 4, 3, 5, 5, 6, 9,15,12, 6, 5, 6, 6, 6, 7,14,
+ 14, 7, 4, 6, 4, 6, 8,15,12, 6, 6, 5, 5, 5, 6,14,
+ 9, 7, 8, 6, 7, 5, 4,10,10,13,14,14,15,10, 6, 8,
+};
+
+static const static_codebook _huff_book__44u2__long = {
+ 2, 64,
+ (long *)_huff_lengthlist__44u2__long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44u2__p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44u2__p1_0[] = {
+ 1, 4, 4, 5, 8, 7, 5, 7, 8, 5, 8, 8, 8,11,11, 8,
+ 10,11, 5, 8, 8, 8,11,10, 8,11,11, 4, 8, 8, 8,11,
+ 11, 8,11,11, 8,11,11,11,13,14,11,13,13, 7,11,11,
+ 10,13,12,11,14,14, 4, 8, 8, 8,11,11, 8,11,11, 8,
+ 11,11,11,14,13,10,12,13, 8,11,11,11,13,13,11,13,
+ 13,
+};
+
+static const static_codebook _44u2__p1_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44u2__p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44u2__p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44u2__p2_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44u2__p2_0[] = {
+ 2, 5, 5, 5, 6, 6, 5, 6, 6, 5, 6, 6, 7, 8, 8, 6,
+ 8, 8, 5, 6, 6, 6, 8, 7, 7, 8, 8, 5, 6, 6, 7, 8,
+ 8, 6, 8, 8, 6, 8, 8, 8, 9,10, 8,10,10, 6, 8, 8,
+ 7,10, 8, 8,10,10, 5, 6, 6, 6, 8, 8, 7, 8, 8, 6,
+ 8, 8, 8,10,10, 8, 8,10, 6, 8, 8, 8,10,10, 8,10,
+ 9,
+};
+
+static const static_codebook _44u2__p2_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44u2__p2_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44u2__p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44u2__p3_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44u2__p3_0[] = {
+ 2, 4, 4, 7, 8, 5, 7, 7, 9, 9, 5, 7, 7, 9, 9, 8,
+ 9, 9,12,11, 8, 9, 9,11,12, 5, 7, 7,10,10, 7, 9,
+ 9,11,11, 7, 9, 9,10,11,10,11,11,13,13, 9,10,11,
+ 12,13, 5, 7, 7,10,10, 7, 9, 9,11,10, 7, 9, 9,11,
+ 11, 9,11,10,13,13,10,11,11,13,13, 8,10,10,14,13,
+ 10,11,11,15,14, 9,11,11,15,14,13,14,13,16,14,12,
+ 13,13,15,16, 8,10,10,13,14, 9,11,11,14,15,10,11,
+ 11,14,15,12,13,13,15,15,12,13,14,15,16, 5, 7, 7,
+ 10,10, 7, 9, 9,11,11, 7, 9, 9,11,12,10,11,11,14,
+ 13,10,11,11,14,14, 7, 9, 9,12,12, 9,11,11,13,13,
+ 9,11,11,13,13,12,13,12,14,14,11,12,13,15,15, 7,
+ 9, 9,12,12, 8,11,10,13,12, 9,11,11,13,13,11,13,
+ 12,15,13,11,13,13,15,16, 9,12,11,15,15,11,12,12,
+ 16,15,11,12,13,16,16,13,14,15,16,15,13,15,15,17,
+ 17, 9,11,11,14,15,10,12,12,15,15,11,13,12,15,16,
+ 13,15,14,16,16,13,15,15,17,19, 5, 7, 7,10,10, 7,
+ 9, 9,12,11, 7, 9, 9,11,11,10,11,11,14,14,10,11,
+ 11,13,14, 7, 9, 9,12,12, 9,11,11,13,13, 9,10,11,
+ 12,13,11,13,12,16,15,11,12,12,14,15, 7, 9, 9,12,
+ 12, 9,11,11,13,13, 9,11,11,13,12,11,13,12,15,16,
+ 12,13,13,15,14, 9,11,11,15,14,11,13,12,16,15,10,
+ 11,12,15,15,13,14,14,18,17,13,14,14,15,17,10,11,
+ 11,14,15,11,13,12,15,17,11,13,12,15,16,13,15,14,
+ 18,17,14,15,15,16,18, 7,10,10,14,14,10,12,12,15,
+ 15,10,12,12,15,15,14,15,15,18,17,13,15,15,16,16,
+ 9,11,11,16,15,11,13,13,16,18,11,13,13,16,16,15,
+ 16,16, 0, 0,14,15,16,18,17, 9,11,11,15,15,10,13,
+ 12,17,16,11,12,13,16,17,14,15,16,19,19,14,15,15,
+ 0,20,12,14,14, 0, 0,13,14,16,19,18,13,15,16,20,
+ 17,16,18, 0, 0, 0,15,16,17,18,19,11,14,14, 0,19,
+ 12,15,14,17,17,13,15,15, 0, 0,16,17,15,20,19,15,
+ 17,16,19, 0, 8,10,10,14,15,10,12,11,15,15,10,11,
+ 12,16,15,13,14,14,19,17,14,15,15, 0, 0, 9,11,11,
+ 16,15,11,13,13,17,16,10,12,13,16,17,14,15,15,18,
+ 18,14,15,16,20,19, 9,12,12, 0,15,11,13,13,16,17,
+ 11,13,13,19,17,14,16,16,18,17,15,16,16,17,19,11,
+ 14,14,18,18,13,14,15, 0, 0,12,14,15,19,18,15,16,
+ 19, 0,19,15,16,19,19,17,12,14,14,16,19,13,15,15,
+ 0,17,13,15,14,18,18,15,16,15, 0,18,16,17,17, 0,
+ 0,
+};
+
+static const static_codebook _44u2__p3_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44u2__p3_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44u2__p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44u2__p4_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44u2__p4_0[] = {
+ 4, 5, 5, 8, 8, 5, 7, 6, 9, 9, 5, 6, 7, 9, 9, 9,
+ 9, 9,11,11, 9, 9, 9,11,11, 5, 7, 7, 9, 9, 7, 8,
+ 8,10,10, 7, 7, 8,10,10,10,10,10,11,12, 9,10,10,
+ 11,12, 5, 7, 7, 9, 9, 6, 8, 7,10,10, 7, 8, 8,10,
+ 10, 9,10,10,12,11, 9,10,10,12,11, 9,10,10,12,12,
+ 10,10,10,13,12, 9,10,10,12,13,12,12,12,14,14,11,
+ 12,12,13,14, 9,10,10,12,12, 9,10,10,12,13,10,10,
+ 10,12,13,11,12,12,14,13,12,12,12,14,13, 5, 7, 7,
+ 10, 9, 7, 8, 8,10,10, 7, 8, 8,10,10,10,10,10,12,
+ 12,10,10,10,12,12, 7, 8, 8,11,10, 8, 8, 9,11,11,
+ 8, 9, 9,11,11,10,11,11,12,13,10,11,11,13,13, 6,
+ 8, 8,10,10, 7, 9, 8,11,10, 8, 9, 9,11,11,10,11,
+ 10,13,11,10,11,11,13,13, 9,10,10,13,13,10,11,11,
+ 13,13,10,11,11,14,13,12,11,13,12,15,12,13,13,15,
+ 15, 9,10,10,12,13,10,11,10,13,13,10,11,11,13,13,
+ 12,13,11,15,13,12,13,13,15,15, 5, 7, 7, 9,10, 7,
+ 8, 8,10,10, 7, 8, 8,10,10,10,10,10,12,12,10,10,
+ 11,12,12, 6, 8, 8,10,10, 8, 9, 9,11,11, 7, 8, 9,
+ 10,11,10,11,11,13,13,10,10,11,11,13, 7, 8, 8,10,
+ 11, 8, 9, 9,11,11, 8, 9, 8,11,11,10,11,11,13,13,
+ 10,11,11,13,12, 9,10,10,13,12,10,11,11,14,13,10,
+ 10,11,13,13,12,13,13,15,15,12,11,13,12,14, 9,10,
+ 10,12,13,10,11,11,13,14,10,11,11,13,13,12,13,13,
+ 15,15,12,13,12,15,12, 8, 9, 9,12,12, 9,11,10,13,
+ 13, 9,10,10,13,13,12,13,13,15,15,12,12,12,14,14,
+ 9,10,10,13,13,10,11,11,13,14,10,11,11,14,12,13,
+ 13,14,14,16,12,13,13,15,14, 9,10,10,13,13,10,11,
+ 10,14,13,10,11,11,13,14,12,14,13,16,14,13,13,13,
+ 14,15,11,13,12,15,14,11,12,13,14,15,12,13,13,16,
+ 15,14,12,15,12,16,14,15,15,17,16,11,12,12,14,15,
+ 11,13,11,15,14,12,13,13,15,16,13,15,12,17,13,14,
+ 15,15,16,16, 8, 9, 9,12,12, 9,10,10,13,13, 9,10,
+ 10,13,13,12,13,12,14,14,12,13,13,15,15, 9,10,10,
+ 13,13,10,11,11,14,13,10,10,11,13,14,12,13,13,15,
+ 14,12,12,14,14,16, 9,10,10,13,13,10,11,11,13,14,
+ 10,11,11,14,13,13,13,13,15,15,13,14,13,16,14,11,
+ 12,12,14,14,12,13,13,16,15,11,12,13,14,15,14,15,
+ 15,16,16,14,13,15,13,17,11,12,12,14,15,12,13,13,
+ 15,16,11,13,12,15,15,14,15,14,16,16,14,15,12,17,
+ 13,
+};
+
+static const static_codebook _44u2__p4_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44u2__p4_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44u2__p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44u2__p5_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44u2__p5_0[] = {
+ 1, 4, 4, 7, 7, 8, 8, 9, 9, 4, 6, 5, 8, 8, 8, 8,
+ 10,10, 4, 5, 6, 8, 8, 8, 8,10,10, 7, 8, 8, 9, 9,
+ 9, 9,11,11, 7, 8, 8, 9, 9, 9, 9,11,11, 8, 8, 8,
+ 9, 9,10,11,12,12, 8, 8, 8, 9, 9,10,10,12,12,10,
+ 10,10,11,11,12,12,13,13,10,10,10,11,11,12,12,13,
+ 13,
+};
+
+static const static_codebook _44u2__p5_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44u2__p5_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44u2__p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44u2__p6_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44u2__p6_0[] = {
+ 1, 4, 4, 6, 6, 8, 8,10,10,11,11,14,13, 4, 6, 5,
+ 8, 8, 9, 9,11,10,12,11,15,14, 4, 5, 6, 8, 8, 9,
+ 9,11,11,11,11,14,14, 6, 8, 8,10, 9,11,11,11,11,
+ 12,12,15,15, 6, 8, 8, 9, 9,11,11,11,12,12,12,15,
+ 15, 8,10,10,11,11,11,11,12,12,13,13,15,16, 8,10,
+ 10,11,11,11,11,12,12,13,13,16,16,10,11,11,12,12,
+ 12,12,13,13,13,13,17,16,10,11,11,12,12,12,12,13,
+ 13,13,14,16,17,11,12,12,13,13,13,13,14,14,15,14,
+ 18,17,11,12,12,13,13,13,13,14,14,14,15,19,18,14,
+ 15,15,15,15,16,16,18,19,18,18, 0, 0,14,15,15,16,
+ 15,17,17,16,18,17,18, 0, 0,
+};
+
+static const static_codebook _44u2__p6_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44u2__p6_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44u2__p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44u2__p6_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44u2__p6_1[] = {
+ 2, 4, 4, 5, 5, 4, 5, 5, 6, 5, 4, 5, 5, 5, 6, 5,
+ 6, 5, 6, 6, 5, 5, 6, 6, 6,
+};
+
+static const static_codebook _44u2__p6_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44u2__p6_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44u2__p6_1,
+ 0
+};
+
+static const long _vq_quantlist__44u2__p7_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44u2__p7_0[] = {
+ 1, 3, 2,12,12,12,12,12,12, 4,12,12,12,12,12,12,
+ 12,12, 5,12,12,12,12,12,12,12,12,12,12,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,
+};
+
+static const static_codebook _44u2__p7_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44u2__p7_0,
+ 1, -516612096, 1626677248, 4, 0,
+ (long *)_vq_quantlist__44u2__p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44u2__p7_1[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44u2__p7_1[] = {
+ 1, 4, 4, 7, 6, 7, 6, 8, 7, 9, 7, 9, 8, 4, 7, 6,
+ 8, 8, 9, 8,10, 9,10,10,11,11, 4, 7, 7, 8, 8, 8,
+ 8, 9,10,11,11,11,11, 6, 8, 8,10,10,10,10,11,11,
+ 12,12,12,12, 7, 8, 8,10,10,10,10,11,11,12,12,13,
+ 13, 7, 9, 9,11,10,12,12,13,13,14,13,14,14, 7, 9,
+ 9,10,11,11,12,13,13,13,13,16,14, 9,10,10,12,12,
+ 13,13,14,14,15,16,15,16, 9,10,10,12,12,12,13,14,
+ 14,14,15,16,15,10,12,12,13,13,15,13,16,16,15,17,
+ 17,17,10,11,11,12,14,14,14,15,15,17,17,15,17,11,
+ 12,12,14,14,14,15,15,15,17,16,17,17,10,12,12,13,
+ 14,14,14,17,15,17,17,17,17,
+};
+
+static const static_codebook _44u2__p7_1 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44u2__p7_1,
+ 1, -523010048, 1618608128, 4, 0,
+ (long *)_vq_quantlist__44u2__p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44u2__p7_2[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44u2__p7_2[] = {
+ 2, 5, 5, 6, 6, 7, 7, 8, 7, 8, 8, 8, 8, 5, 6, 6,
+ 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 5, 6, 6, 7, 7, 8,
+ 7, 8, 8, 8, 8, 8, 8, 6, 7, 7, 7, 8, 8, 8, 8, 8,
+ 9, 9, 9, 9, 6, 7, 7, 8, 7, 8, 8, 9, 9, 9, 9, 9,
+ 9, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 7, 8,
+ 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 8, 8, 8, 8, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 8, 8, 8, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 8,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 8, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9,
+};
+
+static const static_codebook _44u2__p7_2 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44u2__p7_2,
+ 1, -531103744, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44u2__p7_2,
+ 0
+};
+
+static const long _huff_lengthlist__44u2__short[] = {
+ 13,15,17,17,15,15,12,17,11, 9, 7,10,10, 9,12,17,
+ 10, 6, 3, 6, 5, 7,10,17,15,10, 6, 9, 8, 9,11,17,
+ 15, 8, 4, 7, 3, 5, 9,16,16,10, 5, 8, 4, 5, 8,16,
+ 13,11, 5, 8, 3, 3, 5,14,13,12, 7,10, 5, 5, 7,14,
+};
+
+static const static_codebook _huff_book__44u2__short = {
+ 2, 64,
+ (long *)_huff_lengthlist__44u2__short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44u3__long[] = {
+ 6, 9,13,12,14,11,10,13, 8, 4, 5, 7, 8, 7, 8,12,
+ 11, 4, 3, 5, 5, 7, 9,14,11, 6, 5, 6, 6, 6, 7,13,
+ 13, 7, 5, 6, 4, 5, 7,14,11, 7, 6, 6, 5, 5, 6,13,
+ 9, 7, 8, 6, 7, 5, 3, 9, 9,12,13,12,14,10, 6, 7,
+};
+
+static const static_codebook _huff_book__44u3__long = {
+ 2, 64,
+ (long *)_huff_lengthlist__44u3__long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44u3__p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44u3__p1_0[] = {
+ 1, 4, 4, 5, 8, 7, 5, 7, 8, 5, 8, 8, 8,10,11, 8,
+ 10,11, 5, 8, 8, 8,11,10, 8,11,11, 4, 8, 8, 8,11,
+ 11, 8,11,11, 8,11,11,11,13,14,11,14,14, 8,11,11,
+ 10,14,12,11,14,14, 4, 8, 8, 8,11,11, 8,11,11, 7,
+ 11,11,11,14,14,10,12,14, 8,11,11,11,14,14,11,14,
+ 13,
+};
+
+static const static_codebook _44u3__p1_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44u3__p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44u3__p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44u3__p2_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44u3__p2_0[] = {
+ 2, 5, 4, 5, 6, 6, 5, 6, 6, 5, 6, 6, 7, 8, 8, 6,
+ 8, 8, 5, 6, 6, 6, 8, 8, 7, 8, 8, 5, 7, 6, 7, 8,
+ 8, 6, 8, 8, 7, 8, 8, 8, 9,10, 8,10,10, 6, 8, 8,
+ 8,10, 8, 8,10,10, 5, 6, 6, 6, 8, 8, 7, 8, 8, 6,
+ 8, 8, 8,10,10, 8, 8,10, 7, 8, 8, 8,10,10, 8,10,
+ 9,
+};
+
+static const static_codebook _44u3__p2_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44u3__p2_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44u3__p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44u3__p3_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44u3__p3_0[] = {
+ 2, 4, 4, 7, 7, 5, 7, 7, 9, 9, 5, 7, 7, 9, 9, 8,
+ 9, 9,12,12, 8, 9, 9,11,12, 5, 7, 7,10,10, 7, 9,
+ 9,11,11, 7, 9, 9,10,11,10,11,11,13,13, 9,10,11,
+ 13,13, 5, 7, 7,10,10, 7, 9, 9,11,10, 7, 9, 9,11,
+ 11, 9,11,10,13,13,10,11,11,14,13, 8,10,10,14,13,
+ 10,11,11,15,14, 9,11,11,14,14,13,14,13,16,16,12,
+ 13,13,15,15, 8,10,10,13,14, 9,11,11,14,14,10,11,
+ 11,14,15,12,13,13,15,15,13,14,14,15,16, 5, 7, 7,
+ 10,10, 7, 9, 9,11,11, 7, 9, 9,11,12,10,11,11,14,
+ 14,10,11,11,14,14, 7, 9, 9,12,12, 9,11,11,13,13,
+ 9,11,11,13,13,12,12,13,15,15,11,12,13,15,16, 7,
+ 9, 9,11,11, 8,11,10,13,12, 9,11,11,13,13,11,13,
+ 12,15,13,11,13,13,15,16, 9,12,11,15,14,11,12,13,
+ 16,15,11,13,13,15,16,14,14,15,17,16,13,15,16, 0,
+ 17, 9,11,11,15,15,10,13,12,15,15,11,13,13,15,16,
+ 13,15,13,16,15,14,16,15, 0,19, 5, 7, 7,10,10, 7,
+ 9, 9,11,11, 7, 9, 9,11,11,10,12,11,14,14,10,11,
+ 12,14,14, 7, 9, 9,12,12, 9,11,11,14,13, 9,10,11,
+ 12,13,11,13,13,16,16,11,12,13,13,16, 7, 9, 9,12,
+ 12, 9,11,11,13,13, 9,11,11,13,13,11,13,13,15,15,
+ 12,13,12,15,14, 9,11,11,15,14,11,13,12,16,16,10,
+ 12,12,15,15,13,15,15,17,19,13,14,15,16,17,10,12,
+ 12,15,15,11,13,13,16,16,11,13,13,15,16,13,15,15,
+ 0, 0,14,15,15,16,16, 8,10,10,14,14,10,12,12,15,
+ 15,10,12,11,15,16,14,15,15,19,20,13,14,14,18,16,
+ 9,11,11,15,15,11,13,13,17,16,11,13,13,16,16,15,
+ 17,17,20,20,14,15,16,17,20, 9,11,11,15,15,10,13,
+ 12,16,15,11,13,13,15,17,14,16,15,18, 0,14,16,15,
+ 18,20,12,14,14, 0, 0,14,14,16, 0, 0,13,16,15, 0,
+ 0,17,17,18, 0, 0,16,17,19,19, 0,12,14,14,18, 0,
+ 12,16,14, 0,17,13,15,15,18, 0,16,18,17, 0,17,16,
+ 18,17, 0, 0, 7,10,10,14,14,10,12,11,15,15,10,12,
+ 12,16,15,13,15,15,18, 0,14,15,15,17, 0, 9,11,11,
+ 15,15,11,13,13,16,16,11,12,13,16,16,14,15,16,17,
+ 17,14,16,16,16,18, 9,11,12,16,16,11,13,13,17,17,
+ 11,14,13,20,17,15,16,16,19, 0,15,16,17, 0,19,11,
+ 13,14,17,16,14,15,15,20,18,13,14,15,17,19,16,18,
+ 18, 0,20,16,16,19,17, 0,12,15,14,17, 0,14,15,15,
+ 18,19,13,16,15,19,20,15,18,18, 0,20,17, 0,16, 0,
+ 0,
+};
+
+static const static_codebook _44u3__p3_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44u3__p3_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44u3__p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44u3__p4_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44u3__p4_0[] = {
+ 4, 5, 5, 8, 8, 5, 7, 6, 9, 9, 5, 6, 7, 9, 9, 9,
+ 9, 9,11,11, 9, 9, 9,11,11, 5, 7, 7, 9, 9, 7, 8,
+ 8,10,10, 7, 7, 8,10,10, 9,10,10,11,12, 9,10,10,
+ 11,12, 5, 7, 7, 9, 9, 7, 8, 7,10,10, 7, 8, 8,10,
+ 10, 9,10, 9,12,11, 9,10,10,12,11, 9,10, 9,12,12,
+ 9,10,10,13,12, 9,10,10,12,13,12,12,12,14,14,11,
+ 12,12,13,14, 9, 9,10,12,12, 9,10,10,12,12, 9,10,
+ 10,12,13,11,12,11,14,13,12,12,12,14,13, 5, 7, 7,
+ 9, 9, 7, 8, 8,10,10, 7, 8, 8,10,10,10,10,10,12,
+ 12, 9,10,10,12,12, 7, 8, 8,11,10, 8, 8, 9,11,11,
+ 8, 9, 9,11,11,11,11,11,12,13,10,11,11,13,13, 6,
+ 8, 8,10,10, 7, 9, 8,11,10, 8, 9, 9,11,11,10,11,
+ 10,13,11,10,11,11,13,13, 9,11,10,13,12,10,11,11,
+ 13,13,10,11,11,13,13,12,12,13,12,15,12,13,13,15,
+ 15, 9,10,10,12,13,10,11,10,13,12,10,11,11,13,14,
+ 12,13,11,15,13,12,13,13,15,15, 5, 7, 7, 9, 9, 7,
+ 8, 8,10,10, 7, 8, 8,10,10, 9,10,10,12,12,10,10,
+ 11,12,12, 6, 8, 8,10,10, 8, 9, 9,11,11, 7, 8, 9,
+ 10,11,10,11,11,13,13,10,10,11,11,13, 7, 8, 8,10,
+ 10, 8, 9, 9,11,11, 8, 9, 9,11,11,10,11,11,13,13,
+ 11,11,11,13,12, 9,10,10,13,12,10,11,11,14,13,10,
+ 10,11,12,13,12,13,13,15,15,12,11,13,13,14, 9,10,
+ 11,12,13,10,11,11,13,13,10,11,11,13,13,12,13,13,
+ 15,15,12,13,12,15,12, 8, 9, 9,12,12, 9,11,10,13,
+ 13, 9,10,10,13,13,12,13,13,15,14,12,12,12,14,13,
+ 9,10,10,13,12,10,11,11,13,13,10,11,11,14,12,13,
+ 13,14,14,16,12,13,13,15,15, 9,10,10,13,13,10,11,
+ 10,14,13,10,11,11,13,14,12,14,13,15,14,13,13,13,
+ 15,15,11,13,12,15,14,11,12,13,14,15,12,13,13,16,
+ 14,14,12,15,12,16,14,15,15,17,15,11,12,12,14,14,
+ 11,13,11,15,14,12,13,13,15,15,13,15,12,17,13,14,
+ 15,15,16,16, 8, 9, 9,12,12, 9,10,10,12,13, 9,10,
+ 10,13,13,12,12,12,14,14,12,13,13,15,15, 9,10,10,
+ 13,12,10,11,11,14,13,10,10,11,13,14,12,13,13,15,
+ 15,12,12,13,14,16, 9,10,10,13,13,10,11,11,13,14,
+ 10,11,11,14,13,12,13,13,14,15,13,14,13,16,14,11,
+ 12,12,14,14,12,13,13,15,14,11,12,13,14,15,14,15,
+ 15,16,16,13,13,15,13,16,11,12,12,14,15,12,13,13,
+ 14,15,11,13,12,15,14,14,15,15,16,16,14,15,12,16,
+ 13,
+};
+
+static const static_codebook _44u3__p4_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44u3__p4_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44u3__p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44u3__p5_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44u3__p5_0[] = {
+ 2, 3, 3, 6, 6, 7, 7, 9, 9, 4, 5, 5, 7, 7, 8, 8,
+ 10,10, 4, 5, 5, 7, 7, 8, 8,10,10, 6, 7, 7, 8, 8,
+ 9, 9,11,10, 6, 7, 7, 8, 8, 9, 9,10,10, 7, 8, 8,
+ 9, 9,10,10,11,11, 7, 8, 8, 9, 9,10,10,11,11, 9,
+ 10,10,11,10,11,11,12,12, 9,10,10,10,10,11,11,12,
+ 12,
+};
+
+static const static_codebook _44u3__p5_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44u3__p5_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44u3__p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44u3__p6_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44u3__p6_0[] = {
+ 1, 4, 4, 6, 6, 8, 8, 9, 9,10,11,13,14, 4, 6, 5,
+ 8, 8, 9, 9,10,10,11,11,14,14, 4, 6, 6, 8, 8, 9,
+ 9,10,10,11,11,14,14, 6, 8, 8, 9, 9,10,10,11,11,
+ 12,12,15,15, 6, 8, 8, 9, 9,10,11,11,11,12,12,15,
+ 15, 8, 9, 9,11,10,11,11,12,12,13,13,15,16, 8, 9,
+ 9,10,11,11,11,12,12,13,13,16,16,10,10,11,11,11,
+ 12,12,13,13,13,14,17,16, 9,10,11,12,11,12,12,13,
+ 13,13,13,16,18,11,12,11,12,12,13,13,13,14,15,14,
+ 17,17,11,11,12,12,12,13,13,13,14,14,15,18,17,14,
+ 15,15,15,15,16,16,17,17,19,18, 0,20,14,15,14,15,
+ 15,16,16,16,17,18,16,20,18,
+};
+
+static const static_codebook _44u3__p6_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44u3__p6_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44u3__p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44u3__p6_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44u3__p6_1[] = {
+ 2, 4, 4, 5, 5, 4, 5, 5, 6, 5, 4, 5, 5, 5, 6, 5,
+ 6, 5, 6, 6, 5, 5, 6, 6, 6,
+};
+
+static const static_codebook _44u3__p6_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44u3__p6_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44u3__p6_1,
+ 0
+};
+
+static const long _vq_quantlist__44u3__p7_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44u3__p7_0[] = {
+ 1, 3, 3,10,10,10,10,10,10, 4,10,10,10,10,10,10,
+ 10,10, 4,10,10,10,10,10,10,10,10,10,10, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9,
+};
+
+static const static_codebook _44u3__p7_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44u3__p7_0,
+ 1, -515907584, 1627381760, 4, 0,
+ (long *)_vq_quantlist__44u3__p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44u3__p7_1[] = {
+ 7,
+ 6,
+ 8,
+ 5,
+ 9,
+ 4,
+ 10,
+ 3,
+ 11,
+ 2,
+ 12,
+ 1,
+ 13,
+ 0,
+ 14,
+};
+
+static const long _vq_lengthlist__44u3__p7_1[] = {
+ 1, 4, 4, 6, 6, 7, 6, 8, 7, 9, 8,10, 9,11,11, 4,
+ 7, 7, 8, 7, 9, 9,10,10,11,11,11,11,12,12, 4, 7,
+ 7, 7, 7, 9, 9,10,10,11,11,12,12,12,11, 6, 8, 8,
+ 9, 9,10,10,11,11,12,12,13,12,13,13, 6, 8, 8, 9,
+ 9,10,11,11,11,12,12,13,14,13,13, 8, 9, 9,11,11,
+ 12,12,12,13,14,13,14,14,14,15, 8, 9, 9,11,11,11,
+ 12,13,14,13,14,15,17,14,15, 9,10,10,12,12,13,13,
+ 13,14,15,15,15,16,16,16, 9,11,11,12,12,13,13,14,
+ 14,14,15,16,16,16,16,10,12,12,13,13,14,14,15,15,
+ 15,16,17,17,17,17,10,12,11,13,13,15,14,15,14,16,
+ 17,16,16,16,16,11,13,12,14,14,14,14,15,16,17,16,
+ 17,17,17,17,11,13,12,14,14,14,15,17,16,17,17,17,
+ 17,17,17,12,13,13,15,16,15,16,17,17,16,16,17,17,
+ 17,17,12,13,13,15,15,15,16,17,17,17,16,17,16,17,
+ 17,
+};
+
+static const static_codebook _44u3__p7_1 = {
+ 2, 225,
+ (long *)_vq_lengthlist__44u3__p7_1,
+ 1, -522338304, 1620115456, 4, 0,
+ (long *)_vq_quantlist__44u3__p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44u3__p7_2[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44u3__p7_2[] = {
+ 2, 5, 5, 7, 6, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 9,
+ 9, 5, 6, 6, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9,
+ 10,10, 5, 6, 6, 7, 7, 8, 8, 8, 8, 9, 8, 9, 9, 9,
+ 9,10, 9, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9,
+ 10,10,10,10, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9,10,
+ 9,10,10,10,10, 7, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9,
+ 10,10,10,10,10,10, 7, 8, 8, 9, 8, 9, 9, 9, 9,10,
+ 9,10,10,10,10,10,10, 8, 8, 8, 9, 9, 9, 9, 9, 9,
+ 9,10,10,10,10,10,10,10, 8, 9, 8, 9, 9, 9, 9,10,
+ 9,10,10,10,10,10,10,10,10, 9, 9, 9, 9, 9, 9,10,
+ 9,10,10,10,10,10,10,10,10,10, 9, 9, 9, 9, 9,10,
+ 9,10,10,10,10,10,10,10,10,10,10, 9, 9, 9,10, 9,
+ 10,10,10,10,10,10,10,10,10,10,10,10, 9, 9, 9,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10, 9, 9, 9,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,11, 9,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,11, 9,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 9,10,10,10,10,10,10,10,10,10,10,10,11,11,11,10,
+ 11,
+};
+
+static const static_codebook _44u3__p7_2 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44u3__p7_2,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44u3__p7_2,
+ 0
+};
+
+static const long _huff_lengthlist__44u3__short[] = {
+ 14,14,14,15,13,15,12,16,10, 8, 7, 9, 9, 8,12,16,
+ 10, 5, 4, 6, 5, 6, 9,16,14, 8, 6, 8, 7, 8,10,16,
+ 14, 7, 4, 6, 3, 5, 8,16,15, 9, 5, 7, 4, 4, 7,16,
+ 13,10, 6, 7, 4, 3, 4,13,13,12, 7, 9, 5, 5, 6,12,
+};
+
+static const static_codebook _huff_book__44u3__short = {
+ 2, 64,
+ (long *)_huff_lengthlist__44u3__short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44u4__long[] = {
+ 3, 8,12,12,13,12,11,13, 5, 4, 6, 7, 8, 8, 9,13,
+ 9, 5, 4, 5, 5, 7, 9,13, 9, 6, 5, 6, 6, 7, 8,12,
+ 12, 7, 5, 6, 4, 5, 8,13,11, 7, 6, 6, 5, 5, 6,12,
+ 10, 8, 8, 7, 7, 5, 3, 8,10,12,13,12,12, 9, 6, 7,
+};
+
+static const static_codebook _huff_book__44u4__long = {
+ 2, 64,
+ (long *)_huff_lengthlist__44u4__long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44u4__p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44u4__p1_0[] = {
+ 1, 4, 4, 5, 8, 7, 5, 7, 8, 5, 8, 8, 8,10,11, 8,
+ 10,11, 5, 8, 8, 8,11,10, 8,11,11, 4, 8, 8, 8,11,
+ 11, 8,11,11, 8,11,11,11,13,14,11,15,14, 8,11,11,
+ 10,13,12,11,14,14, 4, 8, 8, 8,11,11, 8,11,11, 7,
+ 11,11,11,15,14,10,12,14, 8,11,11,11,14,14,11,14,
+ 13,
+};
+
+static const static_codebook _44u4__p1_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44u4__p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44u4__p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44u4__p2_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44u4__p2_0[] = {
+ 2, 5, 5, 5, 6, 6, 5, 6, 6, 5, 6, 6, 7, 8, 8, 6,
+ 8, 8, 5, 6, 6, 6, 8, 8, 7, 8, 8, 5, 7, 6, 6, 8,
+ 8, 6, 8, 8, 6, 8, 8, 8, 9,10, 8,10,10, 6, 8, 8,
+ 8,10, 8, 8,10,10, 5, 6, 6, 6, 8, 8, 6, 8, 8, 6,
+ 8, 8, 8,10,10, 8, 8,10, 6, 8, 8, 8,10,10, 8,10,
+ 9,
+};
+
+static const static_codebook _44u4__p2_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44u4__p2_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44u4__p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44u4__p3_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44u4__p3_0[] = {
+ 2, 4, 4, 8, 8, 5, 7, 7, 9, 9, 5, 7, 7, 9, 9, 8,
+ 10, 9,12,12, 8, 9,10,12,12, 5, 7, 7,10,10, 7, 9,
+ 9,11,11, 7, 9, 9,11,11,10,12,11,14,14, 9,10,11,
+ 13,14, 5, 7, 7,10,10, 7, 9, 9,11,11, 7, 9, 9,11,
+ 11, 9,11,10,14,13,10,11,11,14,14, 8,10,10,14,13,
+ 10,12,12,15,14, 9,11,11,15,14,13,14,14,17,17,12,
+ 14,14,16,16, 8,10,10,14,14, 9,11,11,14,15,10,12,
+ 12,14,15,12,14,13,16,16,13,14,15,15,18, 4, 7, 7,
+ 10,10, 7, 9, 9,12,11, 7, 9, 9,11,12,10,12,11,15,
+ 14,10,11,12,14,15, 7, 9, 9,12,12, 9,11,12,13,13,
+ 9,11,12,13,13,12,13,13,15,16,11,13,13,15,16, 7,
+ 9, 9,12,12, 9,11,10,13,12, 9,11,12,13,14,11,13,
+ 12,16,14,12,13,13,15,16,10,12,12,16,15,11,13,13,
+ 17,16,11,13,13,17,16,14,15,15,17,17,14,16,16,18,
+ 20, 9,11,11,15,16,11,13,12,16,16,11,13,13,16,17,
+ 14,15,14,18,16,14,16,16,17,20, 5, 7, 7,10,10, 7,
+ 9, 9,12,11, 7, 9,10,11,12,10,12,11,15,15,10,12,
+ 12,14,14, 7, 9, 9,12,12, 9,12,11,14,13, 9,10,11,
+ 12,13,12,13,14,16,16,11,12,13,14,16, 7, 9, 9,12,
+ 12, 9,12,11,13,13, 9,12,11,13,13,11,13,13,16,16,
+ 12,13,13,16,15, 9,11,11,16,14,11,13,13,16,16,11,
+ 12,13,16,16,14,16,16,17,17,13,14,15,16,17,10,12,
+ 12,15,15,11,13,13,16,17,11,13,13,16,16,14,16,15,
+ 19,19,14,15,15,17,18, 8,10,10,14,14,10,12,12,15,
+ 15,10,12,12,16,16,14,16,15,20,19,13,15,15,17,16,
+ 9,12,12,16,16,11,13,13,16,18,11,14,13,16,17,16,
+ 17,16,20, 0,15,16,18,18,20, 9,11,11,15,15,11,14,
+ 12,17,16,11,13,13,17,17,15,17,15,20,20,14,16,16,
+ 17, 0,13,15,14,18,16,14,15,16, 0,18,14,16,16, 0,
+ 0,18,16, 0, 0,20,16,18,18, 0, 0,12,14,14,17,18,
+ 13,15,14,20,18,14,16,15,19,19,16,20,16, 0,18,16,
+ 19,17,19, 0, 8,10,10,14,14,10,12,12,16,15,10,12,
+ 12,16,16,13,15,15,18,17,14,16,16,19, 0, 9,11,11,
+ 16,15,11,14,13,18,17,11,12,13,17,18,14,17,16,18,
+ 18,15,16,17,18,18, 9,12,12,16,16,11,13,13,16,18,
+ 11,14,13,17,17,15,16,16,18,20,16,17,17,20,20,12,
+ 14,14,18,17,14,16,16, 0,19,13,14,15,18, 0,16, 0,
+ 0, 0, 0,16,16, 0,19,20,13,15,14, 0, 0,14,16,16,
+ 18,19,14,16,15, 0,20,16,20,18, 0,20,17,20,17, 0,
+ 0,
+};
+
+static const static_codebook _44u4__p3_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44u4__p3_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44u4__p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44u4__p4_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44u4__p4_0[] = {
+ 4, 5, 5, 8, 8, 5, 7, 6, 9, 9, 5, 6, 7, 9, 9, 9,
+ 9, 9,11,11, 8, 9, 9,11,11, 5, 7, 7, 9, 9, 7, 8,
+ 8,10,10, 7, 7, 8,10,10, 9,10,10,11,12, 9,10,10,
+ 11,12, 5, 7, 7, 9, 9, 7, 8, 7,10,10, 7, 8, 8,10,
+ 10, 9,10,10,12,11, 9,10,10,12,11, 9,10, 9,12,12,
+ 9,10,10,13,12, 9,10,10,12,12,12,12,12,14,14,11,
+ 12,12,13,14, 9, 9,10,12,12, 9,10,10,13,13, 9,10,
+ 10,12,13,11,12,12,14,13,11,12,12,14,14, 5, 7, 7,
+ 9, 9, 7, 8, 8,10,10, 7, 8, 8,10,10,10,10,10,12,
+ 12, 9,10,10,12,12, 7, 8, 8,11,10, 8, 8, 9,11,11,
+ 8, 9, 9,11,11,11,11,11,12,13,10,11,11,13,13, 6,
+ 8, 8,10,10, 7, 9, 8,11,10, 8, 9, 9,11,11,10,11,
+ 10,13,11,10,11,11,13,13, 9,11,10,13,12,10,11,11,
+ 13,14,10,11,11,14,13,12,12,13,12,15,12,13,13,15,
+ 15, 9,10,10,12,13,10,11,10,13,12,10,11,11,13,14,
+ 12,13,11,15,13,13,13,13,15,15, 5, 7, 7, 9, 9, 7,
+ 8, 8,10,10, 7, 8, 8,10,10, 9,10,10,12,12,10,10,
+ 11,12,13, 6, 8, 8,10,10, 8, 9, 9,11,11, 7, 8, 9,
+ 10,11,10,11,11,13,13,10,10,11,11,13, 7, 8, 8,10,
+ 11, 8, 9, 9,11,11, 8, 9, 8,11,11,10,11,11,13,13,
+ 11,12,11,13,12, 9,10,10,13,12,10,11,11,14,13,10,
+ 10,11,12,13,12,13,13,15,15,12,11,13,13,14, 9,10,
+ 11,12,13,10,11,11,13,14,10,11,11,13,13,12,13,13,
+ 15,15,12,13,12,15,12, 8, 9, 9,12,12, 9,11,10,13,
+ 13, 9,10,10,13,13,12,13,13,15,15,12,12,12,14,14,
+ 9,10,10,13,13,10,11,11,13,14,10,11,11,14,13,13,
+ 13,14,14,16,13,13,13,15,15, 9,10,10,13,13,10,11,
+ 10,14,13,10,11,11,13,14,12,14,13,16,14,12,13,13,
+ 14,15,11,12,12,15,14,11,12,13,14,15,12,13,13,16,
+ 15,14,12,15,12,16,14,15,15,16,16,11,12,12,14,14,
+ 11,13,12,15,14,12,13,13,15,16,13,15,13,17,13,14,
+ 15,15,16,17, 8, 9, 9,12,12, 9,10,10,12,13, 9,10,
+ 10,13,13,12,12,12,14,14,12,13,13,15,15, 9,10,10,
+ 13,12,10,11,11,14,13,10,10,11,13,14,13,13,13,15,
+ 15,12,13,14,14,16, 9,10,10,13,13,10,11,11,13,14,
+ 10,11,11,14,14,13,13,13,15,15,13,14,13,16,14,11,
+ 12,12,15,14,12,13,13,16,15,11,12,13,14,15,14,15,
+ 15,17,16,13,13,15,13,16,11,12,13,14,15,13,13,13,
+ 15,16,11,13,12,15,14,14,15,15,16,16,14,15,12,17,
+ 13,
+};
+
+static const static_codebook _44u4__p4_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44u4__p4_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44u4__p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44u4__p5_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44u4__p5_0[] = {
+ 2, 3, 3, 6, 6, 7, 7, 9, 9, 4, 5, 5, 7, 7, 8, 8,
+ 10, 9, 4, 5, 5, 7, 7, 8, 8,10,10, 6, 7, 7, 8, 8,
+ 9, 9,11,10, 6, 7, 7, 8, 8, 9, 9,10,11, 7, 8, 8,
+ 9, 9,10,10,11,11, 7, 8, 8, 9, 9,10,10,11,11, 9,
+ 10,10,11,10,11,11,12,12, 9,10,10,10,11,11,11,12,
+ 12,
+};
+
+static const static_codebook _44u4__p5_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44u4__p5_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44u4__p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44u4__p6_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44u4__p6_0[] = {
+ 1, 4, 4, 6, 6, 8, 8, 9, 9,11,10,13,13, 4, 6, 5,
+ 8, 8, 9, 9,10,10,11,11,14,14, 4, 6, 6, 8, 8, 9,
+ 9,10,10,11,11,14,14, 6, 8, 8, 9, 9,10,10,11,11,
+ 12,12,15,15, 6, 8, 8, 9, 9,10,11,11,11,12,12,15,
+ 15, 8, 9, 9,11,10,11,11,12,12,13,13,16,16, 8, 9,
+ 9,10,10,11,11,12,12,13,13,16,16,10,10,10,12,11,
+ 12,12,13,13,14,14,16,16,10,10,10,11,12,12,12,13,
+ 13,13,14,16,17,11,12,11,12,12,13,13,14,14,15,14,
+ 18,17,11,11,12,12,12,13,13,14,14,14,15,19,18,14,
+ 15,14,15,15,17,16,17,17,17,17,21, 0,14,15,15,16,
+ 16,16,16,17,17,18,17,20,21,
+};
+
+static const static_codebook _44u4__p6_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44u4__p6_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44u4__p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44u4__p6_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44u4__p6_1[] = {
+ 2, 4, 4, 5, 5, 4, 5, 5, 6, 5, 4, 5, 5, 5, 6, 5,
+ 6, 5, 6, 6, 5, 5, 6, 6, 6,
+};
+
+static const static_codebook _44u4__p6_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44u4__p6_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44u4__p6_1,
+ 0
+};
+
+static const long _vq_quantlist__44u4__p7_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44u4__p7_0[] = {
+ 1, 3, 3,12,12,12,12,12,12,12,12,12,12, 3,12,11,
+ 12,12,12,12,12,12,12,12,12,12, 4,11,10,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,
+};
+
+static const static_codebook _44u4__p7_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44u4__p7_0,
+ 1, -514332672, 1627381760, 4, 0,
+ (long *)_vq_quantlist__44u4__p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44u4__p7_1[] = {
+ 7,
+ 6,
+ 8,
+ 5,
+ 9,
+ 4,
+ 10,
+ 3,
+ 11,
+ 2,
+ 12,
+ 1,
+ 13,
+ 0,
+ 14,
+};
+
+static const long _vq_lengthlist__44u4__p7_1[] = {
+ 1, 4, 4, 6, 6, 7, 7, 9, 8,10, 8,10, 9,11,11, 4,
+ 7, 6, 8, 7, 9, 9,10,10,11,10,11,10,12,10, 4, 6,
+ 7, 8, 8, 9, 9,10,10,11,11,11,11,12,12, 6, 8, 8,
+ 10, 9,11,10,12,11,12,12,12,12,13,13, 6, 8, 8,10,
+ 10,10,11,11,11,12,12,13,12,13,13, 8, 9, 9,11,11,
+ 12,11,12,12,13,13,13,13,13,13, 8, 9, 9,11,11,11,
+ 12,12,12,13,13,13,13,13,13, 9,10,10,12,11,13,13,
+ 13,13,14,13,13,14,14,14, 9,10,11,11,12,12,13,13,
+ 13,13,13,14,15,14,14,10,11,11,12,12,13,13,14,14,
+ 14,14,14,15,16,16,10,11,11,12,13,13,13,13,15,14,
+ 14,15,16,15,16,10,12,12,13,13,14,14,14,15,15,15,
+ 15,15,15,16,11,12,12,13,13,14,14,14,15,15,15,16,
+ 15,17,16,11,12,12,13,13,13,15,15,14,16,16,16,16,
+ 16,17,11,12,12,13,13,14,14,15,14,15,15,17,17,16,
+ 16,
+};
+
+static const static_codebook _44u4__p7_1 = {
+ 2, 225,
+ (long *)_vq_lengthlist__44u4__p7_1,
+ 1, -522338304, 1620115456, 4, 0,
+ (long *)_vq_quantlist__44u4__p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44u4__p7_2[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44u4__p7_2[] = {
+ 2, 5, 5, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 9,
+ 9, 5, 6, 6, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9,
+ 9, 9, 5, 6, 6, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 9,
+ 9, 9, 9, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9,
+ 10,10,10,10, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9,10,
+ 9,10, 9,10,10, 7, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9,
+ 10,10,10,10,10,10, 7, 8, 8, 8, 8, 9, 9, 9, 9, 9,
+ 9,10,10,10,10,10,10, 8, 9, 8, 9, 9, 9, 9, 9, 9,
+ 10,10,10,10,10,10,10,10, 8, 8, 8, 9, 9, 9, 9, 9,
+ 10,10,10,10,10,10,10,10,10, 9, 9, 9, 9, 9,10,10,
+ 10,10,10,10,10,10,10,10,10,10, 9, 9, 9, 9, 9,10,
+ 10,10,10,10,10,10,10,10,10,10,10, 9, 9, 9, 9,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10, 9, 9, 9, 9,
+ 10,10,10,10,10,10,10,10,10,11,10,10,10, 9, 9, 9,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10, 9, 9,
+ 9,10,10,10,10,10,10,10,10,10,10,10,10,10,10, 9,
+ 10, 9,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 9,10, 9,10,10,10,10,10,10,10,10,10,10,11,10,10,
+ 10,
+};
+
+static const static_codebook _44u4__p7_2 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44u4__p7_2,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44u4__p7_2,
+ 0
+};
+
+static const long _huff_lengthlist__44u4__short[] = {
+ 14,17,15,17,16,14,13,16,10, 7, 7,10,13,10,15,16,
+ 9, 4, 4, 6, 5, 7, 9,16,12, 8, 7, 8, 8, 8,11,16,
+ 14, 7, 4, 6, 3, 5, 8,15,13, 8, 5, 7, 4, 5, 7,16,
+ 12, 9, 6, 8, 3, 3, 5,16,14,13, 7,10, 5, 5, 7,15,
+};
+
+static const static_codebook _huff_book__44u4__short = {
+ 2, 64,
+ (long *)_huff_lengthlist__44u4__short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44u5__long[] = {
+ 3, 8,13,12,14,12,16,11,13,14, 5, 4, 5, 6, 7, 8,
+ 10, 9,12,15,10, 5, 5, 5, 6, 8, 9, 9,13,15,10, 5,
+ 5, 6, 6, 7, 8, 8,11,13,12, 7, 5, 6, 4, 6, 7, 7,
+ 11,14,11, 7, 7, 6, 6, 6, 7, 6,10,14,14, 9, 8, 8,
+ 6, 7, 7, 7,11,16,11, 8, 8, 7, 6, 6, 7, 4, 7,12,
+ 10,10,12,10,10, 9,10, 5, 6, 9,10,12,15,13,14,14,
+ 14, 8, 7, 8,
+};
+
+static const static_codebook _huff_book__44u5__long = {
+ 2, 100,
+ (long *)_huff_lengthlist__44u5__long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44u5__p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44u5__p1_0[] = {
+ 1, 4, 4, 5, 8, 7, 5, 7, 7, 5, 8, 8, 8,10,10, 7,
+ 9,10, 5, 8, 8, 7,10, 9, 8,10,10, 5, 8, 8, 8,10,
+ 10, 8,10,10, 8,10,10,10,12,13,10,13,13, 7,10,10,
+ 10,13,11,10,13,13, 4, 8, 8, 8,11,10, 8,10,10, 7,
+ 10,10,10,13,13,10,11,13, 8,10,11,10,13,13,10,13,
+ 12,
+};
+
+static const static_codebook _44u5__p1_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44u5__p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44u5__p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44u5__p2_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44u5__p2_0[] = {
+ 3, 4, 4, 5, 6, 6, 5, 6, 6, 5, 6, 6, 6, 8, 8, 6,
+ 7, 8, 5, 6, 6, 6, 8, 7, 6, 8, 8, 5, 6, 6, 6, 8,
+ 8, 6, 8, 8, 6, 8, 8, 8, 9, 9, 8, 9, 9, 6, 8, 7,
+ 7, 9, 8, 8, 9, 9, 5, 6, 6, 6, 8, 7, 6, 8, 8, 6,
+ 8, 7, 8, 9, 9, 7, 8, 9, 6, 8, 8, 8, 9, 9, 8, 9,
+ 9,
+};
+
+static const static_codebook _44u5__p2_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44u5__p2_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44u5__p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44u5__p3_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44u5__p3_0[] = {
+ 2, 4, 5, 8, 8, 5, 7, 6, 9, 9, 5, 6, 7, 9, 9, 8,
+ 10, 9,13,12, 8, 9,10,12,12, 5, 7, 7,10,10, 7, 9,
+ 9,11,11, 6, 8, 9,11,11,10,11,11,14,14, 9,10,11,
+ 13,14, 5, 7, 7, 9,10, 7, 9, 8,11,11, 7, 9, 9,11,
+ 11, 9,11,10,14,13,10,11,11,14,14, 8,10,10,13,13,
+ 10,11,11,15,14, 9,11,11,14,14,13,14,14,17,16,12,
+ 13,13,15,16, 8,10,10,13,13, 9,11,11,14,15,10,11,
+ 11,14,15,12,14,13,16,16,13,15,14,15,17, 5, 7, 7,
+ 10,10, 7, 9, 9,11,11, 7, 9, 9,11,11,10,11,11,14,
+ 14,10,11,12,14,14, 7, 9, 9,12,11, 9,11,11,13,13,
+ 9,11,11,13,13,12,13,13,15,16,11,12,13,15,16, 6,
+ 9, 9,11,11, 8,11,10,13,12, 9,11,11,13,14,11,13,
+ 12,16,14,11,13,13,16,17,10,12,11,15,15,11,13,13,
+ 16,16,11,13,13,17,16,14,15,15,17,17,14,16,16,17,
+ 18, 9,11,11,14,15,10,12,12,15,15,11,13,13,16,17,
+ 13,15,13,17,15,14,15,16,18, 0, 5, 7, 7,10,10, 7,
+ 9, 9,11,11, 7, 9, 9,11,11,10,11,11,14,14,10,11,
+ 12,14,15, 6, 9, 9,12,11, 9,11,11,13,13, 8,10,11,
+ 12,13,11,13,13,16,15,11,12,13,14,15, 7, 9, 9,11,
+ 12, 9,11,11,13,13, 9,11,11,13,13,11,13,13,15,16,
+ 11,13,13,15,14, 9,11,11,15,14,11,13,13,17,15,10,
+ 12,12,15,15,14,16,16,17,17,13,13,15,15,17,10,11,
+ 12,15,15,11,13,13,16,16,11,13,13,15,15,14,15,15,
+ 18,18,14,15,15,17,17, 8,10,10,13,13,10,12,11,15,
+ 15,10,11,12,15,15,14,15,15,18,18,13,14,14,18,18,
+ 9,11,11,15,16,11,13,13,17,17,11,13,13,16,16,15,
+ 15,16,17, 0,14,15,17, 0, 0, 9,11,11,15,15,10,13,
+ 12,18,16,11,13,13,15,16,14,16,15,20,20,14,15,16,
+ 17, 0,13,14,14,20,16,14,15,16,19,18,14,15,15,19,
+ 0,18,16, 0,20,20,16,18,18, 0, 0,12,14,14,18,18,
+ 13,15,14,18,16,14,15,16,18,20,16,19,16, 0,17,17,
+ 18,18,19, 0, 8,10,10,14,14,10,11,11,14,15,10,11,
+ 12,15,15,13,15,14,19,17,13,15,15,17, 0, 9,11,11,
+ 16,15,11,13,13,16,16,10,12,13,15,17,14,16,16,18,
+ 18,14,15,15,18, 0, 9,11,11,15,15,11,13,13,16,17,
+ 11,13,13,18,17,14,18,16,18,18,15,17,17,18, 0,12,
+ 14,14,18,18,14,15,15,20, 0,13,14,15,17, 0,16,18,
+ 17, 0, 0,16,16, 0,17,20,12,14,14,18,18,14,16,15,
+ 0,18,14,16,15,18, 0,16,19,17, 0, 0,17,18,16, 0,
+ 0,
+};
+
+static const static_codebook _44u5__p3_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44u5__p3_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44u5__p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44u5__p4_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44u5__p4_0[] = {
+ 4, 5, 5, 8, 8, 6, 7, 6, 9, 9, 6, 6, 7, 9, 9, 8,
+ 9, 9,11,11, 8, 9, 9,11,11, 6, 7, 7, 9, 9, 7, 8,
+ 8,10,10, 6, 7, 8, 9,10, 9,10,10,11,12, 9, 9,10,
+ 11,12, 6, 7, 7, 9, 9, 6, 8, 7,10, 9, 7, 8, 8,10,
+ 10, 9,10, 9,12,11, 9,10,10,12,11, 8, 9, 9,12,11,
+ 9,10,10,12,12, 9,10,10,12,12,11,12,12,13,14,11,
+ 11,12,13,14, 8, 9, 9,11,12, 9,10,10,12,12, 9,10,
+ 10,12,12,11,12,11,14,13,11,12,12,13,13, 5, 7, 7,
+ 9, 9, 7, 8, 8,10,10, 7, 8, 8,10,10, 9,10,10,12,
+ 12, 9,10,10,12,12, 7, 8, 8,10,10, 8, 8, 9,10,11,
+ 8, 9, 9,11,11,10,10,11,11,13,10,11,11,12,13, 6,
+ 7, 8,10,10, 7, 9, 8,11,10, 8, 9, 9,11,11,10,11,
+ 10,13,11,10,11,11,12,12, 9,10,10,12,12,10,10,11,
+ 12,13,10,11,11,13,13,12,11,13,12,15,12,13,13,14,
+ 15, 9,10,10,12,12, 9,11,10,13,12,10,11,11,13,13,
+ 11,13,11,14,12,12,13,13,14,15, 5, 7, 7, 9, 9, 7,
+ 8, 8,10,10, 7, 8, 8,10,10, 9,10,10,12,12, 9,10,
+ 10,12,12, 6, 8, 7,10,10, 8, 9, 9,11,11, 7, 8, 9,
+ 10,11,10,11,11,12,12,10,10,11,11,13, 7, 8, 8,10,
+ 10, 8, 9, 9,11,11, 8, 9, 8,11,10,10,11,11,13,12,
+ 10,11,10,13,11, 9,10,10,12,12,10,11,11,13,12, 9,
+ 10,10,12,13,12,13,13,14,15,11,11,13,12,14, 9,10,
+ 10,12,12,10,11,11,13,13,10,11,10,13,12,12,13,13,
+ 14,14,12,13,11,14,12, 8, 9, 9,12,12, 9,10,10,12,
+ 12, 9,10,10,12,12,12,12,12,14,14,11,12,12,14,13,
+ 9,10,10,12,12,10,11,11,13,13,10,11,11,13,12,12,
+ 12,13,14,15,12,13,13,15,14, 9,10,10,12,12,10,11,
+ 10,13,12,10,11,11,12,13,12,13,12,15,13,12,13,13,
+ 14,15,11,12,12,14,13,11,12,12,14,15,12,13,13,15,
+ 14,13,12,14,12,16,13,14,14,15,15,11,11,12,14,14,
+ 11,12,11,14,13,12,13,13,14,15,13,14,12,16,12,14,
+ 14,15,16,16, 8, 9, 9,11,12, 9,10,10,12,12, 9,10,
+ 10,12,13,11,12,12,13,13,12,12,13,14,14, 9,10,10,
+ 12,12,10,11,10,13,12,10,10,11,12,13,12,13,13,15,
+ 14,12,12,13,13,15, 9,10,10,12,13,10,11,11,12,13,
+ 10,11,11,13,13,12,13,13,14,15,12,13,12,15,14,11,
+ 12,11,14,13,12,13,13,15,14,11,11,12,13,14,14,15,
+ 14,16,15,13,12,14,13,16,11,12,12,13,14,12,13,13,
+ 14,15,11,12,11,14,14,14,14,14,15,16,13,15,12,16,
+ 12,
+};
+
+static const static_codebook _44u5__p4_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44u5__p4_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44u5__p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44u5__p5_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44u5__p5_0[] = {
+ 2, 3, 3, 6, 6, 8, 8,10,10, 4, 5, 5, 8, 7, 8, 8,
+ 11,10, 3, 5, 5, 7, 8, 8, 8,10,11, 6, 8, 7,10, 9,
+ 10,10,11,11, 6, 7, 8, 9, 9, 9,10,11,12, 8, 8, 8,
+ 10,10,11,11,13,12, 8, 8, 9, 9,10,11,11,12,13,10,
+ 11,10,12,11,13,12,14,14,10,10,11,11,12,12,13,14,
+ 14,
+};
+
+static const static_codebook _44u5__p5_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44u5__p5_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44u5__p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44u5__p6_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44u5__p6_0[] = {
+ 3, 4, 4, 5, 5, 7, 7, 9, 9, 4, 5, 4, 6, 6, 7, 7,
+ 9, 9, 4, 4, 5, 6, 6, 7, 7, 9, 9, 5, 6, 6, 7, 7,
+ 8, 8,10,10, 6, 6, 6, 7, 7, 8, 8,10,10, 7, 7, 7,
+ 8, 8, 9, 9,11,10, 7, 7, 7, 8, 8, 9, 9,10,11, 9,
+ 9, 9,10,10,11,10,11,11, 9, 9, 9,10,10,11,10,11,
+ 11,
+};
+
+static const static_codebook _44u5__p6_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44u5__p6_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44u5__p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44u5__p7_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44u5__p7_0[] = {
+ 1, 4, 4, 5, 7, 7, 5, 7, 7, 5, 9, 9, 8,11,10, 7,
+ 11,10, 5, 9, 9, 7,10,10, 8,10,11, 4, 9, 9, 9,12,
+ 12, 9,12,12, 8,12,12,11,12,12,10,12,13, 7,12,12,
+ 11,12,12,10,12,13, 4, 9, 9, 9,12,12, 9,12,12, 7,
+ 12,11,10,13,13,11,12,12, 7,12,12,10,13,13,11,12,
+ 12,
+};
+
+static const static_codebook _44u5__p7_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44u5__p7_0,
+ 1, -529137664, 1618345984, 2, 0,
+ (long *)_vq_quantlist__44u5__p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44u5__p7_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44u5__p7_1[] = {
+ 2, 4, 4, 6, 6, 7, 7, 8, 8, 8, 8, 4, 5, 5, 7, 7,
+ 8, 8, 9, 8, 8, 9, 4, 5, 5, 7, 7, 8, 8, 9, 9, 8,
+ 9, 6, 7, 7, 8, 8, 9, 8, 9, 9, 9, 9, 6, 7, 7, 8,
+ 8, 9, 9, 9, 9, 9, 9, 7, 8, 8, 9, 9, 9, 9, 9, 9,
+ 9, 9, 7, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 8, 9, 9,
+ 9, 9, 9, 9,10,10,10,10, 8, 9, 9, 9, 9, 9, 9,10,
+ 10,10,10, 8, 9, 9, 9, 9, 9, 9,10,10,10,10, 8, 9,
+ 9, 9, 9, 9, 9,10,10,10,10,
+};
+
+static const static_codebook _44u5__p7_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44u5__p7_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44u5__p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44u5__p8_0[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44u5__p8_0[] = {
+ 1, 4, 4, 6, 6, 8, 8, 9, 9,10,10, 4, 6, 6, 7, 7,
+ 9, 9,10,10,11,11, 4, 6, 6, 7, 7, 9, 9,10,10,11,
+ 11, 6, 8, 7, 9, 9,10,10,11,11,13,12, 6, 8, 8, 9,
+ 9,10,10,11,11,12,13, 8, 9, 9,10,10,12,12,13,12,
+ 14,13, 8, 9, 9,10,10,12,12,13,13,14,14, 9,11,11,
+ 12,12,13,13,14,14,15,14, 9,11,11,12,12,13,13,14,
+ 14,15,14,11,12,12,13,13,14,14,15,14,15,14,11,11,
+ 12,13,13,14,14,14,14,15,15,
+};
+
+static const static_codebook _44u5__p8_0 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44u5__p8_0,
+ 1, -524582912, 1618345984, 4, 0,
+ (long *)_vq_quantlist__44u5__p8_0,
+ 0
+};
+
+static const long _vq_quantlist__44u5__p8_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44u5__p8_1[] = {
+ 3, 5, 5, 6, 6, 7, 7, 7, 7, 7, 7, 5, 6, 5, 7, 6,
+ 7, 7, 8, 8, 8, 8, 5, 5, 5, 6, 6, 7, 7, 8, 8, 8,
+ 8, 6, 7, 6, 7, 7, 8, 8, 8, 8, 8, 8, 6, 6, 7, 7,
+ 7, 8, 8, 8, 8, 8, 8, 7, 7, 7, 8, 8, 8, 8, 8, 8,
+ 8, 8, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 7, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 7, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8,
+};
+
+static const static_codebook _44u5__p8_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44u5__p8_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44u5__p8_1,
+ 0
+};
+
+static const long _vq_quantlist__44u5__p9_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44u5__p9_0[] = {
+ 1, 3, 2,12,10,13,13,13,13,13,13,13,13, 4, 9, 9,
+ 13,13,13,13,13,13,13,13,13,13, 5,10, 9,13,13,13,
+ 13,13,13,13,13,13,13,12,13,13,13,13,13,13,13,13,
+ 13,13,13,13,11,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
+ 13,13,13,13,13,13,13,13,13,13,13,13,13,12,12,12,
+ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+ 12,12,12,12,12,12,12,12,12,
+};
+
+static const static_codebook _44u5__p9_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44u5__p9_0,
+ 1, -514332672, 1627381760, 4, 0,
+ (long *)_vq_quantlist__44u5__p9_0,
+ 0
+};
+
+static const long _vq_quantlist__44u5__p9_1[] = {
+ 7,
+ 6,
+ 8,
+ 5,
+ 9,
+ 4,
+ 10,
+ 3,
+ 11,
+ 2,
+ 12,
+ 1,
+ 13,
+ 0,
+ 14,
+};
+
+static const long _vq_lengthlist__44u5__p9_1[] = {
+ 1, 4, 4, 7, 7, 8, 8, 8, 7, 8, 7, 9, 8, 9, 9, 4,
+ 7, 6, 9, 8,10,10, 9, 8, 9, 9, 9, 9, 9, 8, 5, 6,
+ 6, 8, 9,10,10, 9, 9, 9,10,10,10,10,11, 7, 8, 8,
+ 10,10,11,11,10,10,11,11,11,12,11,11, 7, 8, 8,10,
+ 10,11,11,10,10,11,11,12,11,11,11, 8, 9, 9,11,11,
+ 12,12,11,11,12,11,12,12,12,12, 8, 9,10,11,11,12,
+ 12,11,11,12,12,12,12,12,12, 8, 9, 9,10,10,12,11,
+ 12,12,12,12,12,12,12,13, 8, 9, 9,11,11,11,11,12,
+ 12,12,12,13,12,13,13, 9,10,10,11,11,12,12,12,13,
+ 12,13,13,13,14,13, 9,10,10,11,11,12,12,12,13,13,
+ 12,13,13,14,13, 9,11,10,12,11,13,12,12,13,13,13,
+ 13,13,13,14, 9,10,10,12,12,12,12,12,13,13,13,13,
+ 13,14,14,10,11,11,12,12,12,13,13,13,14,14,13,14,
+ 14,14,10,11,11,12,12,12,12,13,12,13,14,13,14,14,
+ 14,
+};
+
+static const static_codebook _44u5__p9_1 = {
+ 2, 225,
+ (long *)_vq_lengthlist__44u5__p9_1,
+ 1, -522338304, 1620115456, 4, 0,
+ (long *)_vq_quantlist__44u5__p9_1,
+ 0
+};
+
+static const long _vq_quantlist__44u5__p9_2[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44u5__p9_2[] = {
+ 2, 5, 5, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9,
+ 9, 5, 6, 6, 7, 7, 8, 8, 9, 8, 9, 9, 9, 9, 9, 9,
+ 9, 9, 5, 6, 6, 7, 7, 8, 8, 9, 8, 9, 9, 9, 9, 9,
+ 9, 9, 9, 7, 7, 7, 8, 8, 9, 8, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 7, 7, 7, 8, 8, 9, 8, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9,
+ 9,10, 9,10,10,10, 8, 8, 8, 9, 8, 9, 9, 9, 9, 9,
+ 9, 9,10, 9,10, 9,10, 8, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9,10, 9,10,10,10,10,10, 8, 9, 9, 9, 9, 9, 9,10,
+ 9,10, 9,10,10,10,10,10,10, 9, 9, 9, 9, 9,10, 9,
+ 10,10,10,10,10,10,10,10,10,10, 9, 9, 9, 9, 9, 9,
+ 9,10, 9,10, 9,10,10,10,10,10,10, 9, 9, 9, 9, 9,
+ 10,10,10,10,10,10,10,10,10,10,10,10, 9, 9, 9, 9,
+ 9, 9,10,10,10,10,10,10,10,10,10,10,10, 9, 9, 9,
+ 9,10,10, 9,10,10,10,10,10,10,10,10,10,10, 9, 9,
+ 9, 9, 9,10,10,10,10,10,10,10,10,10,10,10,10, 9,
+ 9, 9, 9, 9,10,10,10,10,10,10,10,10,10,10,10,10,
+ 9, 9, 9,10, 9,10,10,10,10,10,10,10,10,10,10,10,
+ 10,
+};
+
+static const static_codebook _44u5__p9_2 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44u5__p9_2,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44u5__p9_2,
+ 0
+};
+
+static const long _huff_lengthlist__44u5__short[] = {
+ 4,10,17,13,17,13,17,17,17,17, 3, 6, 8, 9,11, 9,
+ 15,12,16,17, 6, 5, 5, 7, 7, 8,10,11,17,17, 7, 8,
+ 7, 9, 9,10,13,13,17,17, 8, 6, 5, 7, 4, 7, 5, 8,
+ 14,17, 9, 9, 8, 9, 7, 9, 8,10,16,17,12,10, 7, 8,
+ 4, 7, 4, 7,16,17,12,11, 9,10, 6, 9, 5, 7,14,17,
+ 14,13,10,15, 4, 8, 3, 5,14,17,17,14,11,15, 6,10,
+ 6, 8,15,17,
+};
+
+static const static_codebook _huff_book__44u5__short = {
+ 2, 100,
+ (long *)_huff_lengthlist__44u5__short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44u6__long[] = {
+ 3, 9,14,13,14,13,16,12,13,14, 5, 4, 6, 6, 8, 9,
+ 11,10,12,15,10, 5, 5, 6, 6, 8,10,10,13,16,10, 6,
+ 6, 6, 6, 8, 9, 9,12,14,13, 7, 6, 6, 4, 6, 6, 7,
+ 11,14,10, 7, 7, 7, 6, 6, 6, 7,10,13,15,10, 9, 8,
+ 5, 6, 5, 6,10,14,10, 9, 8, 8, 6, 6, 5, 4, 6,11,
+ 11,11,12,11,10, 9, 9, 5, 5, 9,10,12,15,13,13,13,
+ 13, 8, 7, 7,
+};
+
+static const static_codebook _huff_book__44u6__long = {
+ 2, 100,
+ (long *)_huff_lengthlist__44u6__long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44u6__p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44u6__p1_0[] = {
+ 1, 4, 4, 4, 8, 7, 5, 7, 7, 5, 8, 8, 8,10,10, 7,
+ 9,10, 5, 8, 8, 7,10, 9, 8,10,10, 5, 8, 8, 8,10,
+ 10, 8,10,10, 8,10,10,10,12,13,10,13,13, 7,10,10,
+ 10,13,11,10,13,13, 5, 8, 8, 8,11,10, 8,10,10, 7,
+ 10,10,10,13,13,10,11,13, 8,10,11,10,13,13,10,13,
+ 12,
+};
+
+static const static_codebook _44u6__p1_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44u6__p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44u6__p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44u6__p2_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44u6__p2_0[] = {
+ 3, 4, 4, 5, 6, 6, 5, 6, 6, 5, 6, 6, 6, 8, 8, 6,
+ 7, 8, 5, 6, 6, 6, 8, 7, 6, 8, 8, 5, 6, 6, 6, 8,
+ 8, 6, 8, 8, 6, 8, 8, 8, 9, 9, 8, 9, 9, 6, 7, 7,
+ 7, 9, 8, 8, 9, 9, 5, 6, 6, 6, 8, 7, 6, 8, 8, 6,
+ 8, 8, 8, 9, 9, 7, 8, 9, 6, 8, 8, 8, 9, 9, 8, 9,
+ 9,
+};
+
+static const static_codebook _44u6__p2_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44u6__p2_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44u6__p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44u6__p3_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44u6__p3_0[] = {
+ 2, 5, 4, 8, 8, 5, 7, 6, 9, 9, 5, 6, 7, 9, 9, 8,
+ 9, 9,13,12, 8, 9,10,12,13, 5, 7, 7,10, 9, 7, 9,
+ 9,11,11, 7, 8, 9,11,11,10,11,11,14,14, 9,10,11,
+ 13,14, 5, 7, 7, 9,10, 6, 9, 8,11,11, 7, 9, 9,11,
+ 11, 9,11,10,14,13,10,11,11,14,13, 8,10,10,13,13,
+ 10,11,11,15,15, 9,11,11,14,14,13,14,14,17,16,12,
+ 13,14,16,16, 8,10,10,13,14, 9,11,11,14,15,10,11,
+ 12,14,15,12,14,13,16,15,13,14,14,15,17, 5, 7, 7,
+ 10,10, 7, 9, 9,11,11, 7, 9, 9,11,11,10,12,11,14,
+ 14,10,11,11,14,14, 7, 9, 9,12,11, 9,11,11,13,13,
+ 9,11,11,13,13,11,13,13,14,15,11,12,13,15,16, 6,
+ 9, 9,11,12, 8,11,10,13,12, 9,11,11,13,14,11,13,
+ 12,16,14,11,13,13,15,16,10,12,11,14,15,11,13,13,
+ 15,17,11,13,13,17,16,15,15,16,17,16,14,15,16,18,
+ 0, 9,11,11,14,15,10,12,12,16,15,11,13,13,16,16,
+ 13,15,14,18,15,14,16,16, 0, 0, 5, 7, 7,10,10, 7,
+ 9, 9,11,11, 7, 9, 9,11,11,10,11,11,14,14,10,11,
+ 12,14,14, 6, 9, 9,11,11, 9,11,11,13,13, 8,10,11,
+ 12,13,11,13,13,16,15,11,12,13,14,16, 7, 9, 9,11,
+ 12, 9,11,11,13,13, 9,11,11,13,13,11,13,13,16,15,
+ 11,13,12,15,15, 9,11,11,15,14,11,13,13,17,16,10,
+ 12,13,15,16,14,16,16, 0,18,14,14,15,15,17,10,11,
+ 12,15,15,11,13,13,16,16,11,13,13,16,16,14,16,16,
+ 19,17,14,15,15,17,17, 8,10,10,14,14,10,12,11,15,
+ 15,10,11,12,16,15,14,15,15,18,20,13,14,16,17,18,
+ 9,11,11,15,16,11,13,13,17,17,11,13,13,17,16,15,
+ 16,16, 0, 0,15,16,16, 0, 0, 9,11,11,15,15,10,13,
+ 12,17,15,11,13,13,17,16,15,17,15,20,19,15,16,16,
+ 19, 0,13,15,14, 0,17,14,15,16, 0,20,15,16,16, 0,
+ 19,17,18, 0, 0, 0,16,17,18, 0, 0,12,14,14,19,18,
+ 13,15,14, 0,17,14,15,16,19,19,16,18,16, 0,19,19,
+ 20,17,20, 0, 8,10,10,13,14,10,11,11,15,15,10,12,
+ 12,15,16,14,15,14,19,16,14,15,15, 0,18, 9,11,11,
+ 16,15,11,13,13, 0,16,11,12,13,16,17,14,16,17, 0,
+ 19,15,16,16,18, 0, 9,11,11,15,16,11,13,13,16,16,
+ 11,14,13,18,17,15,16,16,18,20,15,17,19, 0, 0,12,
+ 14,14,17,17,14,16,15, 0, 0,13,14,15,19, 0,16,18,
+ 20, 0, 0,16,16,18,18, 0,12,14,14,17,20,14,16,16,
+ 19, 0,14,16,14, 0,20,16,20,17, 0, 0,17, 0,15, 0,
+ 19,
+};
+
+static const static_codebook _44u6__p3_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44u6__p3_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44u6__p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44u6__p4_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44u6__p4_0[] = {
+ 4, 5, 5, 8, 8, 6, 7, 6, 9, 9, 6, 6, 7, 9, 9, 8,
+ 9, 9,11,11, 8, 9, 9,11,11, 6, 7, 7, 9, 9, 7, 8,
+ 8,10,10, 7, 7, 8, 9,10, 9,10,10,11,11, 9, 9,10,
+ 11,12, 6, 7, 7, 9, 9, 7, 8, 7,10, 9, 7, 8, 8,10,
+ 10, 9,10, 9,12,11, 9,10,10,12,11, 8, 9, 9,11,11,
+ 9,10,10,12,12, 9,10,10,12,12,11,12,12,14,13,11,
+ 11,12,13,13, 8, 9, 9,11,11, 9,10,10,12,12, 9,10,
+ 10,12,12,11,12,11,13,12,11,12,12,13,13, 5, 7, 7,
+ 9, 9, 7, 8, 7,10,10, 7, 7, 8,10,10, 9,10,10,12,
+ 11, 9,10,10,11,12, 7, 8, 8,10,10, 8, 8, 9,11,11,
+ 8, 9, 9,11,11,10,10,11,12,13,10,10,11,12,12, 6,
+ 7, 7,10,10, 7, 9, 8,11,10, 8, 8, 9,10,11,10,11,
+ 10,13,11,10,11,11,12,12, 9,10,10,12,12,10,10,11,
+ 13,13,10,11,11,12,13,12,12,12,13,14,12,12,13,14,
+ 14, 9,10,10,12,12, 9,10,10,13,12,10,11,11,13,13,
+ 11,12,11,14,12,12,13,13,14,14, 6, 7, 7, 9, 9, 7,
+ 8, 7,10,10, 7, 8, 8,10,10, 9,10,10,12,11, 9,10,
+ 10,11,12, 6, 7, 7,10,10, 8, 9, 8,11,10, 7, 8, 9,
+ 10,11,10,11,11,12,12,10,10,11,11,13, 7, 8, 8,10,
+ 10, 8, 9, 9,11,11, 8, 9, 8,11,11,10,11,10,13,12,
+ 10,11,11,13,12, 9,10,10,12,12,10,11,11,13,12, 9,
+ 10,10,12,13,12,13,12,14,14,11,11,12,12,14, 9,10,
+ 10,12,12,10,11,11,13,13,10,11,10,13,12,12,12,12,
+ 14,14,12,13,12,14,13, 8, 9, 9,11,11, 9,10,10,12,
+ 12, 9,10,10,12,12,11,12,12,14,13,11,12,12,13,14,
+ 9,10,10,12,12,10,11,11,13,13,10,11,11,13,13,12,
+ 12,13,14,15,12,12,13,14,14, 9,10,10,12,12, 9,11,
+ 10,13,12,10,10,11,12,13,12,13,12,14,13,12,12,13,
+ 14,15,11,12,12,14,13,11,12,12,14,14,12,13,13,14,
+ 14,13,13,14,14,16,13,14,14,15,15,11,12,11,13,13,
+ 11,12,11,14,13,12,12,13,14,15,12,14,12,15,12,13,
+ 14,15,15,16, 8, 9, 9,11,11, 9,10,10,12,12, 9,10,
+ 10,12,12,11,12,12,14,13,11,12,12,13,13, 9,10,10,
+ 12,12,10,11,10,13,12, 9,10,11,12,13,12,13,12,14,
+ 14,12,12,13,13,14, 9,10,10,12,12,10,11,11,13,13,
+ 10,11,11,13,13,12,13,12,14,14,12,13,13,14,14,11,
+ 11,11,13,13,12,13,12,14,14,11,11,12,13,14,14,14,
+ 14,16,15,12,12,14,12,15,11,12,12,13,14,12,13,13,
+ 14,15,11,12,12,14,14,13,14,14,16,16,13,14,13,16,
+ 13,
+};
+
+static const static_codebook _44u6__p4_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44u6__p4_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44u6__p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44u6__p5_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44u6__p5_0[] = {
+ 2, 3, 3, 6, 6, 8, 8,10,10, 4, 5, 5, 8, 7, 8, 8,
+ 11,11, 3, 5, 5, 7, 8, 8, 8,11,11, 6, 8, 7, 9, 9,
+ 10, 9,12,11, 6, 7, 8, 9, 9, 9,10,11,12, 8, 8, 8,
+ 10, 9,12,11,13,13, 8, 8, 9, 9,10,11,12,13,13,10,
+ 11,11,12,12,13,13,14,14,10,10,11,11,12,13,13,14,
+ 14,
+};
+
+static const static_codebook _44u6__p5_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44u6__p5_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44u6__p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44u6__p6_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44u6__p6_0[] = {
+ 3, 4, 4, 5, 5, 7, 7, 9, 9, 4, 5, 4, 6, 6, 7, 7,
+ 9, 9, 4, 4, 5, 6, 6, 7, 8, 9, 9, 5, 6, 6, 7, 7,
+ 8, 8,10,10, 5, 6, 6, 7, 7, 8, 8,10,10, 7, 8, 7,
+ 8, 8,10, 9,11,11, 7, 7, 8, 8, 8, 9,10,10,11, 9,
+ 9, 9,10,10,11,11,12,11, 9, 9, 9,10,10,11,11,11,
+ 12,
+};
+
+static const static_codebook _44u6__p6_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44u6__p6_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44u6__p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44u6__p7_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44u6__p7_0[] = {
+ 1, 4, 4, 5, 7, 7, 5, 7, 7, 5, 9, 8, 7,10,10, 8,
+ 10,10, 5, 8, 9, 7,10,10, 7,10, 9, 4, 8, 8, 9,11,
+ 11, 8,11,11, 7,11,11,10,10,13,10,13,13, 7,11,11,
+ 10,13,12,10,13,13, 5, 9, 8, 8,11,11, 9,11,11, 7,
+ 11,11,10,13,13,10,12,13, 7,11,11,10,13,13, 9,13,
+ 10,
+};
+
+static const static_codebook _44u6__p7_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44u6__p7_0,
+ 1, -529137664, 1618345984, 2, 0,
+ (long *)_vq_quantlist__44u6__p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44u6__p7_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44u6__p7_1[] = {
+ 3, 4, 4, 6, 6, 7, 7, 8, 8, 8, 8, 4, 5, 5, 7, 6,
+ 8, 8, 8, 8, 8, 8, 4, 5, 5, 6, 7, 8, 8, 8, 8, 8,
+ 8, 6, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 6, 7, 7, 7,
+ 7, 8, 8, 8, 8, 8, 8, 7, 8, 8, 8, 8, 8, 8, 9, 9,
+ 9, 9, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 8, 8, 8,
+ 8, 8, 9, 9, 9, 9, 9, 9, 8, 8, 8, 8, 8, 9, 9, 9,
+ 9, 9, 9, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 8, 8,
+ 8, 8, 8, 9, 9, 9, 9, 9, 9,
+};
+
+static const static_codebook _44u6__p7_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44u6__p7_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44u6__p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44u6__p8_0[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44u6__p8_0[] = {
+ 1, 4, 4, 6, 6, 8, 8, 9, 9,10,10, 4, 6, 6, 7, 7,
+ 9, 9,10,10,11,11, 4, 6, 6, 7, 7, 9, 9,10,10,11,
+ 11, 6, 8, 8, 9, 9,10,10,11,11,12,12, 6, 8, 8, 9,
+ 9,10,10,11,11,12,12, 8, 9, 9,10,10,11,11,12,12,
+ 13,13, 8, 9, 9,10,10,11,11,12,12,13,13,10,10,10,
+ 11,11,13,13,13,13,15,14, 9,10,10,12,11,12,13,13,
+ 13,14,15,11,12,12,13,13,13,13,15,14,15,15,11,11,
+ 12,13,13,14,14,14,15,15,15,
+};
+
+static const static_codebook _44u6__p8_0 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44u6__p8_0,
+ 1, -524582912, 1618345984, 4, 0,
+ (long *)_vq_quantlist__44u6__p8_0,
+ 0
+};
+
+static const long _vq_quantlist__44u6__p8_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44u6__p8_1[] = {
+ 3, 5, 5, 6, 6, 7, 7, 7, 7, 7, 7, 5, 6, 5, 7, 7,
+ 7, 7, 8, 7, 8, 8, 5, 5, 6, 6, 7, 7, 7, 7, 7, 8,
+ 8, 6, 7, 7, 7, 7, 8, 7, 8, 8, 8, 8, 6, 6, 7, 7,
+ 7, 7, 8, 8, 8, 8, 8, 7, 7, 7, 8, 8, 8, 8, 8, 8,
+ 8, 8, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 7, 7, 7,
+ 8, 8, 8, 8, 8, 8, 8, 8, 7, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 7, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8,
+};
+
+static const static_codebook _44u6__p8_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44u6__p8_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44u6__p8_1,
+ 0
+};
+
+static const long _vq_quantlist__44u6__p9_0[] = {
+ 7,
+ 6,
+ 8,
+ 5,
+ 9,
+ 4,
+ 10,
+ 3,
+ 11,
+ 2,
+ 12,
+ 1,
+ 13,
+ 0,
+ 14,
+};
+
+static const long _vq_lengthlist__44u6__p9_0[] = {
+ 1, 3, 2, 9, 8,15,15,15,15,15,15,15,15,15,15, 4,
+ 8, 9,13,14,14,14,14,14,14,14,14,14,14,14, 5, 8,
+ 9,14,14,14,14,14,14,14,14,14,14,14,14,11,14,14,
+ 14,14,14,14,14,14,14,14,14,14,14,14,11,14,14,14,
+ 14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,
+ 14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,
+ 14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,
+ 14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,
+ 14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,
+ 14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,
+ 14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,
+ 14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,
+ 14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,
+ 14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,
+ 14,
+};
+
+static const static_codebook _44u6__p9_0 = {
+ 2, 225,
+ (long *)_vq_lengthlist__44u6__p9_0,
+ 1, -514071552, 1627381760, 4, 0,
+ (long *)_vq_quantlist__44u6__p9_0,
+ 0
+};
+
+static const long _vq_quantlist__44u6__p9_1[] = {
+ 7,
+ 6,
+ 8,
+ 5,
+ 9,
+ 4,
+ 10,
+ 3,
+ 11,
+ 2,
+ 12,
+ 1,
+ 13,
+ 0,
+ 14,
+};
+
+static const long _vq_lengthlist__44u6__p9_1[] = {
+ 1, 4, 4, 7, 7, 8, 9, 8, 8, 9, 8, 9, 8, 9, 9, 4,
+ 7, 6, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 4, 7,
+ 6, 9, 9,10,10, 9, 9,10,10,10,10,11,11, 7, 9, 8,
+ 10,10,11,11,10,10,11,11,11,11,11,11, 7, 8, 9,10,
+ 10,11,11,10,10,11,11,11,11,11,12, 8,10,10,11,11,
+ 12,12,11,11,12,12,12,12,13,12, 8,10,10,11,11,12,
+ 11,11,11,11,12,12,12,12,13, 8, 9, 9,11,10,11,11,
+ 12,12,12,12,13,12,13,12, 8, 9, 9,11,11,11,11,12,
+ 12,12,12,12,13,13,13, 9,10,10,11,12,12,12,12,12,
+ 13,13,13,13,13,13, 9,10,10,11,11,12,12,12,12,13,
+ 13,13,13,14,13,10,10,10,12,11,12,12,13,13,13,13,
+ 13,13,13,13,10,10,11,11,11,12,12,13,13,13,13,13,
+ 13,13,13,10,11,11,12,12,13,12,12,13,13,13,13,13,
+ 13,14,10,11,11,12,12,13,12,13,13,13,14,13,13,14,
+ 13,
+};
+
+static const static_codebook _44u6__p9_1 = {
+ 2, 225,
+ (long *)_vq_lengthlist__44u6__p9_1,
+ 1, -522338304, 1620115456, 4, 0,
+ (long *)_vq_quantlist__44u6__p9_1,
+ 0
+};
+
+static const long _vq_quantlist__44u6__p9_2[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44u6__p9_2[] = {
+ 3, 5, 5, 7, 7, 8, 8, 8, 8, 8, 8, 9, 8, 8, 9, 9,
+ 9, 5, 6, 6, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9,
+ 9, 9, 5, 6, 6, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9,
+ 9, 9, 9, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 8, 8, 8, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 8, 8, 8, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 8, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9,10, 9, 8, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9,10,10, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,10, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9,10, 9, 9, 9,10, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9,10, 9, 9, 9,10, 9, 9,10, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9,10,10,10, 9,10, 9,10,10,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9,10,10, 9,10,10, 9, 9,
+ 10,
+};
+
+static const static_codebook _44u6__p9_2 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44u6__p9_2,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44u6__p9_2,
+ 0
+};
+
+static const long _huff_lengthlist__44u6__short[] = {
+ 4,11,16,13,17,13,17,16,17,17, 4, 7, 9, 9,13,10,
+ 16,12,16,17, 7, 6, 5, 7, 8, 9,12,12,16,17, 6, 9,
+ 7, 9,10,10,15,15,17,17, 6, 7, 5, 7, 5, 7, 7,10,
+ 16,17, 7, 9, 8, 9, 8,10,11,11,15,17, 7, 7, 7, 8,
+ 5, 8, 8, 9,15,17, 8, 7, 9, 9, 7, 8, 7, 2, 7,15,
+ 14,13,13,15, 5,10, 4, 3, 6,17,17,15,13,17, 7,11,
+ 7, 6, 9,16,
+};
+
+static const static_codebook _huff_book__44u6__short = {
+ 2, 100,
+ (long *)_huff_lengthlist__44u6__short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44u7__long[] = {
+ 3, 9,14,13,15,14,16,13,13,14, 5, 5, 7, 7, 8, 9,
+ 11,10,12,15,10, 6, 5, 6, 6, 9,10,10,13,16,10, 6,
+ 6, 6, 6, 8, 9, 9,12,15,14, 7, 6, 6, 5, 6, 6, 8,
+ 12,15,10, 8, 7, 7, 6, 7, 7, 7,11,13,14,10, 9, 8,
+ 5, 6, 4, 5, 9,12,10, 9, 9, 8, 6, 6, 5, 3, 6,11,
+ 12,11,12,12,10, 9, 8, 5, 5, 8,10,11,15,13,13,13,
+ 12, 8, 6, 7,
+};
+
+static const static_codebook _huff_book__44u7__long = {
+ 2, 100,
+ (long *)_huff_lengthlist__44u7__long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44u7__p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44u7__p1_0[] = {
+ 1, 4, 4, 4, 7, 7, 5, 7, 7, 5, 8, 8, 8,10,10, 7,
+ 10,10, 5, 8, 8, 7,10,10, 8,10,10, 5, 8, 8, 8,11,
+ 10, 8,10,10, 8,10,10,10,12,13,10,13,13, 7,10,10,
+ 10,13,12,10,13,13, 5, 8, 8, 8,11,10, 8,10,11, 7,
+ 10,10,10,13,13,10,12,13, 8,11,11,10,13,13,10,13,
+ 12,
+};
+
+static const static_codebook _44u7__p1_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44u7__p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44u7__p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44u7__p2_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44u7__p2_0[] = {
+ 3, 4, 4, 5, 6, 6, 5, 6, 6, 5, 6, 6, 6, 8, 8, 6,
+ 7, 8, 5, 6, 6, 6, 8, 7, 6, 8, 8, 5, 6, 6, 6, 8,
+ 7, 6, 8, 8, 6, 8, 8, 8, 9, 9, 8, 9, 9, 6, 8, 7,
+ 7, 9, 8, 8, 9, 9, 5, 6, 6, 6, 8, 7, 6, 8, 8, 6,
+ 8, 8, 8, 9, 9, 7, 8, 9, 6, 8, 8, 8, 9, 9, 8, 9,
+ 9,
+};
+
+static const static_codebook _44u7__p2_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44u7__p2_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44u7__p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44u7__p3_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44u7__p3_0[] = {
+ 2, 5, 4, 8, 8, 5, 7, 6, 9, 9, 5, 6, 7, 9, 9, 8,
+ 9, 9,13,12, 8, 9,10,12,13, 5, 7, 7,10, 9, 7, 9,
+ 9,11,11, 6, 8, 9,11,11,10,11,11,14,14, 9,10,11,
+ 13,14, 5, 7, 7, 9, 9, 7, 9, 8,11,11, 7, 9, 9,11,
+ 11, 9,11,10,14,13,10,11,11,14,14, 8,10,10,14,13,
+ 10,11,12,15,14, 9,11,11,15,14,13,14,14,16,16,12,
+ 13,14,17,16, 8,10,10,13,13, 9,11,11,14,15,10,11,
+ 12,14,15,12,14,13,16,16,13,14,15,15,17, 5, 7, 7,
+ 10,10, 7, 9, 9,11,11, 7, 9, 9,11,11,10,12,11,15,
+ 14,10,11,12,14,14, 7, 9, 9,12,12, 9,11,11,13,13,
+ 9,11,11,13,13,11,13,13,14,17,11,13,13,15,16, 6,
+ 9, 9,11,11, 8,11,10,13,12, 9,11,11,13,13,11,13,
+ 12,16,14,11,13,13,16,16,10,12,12,15,15,11,13,13,
+ 16,16,11,13,13,16,15,14,16,17,17,19,14,16,16,18,
+ 0, 9,11,11,14,15,10,13,12,16,15,11,13,13,16,16,
+ 14,15,14, 0,16,14,16,16,18, 0, 5, 7, 7,10,10, 7,
+ 9, 9,12,11, 7, 9, 9,11,12,10,11,11,15,14,10,11,
+ 12,14,14, 6, 9, 9,11,11, 9,11,11,13,13, 8,10,11,
+ 12,13,11,13,13,17,15,11,12,13,14,15, 7, 9, 9,11,
+ 12, 9,11,11,13,13, 9,11,11,13,13,11,13,12,16,16,
+ 11,13,13,15,14, 9,11,11,14,15,11,13,13,16,15,10,
+ 12,13,16,16,15,16,16, 0, 0,14,13,15,16,18,10,11,
+ 11,15,15,11,13,14,16,18,11,13,13,16,15,15,16,16,
+ 19, 0,14,15,15,16,16, 8,10,10,13,13,10,12,11,16,
+ 15,10,11,11,16,15,13,15,16,18, 0,13,14,15,17,17,
+ 9,11,11,15,15,11,13,13,16,18,11,13,13,16,17,15,
+ 16,16, 0, 0,15,18,16, 0,17, 9,11,11,15,15,11,13,
+ 12,17,15,11,13,14,16,17,15,18,15, 0,17,15,16,16,
+ 18,19,13,15,14, 0,18,14,16,16,19,18,14,16,15,19,
+ 19,16,18,19, 0, 0,16,17, 0, 0, 0,12,14,14,17,17,
+ 13,16,14, 0,18,14,16,15,18, 0,16,18,16,19,17,18,
+ 19,17, 0, 0, 8,10,10,14,14, 9,12,11,15,15,10,11,
+ 12,15,17,13,15,15,18,16,14,16,15,18,17, 9,11,11,
+ 16,15,11,13,13, 0,16,11,12,13,16,15,15,16,16, 0,
+ 17,15,15,16,18,17, 9,12,11,15,17,11,13,13,16,16,
+ 11,14,13,16,16,15,15,16,18,19,16,18,16, 0, 0,12,
+ 14,14, 0,16,14,16,16, 0,18,13,14,15,16, 0,17,16,
+ 18, 0, 0,16,16,17,19, 0,13,14,14,17, 0,14,17,16,
+ 0,19,14,15,15,18,19,17,16,18, 0, 0,15,19,16, 0,
+ 0,
+};
+
+static const static_codebook _44u7__p3_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44u7__p3_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44u7__p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44u7__p4_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44u7__p4_0[] = {
+ 4, 5, 5, 8, 8, 6, 7, 6, 9, 9, 6, 6, 7, 9, 9, 8,
+ 9, 9,11,11, 8, 9, 9,10,11, 6, 7, 7, 9, 9, 7, 8,
+ 8,10,10, 6, 7, 8, 9,10, 9,10,10,12,12, 9, 9,10,
+ 11,12, 6, 7, 7, 9, 9, 6, 8, 7,10, 9, 7, 8, 8,10,
+ 10, 9,10, 9,12,11, 9,10,10,12,11, 8, 9, 9,11,11,
+ 9,10,10,12,12, 9,10,10,12,12,11,12,12,13,14,11,
+ 11,12,13,13, 8, 9, 9,11,11, 9,10,10,12,11, 9,10,
+ 10,12,12,11,12,11,13,13,11,12,12,13,13, 6, 7, 7,
+ 9, 9, 7, 8, 7,10,10, 7, 7, 8,10,10, 9,10,10,12,
+ 11, 9,10,10,12,12, 7, 8, 8,10,10, 8, 8, 9,11,11,
+ 8, 9, 9,11,11,10,11,11,12,12,10,10,11,12,13, 6,
+ 7, 7,10,10, 7, 9, 8,11,10, 8, 8, 9,10,11,10,11,
+ 10,13,11,10,11,11,12,12, 9,10,10,12,12,10,10,11,
+ 13,13,10,11,11,13,12,12,12,13,13,14,12,12,13,14,
+ 14, 9,10,10,12,12, 9,10,10,12,12,10,11,11,13,13,
+ 11,12,11,14,12,12,13,13,14,14, 6, 7, 7, 9, 9, 7,
+ 8, 7,10,10, 7, 7, 8,10,10, 9,10,10,12,11, 9,10,
+ 10,11,12, 6, 7, 7,10,10, 8, 9, 8,11,10, 7, 8, 9,
+ 10,11,10,11,11,13,12,10,10,11,11,13, 7, 8, 8,10,
+ 10, 8, 9, 9,11,11, 8, 9, 9,11,11,10,11,10,13,12,
+ 10,11,11,12,12, 9,10,10,12,12,10,11,11,13,12, 9,
+ 10,10,12,13,12,13,12,14,14,11,11,12,12,14, 9,10,
+ 10,12,12,10,11,11,13,13,10,11,11,13,13,12,13,12,
+ 14,14,12,13,12,14,13, 8, 9, 9,11,11, 9,10,10,12,
+ 12, 9,10,10,12,12,11,12,12,14,13,11,12,12,13,13,
+ 9,10,10,12,12,10,11,11,13,13,10,11,11,13,12,12,
+ 13,13,14,14,12,12,13,14,14, 9,10,10,12,12, 9,11,
+ 10,13,12,10,10,11,12,13,11,13,12,14,13,12,12,13,
+ 14,14,11,12,12,13,13,11,12,13,14,14,12,13,13,14,
+ 14,13,13,14,14,16,13,14,14,16,16,11,11,11,13,13,
+ 11,12,11,14,13,12,12,13,14,15,13,14,12,16,13,14,
+ 14,14,15,16, 8, 9, 9,11,11, 9,10,10,12,12, 9,10,
+ 10,12,12,11,12,12,14,13,11,12,12,13,14, 9,10,10,
+ 12,12,10,11,10,13,12, 9,10,11,12,13,12,13,12,14,
+ 14,12,12,13,13,14, 9,10,10,12,12,10,11,11,12,13,
+ 10,11,11,13,13,12,13,12,14,14,12,13,13,14,14,11,
+ 12,12,13,13,12,13,12,14,14,11,11,12,13,14,13,15,
+ 14,16,15,13,12,14,13,16,11,12,12,13,13,12,13,13,
+ 14,14,12,12,12,14,14,13,14,14,15,15,13,14,13,16,
+ 14,
+};
+
+static const static_codebook _44u7__p4_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44u7__p4_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44u7__p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44u7__p5_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44u7__p5_0[] = {
+ 2, 3, 3, 6, 6, 7, 8,10,10, 4, 5, 5, 8, 7, 8, 8,
+ 11,11, 3, 5, 5, 7, 7, 8, 9,11,11, 6, 8, 7, 9, 9,
+ 10,10,12,12, 6, 7, 8, 9,10,10,10,12,12, 8, 8, 8,
+ 10,10,12,11,13,13, 8, 8, 9,10,10,11,11,13,13,10,
+ 11,11,12,12,13,13,14,14,10,11,11,12,12,13,13,14,
+ 14,
+};
+
+static const static_codebook _44u7__p5_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44u7__p5_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44u7__p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44u7__p6_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44u7__p6_0[] = {
+ 3, 4, 4, 5, 5, 7, 7, 9, 9, 4, 5, 4, 6, 6, 8, 7,
+ 9, 9, 4, 4, 5, 6, 6, 7, 7, 9, 9, 5, 6, 6, 7, 7,
+ 8, 8,10,10, 5, 6, 6, 7, 7, 8, 8,10,10, 7, 8, 7,
+ 8, 8,10, 9,11,11, 7, 7, 8, 8, 8, 9,10,11,11, 9,
+ 9, 9,10,10,11,10,12,11, 9, 9, 9,10,10,11,11,11,
+ 12,
+};
+
+static const static_codebook _44u7__p6_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44u7__p6_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44u7__p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44u7__p7_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44u7__p7_0[] = {
+ 1, 4, 4, 5, 7, 7, 5, 7, 7, 5, 9, 8, 8, 9, 9, 7,
+ 10,10, 5, 8, 9, 7, 9,10, 8, 9, 9, 4, 9, 9, 9,11,
+ 10, 8,10,10, 7,11,10,10,10,12,10,12,12, 7,10,10,
+ 10,12,11,10,12,12, 5, 9, 9, 8,10,10, 9,11,11, 7,
+ 11,10,10,12,12,10,11,12, 7,10,11,10,12,12,10,12,
+ 10,
+};
+
+static const static_codebook _44u7__p7_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44u7__p7_0,
+ 1, -529137664, 1618345984, 2, 0,
+ (long *)_vq_quantlist__44u7__p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44u7__p7_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44u7__p7_1[] = {
+ 3, 4, 4, 6, 6, 7, 7, 8, 8, 8, 8, 4, 5, 5, 6, 6,
+ 8, 7, 8, 8, 8, 8, 4, 5, 5, 6, 6, 7, 8, 8, 8, 8,
+ 8, 6, 7, 6, 7, 7, 8, 8, 9, 9, 9, 9, 6, 6, 7, 7,
+ 7, 8, 8, 9, 9, 9, 9, 7, 8, 7, 8, 8, 9, 9, 9, 9,
+ 9, 9, 7, 7, 8, 8, 8, 9, 9, 9, 9, 9, 9, 8, 8, 8,
+ 9, 9, 9, 9,10, 9, 9, 9, 8, 8, 8, 9, 9, 9, 9, 9,
+ 9, 9,10, 8, 8, 8, 9, 9, 9, 9,10, 9,10,10, 8, 8,
+ 8, 9, 9, 9, 9, 9,10,10,10,
+};
+
+static const static_codebook _44u7__p7_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44u7__p7_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44u7__p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44u7__p8_0[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44u7__p8_0[] = {
+ 1, 4, 4, 6, 6, 8, 8,10,10,11,11, 4, 6, 6, 7, 7,
+ 9, 9,11,10,12,12, 5, 6, 5, 7, 7, 9, 9,10,11,12,
+ 12, 6, 7, 7, 8, 8,10,10,11,11,13,13, 6, 7, 7, 8,
+ 8,10,10,11,12,13,13, 8, 9, 9,10,10,11,11,12,12,
+ 14,14, 8, 9, 9,10,10,11,11,12,12,14,14,10,10,10,
+ 11,11,13,12,14,14,15,15,10,10,10,12,12,13,13,14,
+ 14,15,15,11,12,12,13,13,14,14,15,14,16,15,11,12,
+ 12,13,13,14,14,15,15,15,16,
+};
+
+static const static_codebook _44u7__p8_0 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44u7__p8_0,
+ 1, -524582912, 1618345984, 4, 0,
+ (long *)_vq_quantlist__44u7__p8_0,
+ 0
+};
+
+static const long _vq_quantlist__44u7__p8_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44u7__p8_1[] = {
+ 4, 5, 5, 6, 6, 7, 7, 7, 7, 7, 7, 5, 6, 6, 7, 7,
+ 7, 7, 7, 7, 7, 7, 5, 6, 6, 6, 7, 7, 7, 7, 7, 7,
+ 7, 6, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 6, 7, 7, 7,
+ 7, 7, 7, 7, 7, 8, 8, 7, 7, 7, 7, 7, 8, 7, 8, 8,
+ 8, 8, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 7, 7, 7,
+ 7, 7, 8, 8, 8, 8, 8, 8, 7, 7, 7, 7, 7, 8, 8, 8,
+ 8, 8, 8, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 7, 7,
+ 7, 8, 8, 8, 8, 8, 8, 8, 8,
+};
+
+static const static_codebook _44u7__p8_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44u7__p8_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44u7__p8_1,
+ 0
+};
+
+static const long _vq_quantlist__44u7__p9_0[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44u7__p9_0[] = {
+ 1, 3, 3,10,10,10,10,10,10,10,10, 4,10,10,10,10,
+ 10,10,10,10,10,10, 4,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9,
+};
+
+static const static_codebook _44u7__p9_0 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44u7__p9_0,
+ 1, -512171520, 1630791680, 4, 0,
+ (long *)_vq_quantlist__44u7__p9_0,
+ 0
+};
+
+static const long _vq_quantlist__44u7__p9_1[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44u7__p9_1[] = {
+ 1, 4, 4, 6, 5, 8, 6, 9, 8,10, 9,11,10, 4, 6, 6,
+ 8, 8, 9, 9,11,10,11,11,11,11, 4, 6, 6, 8, 8,10,
+ 9,11,11,11,11,11,12, 6, 8, 8,10,10,11,11,12,12,
+ 13,12,13,13, 6, 8, 8,10,10,11,11,12,12,12,13,14,
+ 13, 8,10,10,11,11,12,13,14,14,14,14,15,15, 8,10,
+ 10,11,12,12,13,13,14,14,14,14,15, 9,11,11,13,13,
+ 14,14,15,14,16,15,17,15, 9,11,11,12,13,14,14,15,
+ 14,15,15,15,16,10,12,12,13,14,15,15,15,15,16,17,
+ 16,17,10,13,12,13,14,14,16,16,16,16,15,16,17,11,
+ 13,13,14,15,14,17,15,16,17,17,17,17,11,13,13,14,
+ 15,15,15,15,17,17,16,17,16,
+};
+
+static const static_codebook _44u7__p9_1 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44u7__p9_1,
+ 1, -518889472, 1622704128, 4, 0,
+ (long *)_vq_quantlist__44u7__p9_1,
+ 0
+};
+
+static const long _vq_quantlist__44u7__p9_2[] = {
+ 24,
+ 23,
+ 25,
+ 22,
+ 26,
+ 21,
+ 27,
+ 20,
+ 28,
+ 19,
+ 29,
+ 18,
+ 30,
+ 17,
+ 31,
+ 16,
+ 32,
+ 15,
+ 33,
+ 14,
+ 34,
+ 13,
+ 35,
+ 12,
+ 36,
+ 11,
+ 37,
+ 10,
+ 38,
+ 9,
+ 39,
+ 8,
+ 40,
+ 7,
+ 41,
+ 6,
+ 42,
+ 5,
+ 43,
+ 4,
+ 44,
+ 3,
+ 45,
+ 2,
+ 46,
+ 1,
+ 47,
+ 0,
+ 48,
+};
+
+static const long _vq_lengthlist__44u7__p9_2[] = {
+ 2, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8,
+ 8,
+};
+
+static const static_codebook _44u7__p9_2 = {
+ 1, 49,
+ (long *)_vq_lengthlist__44u7__p9_2,
+ 1, -526909440, 1611661312, 6, 0,
+ (long *)_vq_quantlist__44u7__p9_2,
+ 0
+};
+
+static const long _huff_lengthlist__44u7__short[] = {
+ 5,12,17,16,16,17,17,17,17,17, 4, 7,11,11,12, 9,
+ 17,10,17,17, 7, 7, 8, 9, 7, 9,11,10,15,17, 7, 9,
+ 10,11,10,12,14,12,16,17, 7, 8, 5, 7, 4, 7, 7, 8,
+ 16,16, 6,10, 9,10, 7,10,11,11,16,17, 6, 8, 8, 9,
+ 5, 7, 5, 8,16,17, 5, 5, 8, 7, 6, 7, 7, 6, 6,14,
+ 12,10,12,11, 7,11, 4, 4, 2, 7,17,15,15,15, 8,15,
+ 6, 8, 5, 9,
+};
+
+static const static_codebook _huff_book__44u7__short = {
+ 2, 100,
+ (long *)_huff_lengthlist__44u7__short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44u8__long[] = {
+ 3, 9,13,14,14,15,14,14,15,15, 5, 4, 6, 8,10,12,
+ 12,14,15,15, 9, 5, 4, 5, 8,10,11,13,16,16,10, 7,
+ 4, 3, 5, 7, 9,11,13,13,10, 9, 7, 4, 4, 6, 8,10,
+ 12,14,13,11, 9, 6, 5, 5, 6, 8,12,14,13,11,10, 8,
+ 7, 6, 6, 7,10,14,13,11,12,10, 8, 7, 6, 6, 9,13,
+ 12,11,14,12,11, 9, 8, 7, 9,11,11,12,14,13,14,11,
+ 10, 8, 8, 9,
+};
+
+static const static_codebook _huff_book__44u8__long = {
+ 2, 100,
+ (long *)_huff_lengthlist__44u8__long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44u8__short[] = {
+ 6,14,18,18,17,17,17,17,17,17, 4, 7, 9, 9,10,13,
+ 15,17,17,17, 6, 7, 5, 6, 8,11,16,17,16,17, 5, 7,
+ 5, 4, 6,10,14,17,17,17, 6, 6, 6, 5, 7,10,13,16,
+ 17,17, 7, 6, 7, 7, 7, 8, 7,10,15,16,12, 9, 9, 6,
+ 6, 5, 3, 5,11,15,14,14,13, 5, 5, 7, 3, 4, 8,15,
+ 17,17,13, 7, 7,10, 6, 6,10,15,17,17,16,10,11,14,
+ 10,10,15,17,
+};
+
+static const static_codebook _huff_book__44u8__short = {
+ 2, 100,
+ (long *)_huff_lengthlist__44u8__short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44u8_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44u8_p1_0[] = {
+ 1, 5, 5, 5, 7, 7, 5, 7, 7, 5, 7, 7, 8, 9, 9, 7,
+ 9, 9, 5, 7, 7, 7, 9, 9, 8, 9, 9, 5, 7, 7, 7, 9,
+ 9, 7, 9, 9, 7, 9, 9, 9,10,11, 9,11,10, 7, 9, 9,
+ 9,11,10, 9,10,11, 5, 7, 7, 7, 9, 9, 7, 9, 9, 7,
+ 9, 9, 9,11,10, 9,10,10, 8, 9, 9, 9,11,11, 9,11,
+ 10,
+};
+
+static const static_codebook _44u8_p1_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44u8_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44u8_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44u8_p2_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44u8_p2_0[] = {
+ 4, 5, 5, 8, 8, 5, 7, 6, 9, 9, 5, 6, 7, 9, 9, 8,
+ 9, 9,11,11, 8, 9, 9,11,11, 5, 7, 7, 9, 9, 7, 8,
+ 8,10,10, 7, 8, 8,10,10, 9,10,10,12,12, 9,10,10,
+ 11,12, 5, 7, 7, 9, 9, 7, 8, 7,10,10, 7, 8, 8,10,
+ 10, 9,10, 9,12,11, 9,10,10,12,12, 8, 9, 9,12,11,
+ 9,10,10,12,12, 9,10,10,12,12,11,12,12,14,14,11,
+ 11,12,13,14, 8, 9, 9,11,11, 9,10,10,12,12, 9,10,
+ 10,12,12,11,12,11,13,13,11,12,12,14,14, 5, 7, 7,
+ 9, 9, 7, 8, 8,10,10, 7, 8, 8,10,10, 9,10,10,12,
+ 12, 9,10,10,11,12, 7, 8, 8,10,10, 8, 9, 9,11,11,
+ 8, 9, 9,11,11,10,11,11,12,13,10,11,11,12,13, 6,
+ 8, 8,10,10, 8, 9, 8,11,10, 8, 9, 9,11,11,10,11,
+ 10,13,12,10,11,11,13,13, 9,10,10,12,12,10,11,11,
+ 13,13,10,11,11,13,13,12,12,13,13,14,12,13,13,14,
+ 14, 9,10,10,12,12,10,11,10,13,12,10,11,11,13,13,
+ 11,13,12,14,13,12,13,13,14,14, 5, 7, 7, 9, 9, 7,
+ 8, 8,10,10, 7, 8, 8,10,10, 9,10,10,12,12, 9,10,
+ 10,12,12, 7, 8, 8,10,10, 8, 9, 9,11,11, 8, 8, 9,
+ 10,11,10,11,11,13,13,10,10,11,12,13, 7, 8, 8,10,
+ 10, 8, 9, 9,11,11, 8, 9, 9,11,11,10,11,11,13,13,
+ 10,11,11,13,12, 9,10,10,12,12,10,11,11,13,13,10,
+ 10,11,12,13,12,13,13,14,14,12,12,13,13,14, 9,10,
+ 10,12,12,10,11,11,13,13,10,11,11,13,13,12,13,13,
+ 15,14,12,13,13,14,13, 8, 9, 9,11,11, 9,10,10,12,
+ 12, 9,10,10,12,12,12,12,12,14,13,11,12,12,14,14,
+ 9,10,10,12,12,10,11,11,13,13,10,11,11,13,13,12,
+ 13,13,14,15,12,13,13,14,15, 9,10,10,12,12,10,11,
+ 10,13,12,10,11,11,13,13,12,13,12,15,14,12,13,13,
+ 14,15,11,12,12,14,14,12,13,13,14,14,12,13,13,15,
+ 14,14,14,14,14,16,14,14,15,16,16,11,12,12,14,14,
+ 11,12,12,14,14,12,13,13,14,15,13,14,13,16,14,14,
+ 14,14,16,16, 8, 9, 9,11,11, 9,10,10,12,12, 9,10,
+ 10,12,12,11,12,12,14,13,11,12,12,14,14, 9,10,10,
+ 12,12,10,11,11,13,13,10,10,11,12,13,12,13,13,15,
+ 14,12,12,13,13,14, 9,10,10,12,12,10,11,11,13,13,
+ 10,11,11,13,13,12,13,13,14,14,12,13,13,15,14,11,
+ 12,12,14,13,12,13,13,15,14,11,12,12,13,14,14,15,
+ 14,16,15,13,13,14,13,16,11,12,12,14,14,12,13,13,
+ 14,15,12,13,12,15,14,14,14,14,16,15,14,15,13,16,
+ 14,
+};
+
+static const static_codebook _44u8_p2_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44u8_p2_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44u8_p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44u8_p3_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44u8_p3_0[] = {
+ 3, 4, 4, 5, 5, 7, 7, 9, 9, 4, 5, 4, 6, 6, 7, 7,
+ 9, 9, 4, 4, 5, 6, 6, 7, 7, 9, 9, 5, 6, 6, 7, 7,
+ 8, 8,10,10, 6, 6, 6, 7, 7, 8, 8,10,10, 7, 7, 7,
+ 8, 8, 9, 9,11,10, 7, 7, 7, 8, 8, 9, 9,10,11, 9,
+ 9, 9,10,10,11,10,12,11, 9, 9, 9, 9,10,11,11,11,
+ 12,
+};
+
+static const static_codebook _44u8_p3_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44u8_p3_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44u8_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44u8_p4_0[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44u8_p4_0[] = {
+ 4, 4, 4, 6, 6, 7, 7, 8, 8, 8, 8,10,10,11,11,11,
+ 11, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9,10,10,11,11,
+ 12,12, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9,10,10,11,
+ 11,12,12, 6, 6, 6, 7, 7, 8, 8, 9, 9, 9, 9,10,10,
+ 11,11,12,12, 6, 6, 6, 7, 7, 8, 8, 9, 9, 9, 9,10,
+ 10,11,11,12,12, 7, 7, 7, 8, 8, 9, 8,10, 9,10, 9,
+ 11,10,12,11,13,12, 7, 7, 7, 8, 8, 8, 9, 9,10, 9,
+ 10,10,11,11,12,12,13, 8, 8, 8, 9, 9, 9, 9,10,10,
+ 11,10,11,11,12,12,13,13, 8, 8, 8, 9, 9, 9,10,10,
+ 10,10,11,11,11,12,12,12,13, 8, 9, 9, 9, 9,10, 9,
+ 11,10,11,11,12,11,13,12,13,13, 8, 9, 9, 9, 9, 9,
+ 10,10,11,11,11,11,12,12,13,13,13,10,10,10,10,10,
+ 11,10,11,11,12,11,13,12,13,13,14,13,10,10,10,10,
+ 10,10,11,11,11,11,12,12,13,13,13,13,14,11,11,11,
+ 11,11,12,11,12,12,13,12,13,13,14,13,14,14,11,11,
+ 11,11,11,11,12,12,12,12,13,13,13,13,14,14,14,11,
+ 12,12,12,12,13,12,13,12,13,13,14,13,14,14,14,14,
+ 11,12,12,12,12,12,12,13,13,13,13,13,14,14,14,14,
+ 14,
+};
+
+static const static_codebook _44u8_p4_0 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44u8_p4_0,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44u8_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44u8_p5_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44u8_p5_0[] = {
+ 1, 4, 4, 5, 7, 7, 5, 7, 7, 5, 8, 8, 8, 9, 9, 7,
+ 9, 9, 5, 8, 8, 7, 9, 9, 8, 9, 9, 5, 8, 8, 8,10,
+ 10, 8,10,10, 7,10,10, 9,10,12, 9,12,11, 7,10,10,
+ 9,11,10, 9,11,12, 5, 8, 8, 8,10,10, 8,10,10, 7,
+ 10,10, 9,11,11, 9,10,11, 7,10,10, 9,11,11,10,12,
+ 10,
+};
+
+static const static_codebook _44u8_p5_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44u8_p5_0,
+ 1, -529137664, 1618345984, 2, 0,
+ (long *)_vq_quantlist__44u8_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44u8_p5_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44u8_p5_1[] = {
+ 4, 5, 5, 6, 6, 7, 7, 7, 7, 8, 8, 5, 5, 5, 6, 6,
+ 7, 7, 8, 8, 8, 8, 5, 5, 5, 6, 6, 7, 7, 7, 8, 8,
+ 8, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 6, 6, 6, 7,
+ 7, 7, 7, 8, 8, 8, 8, 7, 7, 7, 7, 7, 8, 8, 8, 8,
+ 8, 8, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 7, 8, 7,
+ 8, 8, 8, 8, 8, 8, 8, 8, 7, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 9, 9,
+};
+
+static const static_codebook _44u8_p5_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44u8_p5_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44u8_p5_1,
+ 0
+};
+
+static const long _vq_quantlist__44u8_p6_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44u8_p6_0[] = {
+ 2, 4, 4, 6, 6, 7, 7, 8, 8, 9, 9,10,10, 4, 6, 5,
+ 7, 7, 8, 8, 8, 8, 9, 9,10,10, 4, 6, 6, 7, 7, 8,
+ 8, 8, 8, 9, 9,10,10, 6, 7, 7, 7, 8, 8, 8, 8, 9,
+ 9,10,10,10, 6, 7, 7, 8, 8, 8, 8, 9, 8,10, 9,11,
+ 10, 7, 8, 8, 8, 8, 8, 9, 9, 9,10,10,11,11, 7, 8,
+ 8, 8, 8, 9, 8, 9, 9,10,10,11,11, 8, 8, 8, 9, 9,
+ 9, 9, 9,10,10,10,11,11, 8, 8, 8, 9, 9, 9, 9,10,
+ 9,10,10,11,11, 9, 9, 9, 9,10,10,10,10,10,10,11,
+ 11,12, 9, 9, 9,10, 9,10,10,10,10,11,10,12,11,10,
+ 10,10,10,10,11,11,11,11,11,12,12,12,10,10,10,10,
+ 11,11,11,11,11,12,11,12,12,
+};
+
+static const static_codebook _44u8_p6_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44u8_p6_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44u8_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44u8_p6_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44u8_p6_1[] = {
+ 3, 4, 4, 5, 5, 4, 5, 5, 5, 5, 4, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5,
+};
+
+static const static_codebook _44u8_p6_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44u8_p6_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44u8_p6_1,
+ 0
+};
+
+static const long _vq_quantlist__44u8_p7_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44u8_p7_0[] = {
+ 1, 4, 5, 6, 6, 7, 7, 8, 8,10,10,11,11, 5, 6, 6,
+ 7, 7, 8, 8, 9, 9,11,10,12,11, 5, 6, 6, 7, 7, 8,
+ 8, 9, 9,10,11,11,12, 6, 7, 7, 8, 8, 9, 9,10,10,
+ 11,11,12,12, 6, 7, 7, 8, 8, 9, 9,10,10,11,12,13,
+ 12, 7, 8, 8, 9, 9,10,10,11,11,12,12,13,13, 8, 8,
+ 8, 9, 9,10,10,11,11,12,12,13,13, 9, 9, 9,10,10,
+ 11,11,12,12,13,13,14,14, 9, 9, 9,10,10,11,11,12,
+ 12,13,13,14,14,10,11,11,12,11,13,12,13,13,14,14,
+ 15,15,10,11,11,11,12,12,13,13,14,14,14,15,15,11,
+ 12,12,13,13,14,13,15,14,15,15,16,15,11,11,12,13,
+ 13,13,14,14,14,15,15,15,16,
+};
+
+static const static_codebook _44u8_p7_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44u8_p7_0,
+ 1, -523206656, 1618345984, 4, 0,
+ (long *)_vq_quantlist__44u8_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44u8_p7_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44u8_p7_1[] = {
+ 4, 5, 5, 6, 6, 7, 7, 7, 7, 7, 7, 5, 6, 6, 7, 7,
+ 7, 7, 7, 7, 7, 7, 5, 6, 6, 7, 7, 7, 7, 7, 7, 7,
+ 7, 6, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 6, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 8, 7, 7, 7, 7, 7, 7, 7, 8, 8,
+ 8, 8, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 7, 7, 7,
+ 8, 7, 8, 8, 8, 8, 8, 8, 7, 7, 7, 7, 7, 8, 8, 8,
+ 8, 8, 8, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 7, 7,
+ 7, 8, 8, 8, 8, 8, 8, 8, 8,
+};
+
+static const static_codebook _44u8_p7_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44u8_p7_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44u8_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44u8_p8_0[] = {
+ 7,
+ 6,
+ 8,
+ 5,
+ 9,
+ 4,
+ 10,
+ 3,
+ 11,
+ 2,
+ 12,
+ 1,
+ 13,
+ 0,
+ 14,
+};
+
+static const long _vq_lengthlist__44u8_p8_0[] = {
+ 1, 4, 4, 7, 7, 8, 8, 8, 7, 9, 8,10, 9,11,10, 4,
+ 6, 6, 8, 8,10, 9, 9, 9,10,10,11,10,12,10, 4, 6,
+ 6, 8, 8,10,10, 9, 9,10,10,11,11,11,12, 7, 8, 8,
+ 10,10,11,11,11,10,12,11,12,12,13,11, 7, 8, 8,10,
+ 10,11,11,10,10,11,11,12,12,13,13, 8,10,10,11,11,
+ 12,11,12,11,13,12,13,12,14,13, 8,10, 9,11,11,12,
+ 12,12,12,12,12,13,13,14,13, 8, 9, 9,11,10,12,11,
+ 13,12,13,13,14,13,14,13, 8, 9, 9,10,11,12,12,12,
+ 12,13,13,14,15,14,14, 9,10,10,12,11,13,12,13,13,
+ 14,13,14,14,14,14, 9,10,10,12,12,12,12,13,13,14,
+ 14,14,15,14,14,10,11,11,13,12,13,12,14,14,14,14,
+ 14,14,15,15,10,11,11,12,12,13,13,14,14,14,15,15,
+ 14,16,15,11,12,12,13,12,14,14,14,13,15,14,15,15,
+ 15,17,11,12,12,13,13,14,14,14,15,15,14,15,15,14,
+ 17,
+};
+
+static const static_codebook _44u8_p8_0 = {
+ 2, 225,
+ (long *)_vq_lengthlist__44u8_p8_0,
+ 1, -520986624, 1620377600, 4, 0,
+ (long *)_vq_quantlist__44u8_p8_0,
+ 0
+};
+
+static const long _vq_quantlist__44u8_p8_1[] = {
+ 10,
+ 9,
+ 11,
+ 8,
+ 12,
+ 7,
+ 13,
+ 6,
+ 14,
+ 5,
+ 15,
+ 4,
+ 16,
+ 3,
+ 17,
+ 2,
+ 18,
+ 1,
+ 19,
+ 0,
+ 20,
+};
+
+static const long _vq_lengthlist__44u8_p8_1[] = {
+ 4, 6, 6, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 6, 6, 6, 7, 7, 8, 8, 8, 8, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 5, 6, 6, 7, 7, 8,
+ 8, 9, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 7,
+ 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 8, 8, 8, 8, 8, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,10,10, 9,10, 8, 8,
+ 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,10, 9,10,
+ 10, 9,10, 8, 9, 8, 9, 9, 9, 9, 9, 9, 9, 9,10, 9,
+ 10,10,10,10,10,10,10,10, 8, 9, 8, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9,10,10,10,10, 9,10,10, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9,10, 9,10,10,10,10,10,10,
+ 10,10, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,10, 9,10,
+ 10,10,10,10,10,10,10, 9, 9, 9, 9, 9, 9, 9,10, 9,
+ 10,10,10,10,10,10,10,10,10,10,10,10, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9,10,10,10,10,10,10,10,10,10,10,
+ 10, 9, 9, 9, 9, 9, 9,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10, 9, 9, 9, 9, 9, 9, 9,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10, 9, 9, 9, 9, 9,
+ 9, 9,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 9, 9, 9, 9, 9,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10, 9, 9, 9,10, 9,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10, 9, 9, 9, 9, 9,10,
+ 9,10,10,10,10,10,10,10,10,10,10,10,10,10,10, 9,
+ 9, 9, 9, 9, 9,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10, 9, 9, 9,10, 9,10, 9,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,
+};
+
+static const static_codebook _44u8_p8_1 = {
+ 2, 441,
+ (long *)_vq_lengthlist__44u8_p8_1,
+ 1, -529268736, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44u8_p8_1,
+ 0
+};
+
+static const long _vq_quantlist__44u8_p9_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44u8_p9_0[] = {
+ 1, 3, 3, 9, 9, 9, 9, 9, 9, 4, 9, 9, 9, 9, 9, 9,
+ 9, 9, 5, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 8, 8, 8,
+ 8,
+};
+
+static const static_codebook _44u8_p9_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44u8_p9_0,
+ 1, -511895552, 1631393792, 4, 0,
+ (long *)_vq_quantlist__44u8_p9_0,
+ 0
+};
+
+static const long _vq_quantlist__44u8_p9_1[] = {
+ 9,
+ 8,
+ 10,
+ 7,
+ 11,
+ 6,
+ 12,
+ 5,
+ 13,
+ 4,
+ 14,
+ 3,
+ 15,
+ 2,
+ 16,
+ 1,
+ 17,
+ 0,
+ 18,
+};
+
+static const long _vq_lengthlist__44u8_p9_1[] = {
+ 1, 4, 4, 7, 7, 8, 7, 8, 6, 9, 7,10, 8,11,10,11,
+ 11,11,11, 4, 7, 6, 9, 9,10, 9, 9, 9,10,10,11,10,
+ 11,10,11,11,13,11, 4, 7, 7, 9, 9, 9, 9, 9, 9,10,
+ 10,11,10,11,11,11,12,11,12, 7, 9, 8,11,11,11,11,
+ 10,10,11,11,12,12,12,12,12,12,14,13, 7, 8, 9,10,
+ 11,11,11,10,10,11,11,11,11,12,12,14,12,13,14, 8,
+ 9, 9,11,11,11,11,11,11,12,12,14,12,15,14,14,14,
+ 15,14, 8, 9, 9,11,11,11,11,12,11,12,12,13,13,13,
+ 13,13,13,14,14, 8, 9, 9,11,10,12,11,12,12,13,13,
+ 13,13,15,14,14,14,16,16, 8, 9, 9,10,11,11,12,12,
+ 12,13,13,13,14,14,14,15,16,15,15, 9,10,10,11,12,
+ 12,13,13,13,14,14,16,14,14,16,16,16,16,15, 9,10,
+ 10,11,11,12,13,13,14,15,14,16,14,15,16,16,16,16,
+ 15,10,11,11,12,13,13,14,15,15,15,15,15,16,15,16,
+ 15,16,15,15,10,11,11,13,13,14,13,13,15,14,15,15,
+ 16,15,15,15,16,15,16,10,12,12,14,14,14,14,14,16,
+ 16,15,15,15,16,16,16,16,16,16,11,12,12,14,14,14,
+ 14,15,15,16,15,16,15,16,15,16,16,16,16,12,12,13,
+ 14,14,15,16,16,16,16,16,16,15,16,16,16,16,16,16,
+ 12,13,13,14,14,14,14,15,16,15,16,16,16,16,16,16,
+ 16,16,16,12,13,14,14,14,16,15,16,15,16,16,16,16,
+ 16,16,16,16,16,16,12,14,13,14,15,15,15,16,15,16,
+ 16,15,16,16,16,16,16,16,16,
+};
+
+static const static_codebook _44u8_p9_1 = {
+ 2, 361,
+ (long *)_vq_lengthlist__44u8_p9_1,
+ 1, -518287360, 1622704128, 5, 0,
+ (long *)_vq_quantlist__44u8_p9_1,
+ 0
+};
+
+static const long _vq_quantlist__44u8_p9_2[] = {
+ 24,
+ 23,
+ 25,
+ 22,
+ 26,
+ 21,
+ 27,
+ 20,
+ 28,
+ 19,
+ 29,
+ 18,
+ 30,
+ 17,
+ 31,
+ 16,
+ 32,
+ 15,
+ 33,
+ 14,
+ 34,
+ 13,
+ 35,
+ 12,
+ 36,
+ 11,
+ 37,
+ 10,
+ 38,
+ 9,
+ 39,
+ 8,
+ 40,
+ 7,
+ 41,
+ 6,
+ 42,
+ 5,
+ 43,
+ 4,
+ 44,
+ 3,
+ 45,
+ 2,
+ 46,
+ 1,
+ 47,
+ 0,
+ 48,
+};
+
+static const long _vq_lengthlist__44u8_p9_2[] = {
+ 2, 3, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7,
+};
+
+static const static_codebook _44u8_p9_2 = {
+ 1, 49,
+ (long *)_vq_lengthlist__44u8_p9_2,
+ 1, -526909440, 1611661312, 6, 0,
+ (long *)_vq_quantlist__44u8_p9_2,
+ 0
+};
+
+static const long _huff_lengthlist__44u9__long[] = {
+ 3, 9,13,13,14,15,14,14,15,15, 5, 5, 9,10,12,12,
+ 13,14,16,15,10, 6, 6, 6, 8,11,12,13,16,15,11, 7,
+ 5, 3, 5, 8,10,12,15,15,10,10, 7, 4, 3, 5, 8,10,
+ 12,12,12,12, 9, 7, 5, 4, 6, 8,10,13,13,12,11, 9,
+ 7, 5, 5, 6, 9,12,14,12,12,10, 8, 6, 6, 6, 7,11,
+ 13,12,14,13,10, 8, 7, 7, 7,10,11,11,12,13,12,11,
+ 10, 8, 8, 9,
+};
+
+static const static_codebook _huff_book__44u9__long = {
+ 2, 100,
+ (long *)_huff_lengthlist__44u9__long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _huff_lengthlist__44u9__short[] = {
+ 9,16,18,18,17,17,17,17,17,17, 5, 8,11,12,11,12,
+ 17,17,16,16, 6, 6, 8, 8, 9,10,14,15,16,16, 6, 7,
+ 7, 4, 6, 9,13,16,16,16, 6, 6, 7, 4, 5, 8,11,15,
+ 17,16, 7, 6, 7, 6, 6, 8, 9,10,14,16,11, 8, 8, 7,
+ 6, 6, 3, 4,10,15,14,12,12,10, 5, 6, 3, 3, 8,13,
+ 15,17,15,11, 6, 8, 6, 6, 9,14,17,15,15,12, 8,10,
+ 9, 9,12,15,
+};
+
+static const static_codebook _huff_book__44u9__short = {
+ 2, 100,
+ (long *)_huff_lengthlist__44u9__short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44u9_p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44u9_p1_0[] = {
+ 1, 5, 5, 5, 7, 7, 5, 7, 7, 5, 7, 7, 7, 9, 9, 7,
+ 9, 9, 5, 7, 7, 7, 9, 9, 7, 9, 9, 5, 7, 7, 7, 9,
+ 9, 7, 9, 9, 8, 9, 9, 9,10,11, 9,11,11, 7, 9, 9,
+ 9,11,10, 9,11,11, 5, 7, 7, 7, 9, 9, 8, 9,10, 7,
+ 9, 9, 9,11,11, 9,10,11, 7, 9,10, 9,11,11, 9,11,
+ 10,
+};
+
+static const static_codebook _44u9_p1_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44u9_p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44u9_p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44u9_p2_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44u9_p2_0[] = {
+ 3, 5, 5, 8, 8, 5, 7, 7, 9, 9, 6, 7, 7, 9, 9, 8,
+ 9, 9,11,10, 8, 9, 9,11,11, 6, 7, 7, 9, 9, 7, 8,
+ 8,10,10, 7, 8, 8, 9,10, 9,10,10,11,11, 9, 9,10,
+ 11,11, 6, 7, 7, 9, 9, 7, 8, 8,10, 9, 7, 8, 8,10,
+ 10, 9,10, 9,11,11, 9,10,10,11,11, 8, 9, 9,11,11,
+ 9,10,10,12,11, 9,10,10,11,12,11,11,11,13,13,11,
+ 11,11,12,13, 8, 9, 9,11,11, 9,10,10,11,11, 9,10,
+ 10,12,11,11,12,11,13,12,11,11,12,13,13, 6, 7, 7,
+ 9, 9, 7, 8, 8,10,10, 7, 8, 8,10,10, 9,10,10,12,
+ 11, 9,10,10,11,12, 7, 8, 8,10,10, 8, 9, 9,11,11,
+ 8, 9, 9,10,10,10,11,11,12,12,10,10,11,12,12, 7,
+ 8, 8,10,10, 8, 9, 8,10,10, 8, 9, 9,10,10,10,11,
+ 10,12,11,10,10,11,12,12, 9,10,10,11,12,10,11,11,
+ 12,12,10,11,10,12,12,12,12,12,13,13,11,12,12,13,
+ 13, 9,10,10,11,11, 9,10,10,12,12,10,11,11,12,13,
+ 11,12,11,13,12,12,12,12,13,14, 6, 7, 7, 9, 9, 7,
+ 8, 8,10,10, 7, 8, 8,10,10, 9,10,10,11,11, 9,10,
+ 10,11,12, 7, 8, 8,10,10, 8, 9, 9,11,10, 8, 8, 9,
+ 10,10,10,11,10,12,12,10,10,11,11,12, 7, 8, 8,10,
+ 10, 8, 9, 9,10,10, 8, 9, 9,10,10,10,11,10,12,12,
+ 10,11,10,12,12, 9,10,10,12,11,10,11,11,12,12, 9,
+ 10,10,12,12,12,12,12,13,13,11,11,12,12,14, 9,10,
+ 10,11,12,10,11,11,12,12,10,11,11,12,12,11,12,12,
+ 14,14,12,12,12,13,13, 8, 9, 9,11,11, 9,10,10,12,
+ 11, 9,10,10,12,12,11,12,11,13,13,11,11,12,13,13,
+ 9,10,10,12,12,10,11,11,12,12,10,11,11,12,12,12,
+ 12,12,14,14,12,12,12,13,13, 9,10,10,12,11,10,11,
+ 10,12,12,10,11,11,12,12,11,12,12,14,13,12,12,12,
+ 13,14,11,12,11,13,13,11,12,12,13,13,12,12,12,14,
+ 14,13,13,13,13,15,13,13,14,15,15,11,11,11,13,13,
+ 11,12,11,13,13,11,12,12,13,13,12,13,12,15,13,13,
+ 13,14,14,15, 8, 9, 9,11,11, 9,10,10,11,12, 9,10,
+ 10,11,12,11,12,11,13,13,11,12,12,13,13, 9,10,10,
+ 11,12,10,11,10,12,12,10,10,11,12,13,12,12,12,14,
+ 13,11,12,12,13,14, 9,10,10,12,12,10,11,11,12,12,
+ 10,11,11,12,12,12,12,12,14,13,12,12,12,14,13,11,
+ 11,11,13,13,11,12,12,14,13,11,11,12,13,13,13,13,
+ 13,15,14,12,12,13,13,15,11,12,12,13,13,12,12,12,
+ 13,14,11,12,12,13,13,13,13,14,14,15,13,13,13,14,
+ 14,
+};
+
+static const static_codebook _44u9_p2_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44u9_p2_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44u9_p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44u9_p3_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44u9_p3_0[] = {
+ 3, 4, 4, 5, 5, 7, 7, 8, 8, 4, 5, 5, 6, 6, 7, 7,
+ 9, 9, 4, 4, 5, 6, 6, 7, 7, 9, 9, 5, 6, 6, 7, 7,
+ 8, 8, 9, 9, 5, 6, 6, 7, 7, 8, 8, 9, 9, 7, 7, 7,
+ 8, 8, 9, 9,10,10, 7, 7, 7, 8, 8, 9, 9,10,10, 8,
+ 9, 9,10, 9,10,10,11,11, 8, 9, 9, 9,10,10,10,11,
+ 11,
+};
+
+static const static_codebook _44u9_p3_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44u9_p3_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44u9_p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44u9_p4_0[] = {
+ 8,
+ 7,
+ 9,
+ 6,
+ 10,
+ 5,
+ 11,
+ 4,
+ 12,
+ 3,
+ 13,
+ 2,
+ 14,
+ 1,
+ 15,
+ 0,
+ 16,
+};
+
+static const long _vq_lengthlist__44u9_p4_0[] = {
+ 4, 5, 5, 6, 6, 7, 7, 8, 8, 8, 8, 9, 9,10,10,11,
+ 11, 5, 5, 5, 6, 6, 7, 7, 8, 8, 8, 8, 9, 9,10,10,
+ 11,11, 5, 5, 5, 6, 6, 7, 7, 8, 8, 8, 8, 9, 9,10,
+ 10,11,11, 6, 6, 6, 7, 6, 7, 7, 8, 8, 9, 9,10,10,
+ 11,11,12,11, 6, 6, 6, 6, 7, 7, 7, 8, 8, 9, 9,10,
+ 10,11,11,11,12, 7, 7, 7, 7, 7, 8, 8, 9, 9, 9, 9,
+ 10,10,11,11,12,12, 7, 7, 7, 7, 7, 8, 8, 9, 9, 9,
+ 9,10,10,11,11,12,12, 8, 8, 8, 8, 8, 9, 8,10, 9,
+ 10,10,11,10,12,11,13,12, 8, 8, 8, 8, 8, 9, 9, 9,
+ 10,10,10,10,11,11,12,12,12, 8, 8, 8, 9, 9, 9, 9,
+ 10,10,11,10,12,11,12,12,13,12, 8, 8, 8, 9, 9, 9,
+ 9,10,10,10,11,11,11,12,12,12,13, 9, 9, 9,10,10,
+ 10,10,11,10,11,11,12,11,13,12,13,13, 9, 9,10,10,
+ 10,10,10,10,11,11,11,11,12,12,13,13,13,10,11,10,
+ 11,11,11,11,12,11,12,12,13,12,13,13,14,13,10,10,
+ 10,11,11,11,11,11,12,12,12,12,13,13,13,13,14,11,
+ 11,11,12,11,12,12,12,12,13,13,13,13,14,13,14,14,
+ 11,11,11,11,12,12,12,12,12,12,13,13,13,13,14,14,
+ 14,
+};
+
+static const static_codebook _44u9_p4_0 = {
+ 2, 289,
+ (long *)_vq_lengthlist__44u9_p4_0,
+ 1, -529530880, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44u9_p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44u9_p5_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44u9_p5_0[] = {
+ 1, 4, 4, 5, 7, 7, 5, 7, 7, 5, 8, 8, 8, 9, 9, 7,
+ 9, 9, 5, 8, 8, 7, 9, 9, 8, 9, 9, 5, 8, 8, 8,10,
+ 10, 8,10,10, 7,10,10, 9,10,12, 9,11,11, 7,10,10,
+ 9,11,10, 9,11,12, 5, 8, 8, 8,10,10, 8,10,10, 7,
+ 10,10, 9,12,11, 9,10,11, 7,10,10, 9,11,11,10,12,
+ 10,
+};
+
+static const static_codebook _44u9_p5_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44u9_p5_0,
+ 1, -529137664, 1618345984, 2, 0,
+ (long *)_vq_quantlist__44u9_p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44u9_p5_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44u9_p5_1[] = {
+ 5, 5, 5, 6, 6, 7, 7, 7, 7, 7, 7, 5, 6, 6, 6, 6,
+ 7, 7, 7, 7, 8, 7, 5, 6, 6, 6, 6, 7, 7, 7, 7, 7,
+ 7, 6, 6, 6, 7, 7, 7, 7, 7, 7, 8, 8, 6, 6, 6, 7,
+ 7, 7, 7, 7, 7, 8, 8, 7, 7, 7, 7, 7, 8, 7, 8, 8,
+ 8, 8, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 7, 7, 7,
+ 8, 7, 8, 8, 8, 8, 8, 8, 7, 7, 7, 7, 8, 8, 8, 8,
+ 8, 8, 8, 7, 8, 7, 8, 8, 8, 8, 8, 8, 8, 8, 7, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8,
+};
+
+static const static_codebook _44u9_p5_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44u9_p5_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44u9_p5_1,
+ 0
+};
+
+static const long _vq_quantlist__44u9_p6_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44u9_p6_0[] = {
+ 2, 4, 4, 6, 6, 7, 7, 8, 8, 9, 9,10,10, 4, 6, 5,
+ 7, 7, 8, 8, 8, 8, 9, 9,10,10, 4, 5, 6, 7, 7, 8,
+ 8, 8, 8, 9, 9,10,10, 6, 7, 7, 8, 8, 8, 8, 9, 9,
+ 10,10,10,10, 6, 7, 7, 8, 8, 8, 8, 9, 9,10,10,10,
+ 10, 7, 8, 8, 8, 8, 9, 9, 9, 9,10,10,11,11, 7, 8,
+ 8, 8, 8, 9, 9, 9, 9,10,10,11,11, 8, 8, 8, 9, 9,
+ 9, 9, 9,10,10,10,11,11, 8, 8, 8, 9, 9, 9, 9,10,
+ 9,10,10,11,11, 9, 9, 9,10,10,10,10,10,11,11,11,
+ 11,12, 9, 9, 9,10,10,10,10,10,10,11,10,12,11,10,
+ 10,10,10,10,11,11,11,11,11,12,12,12,10,10,10,10,
+ 10,11,11,11,11,12,11,12,12,
+};
+
+static const static_codebook _44u9_p6_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44u9_p6_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44u9_p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44u9_p6_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44u9_p6_1[] = {
+ 4, 4, 4, 5, 5, 4, 5, 4, 5, 5, 4, 4, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5,
+};
+
+static const static_codebook _44u9_p6_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44u9_p6_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44u9_p6_1,
+ 0
+};
+
+static const long _vq_quantlist__44u9_p7_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44u9_p7_0[] = {
+ 1, 4, 5, 6, 6, 7, 7, 8, 9,10,10,11,11, 5, 6, 6,
+ 7, 7, 8, 8, 9, 9,10,10,11,11, 5, 6, 6, 7, 7, 8,
+ 8, 9, 9,10,10,11,11, 6, 7, 7, 8, 8, 9, 9,10,10,
+ 11,11,12,12, 6, 7, 7, 8, 8, 9, 9,10,10,11,11,12,
+ 12, 8, 8, 8, 9, 9,10,10,11,11,12,12,13,13, 8, 8,
+ 8, 9, 9,10,10,11,11,12,12,13,13, 9, 9, 9,10,10,
+ 11,11,12,12,13,13,13,13, 9, 9, 9,10,10,11,11,12,
+ 12,13,13,14,14,10,10,10,11,11,12,12,13,13,14,13,
+ 15,14,10,10,10,11,11,12,12,13,13,14,14,14,14,11,
+ 11,12,12,12,13,13,14,14,14,14,15,15,11,11,12,12,
+ 12,13,13,14,14,14,15,15,15,
+};
+
+static const static_codebook _44u9_p7_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44u9_p7_0,
+ 1, -523206656, 1618345984, 4, 0,
+ (long *)_vq_quantlist__44u9_p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44u9_p7_1[] = {
+ 5,
+ 4,
+ 6,
+ 3,
+ 7,
+ 2,
+ 8,
+ 1,
+ 9,
+ 0,
+ 10,
+};
+
+static const long _vq_lengthlist__44u9_p7_1[] = {
+ 5, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 6, 6, 6, 7, 7,
+ 7, 7, 7, 7, 7, 7, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 6, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 8, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 8, 8, 7, 7, 7, 7, 7, 7, 7, 8, 7, 8, 8, 7, 7,
+ 7, 7, 7, 7, 7, 8, 8, 8, 8,
+};
+
+static const static_codebook _44u9_p7_1 = {
+ 2, 121,
+ (long *)_vq_lengthlist__44u9_p7_1,
+ 1, -531365888, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44u9_p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44u9_p8_0[] = {
+ 7,
+ 6,
+ 8,
+ 5,
+ 9,
+ 4,
+ 10,
+ 3,
+ 11,
+ 2,
+ 12,
+ 1,
+ 13,
+ 0,
+ 14,
+};
+
+static const long _vq_lengthlist__44u9_p8_0[] = {
+ 1, 4, 4, 7, 7, 8, 8, 8, 8, 9, 9,10, 9,11,10, 4,
+ 6, 6, 8, 8, 9, 9, 9, 9,10,10,11,10,12,10, 4, 6,
+ 6, 8, 8, 9,10, 9, 9,10,10,11,11,12,12, 7, 8, 8,
+ 10,10,11,11,10,10,11,11,12,12,13,12, 7, 8, 8,10,
+ 10,11,11,10,10,11,11,12,12,12,13, 8,10, 9,11,11,
+ 12,12,11,11,12,12,13,13,14,13, 8, 9, 9,11,11,12,
+ 12,11,12,12,12,13,13,14,13, 8, 9, 9,10,10,12,11,
+ 13,12,13,13,14,13,15,14, 8, 9, 9,10,10,11,12,12,
+ 12,13,13,13,14,14,14, 9,10,10,12,11,13,12,13,13,
+ 14,13,14,14,14,15, 9,10,10,11,12,12,12,13,13,14,
+ 14,14,15,15,15,10,11,11,12,12,13,13,14,14,14,14,
+ 15,14,16,15,10,11,11,12,12,13,13,13,14,14,14,14,
+ 14,15,16,11,12,12,13,13,14,13,14,14,15,14,15,16,
+ 16,16,11,12,12,13,13,14,13,14,14,15,15,15,16,15,
+ 15,
+};
+
+static const static_codebook _44u9_p8_0 = {
+ 2, 225,
+ (long *)_vq_lengthlist__44u9_p8_0,
+ 1, -520986624, 1620377600, 4, 0,
+ (long *)_vq_quantlist__44u9_p8_0,
+ 0
+};
+
+static const long _vq_quantlist__44u9_p8_1[] = {
+ 10,
+ 9,
+ 11,
+ 8,
+ 12,
+ 7,
+ 13,
+ 6,
+ 14,
+ 5,
+ 15,
+ 4,
+ 16,
+ 3,
+ 17,
+ 2,
+ 18,
+ 1,
+ 19,
+ 0,
+ 20,
+};
+
+static const long _vq_lengthlist__44u9_p8_1[] = {
+ 4, 6, 6, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 6, 6, 6, 7, 7, 8, 8, 8, 8, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 6, 6, 6, 7, 7, 8,
+ 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 7,
+ 7, 7, 8, 8, 8, 8, 9, 8, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9, 8, 8, 8, 8, 8, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9,10, 9,10,10,10, 8, 8,
+ 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9,10,10, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 10, 9,10, 9,10,10,10,10, 8, 8, 8, 9, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9,10,10, 9,10,10,10,10,10, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9, 9,10, 9,10,10,10,10,10,10,
+ 10,10, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,10,10,10,
+ 10,10,10,10,10,10,10, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9,10,10,10,10,10,10,10,10,10,10, 9, 9, 9, 9,
+ 9, 9, 9, 9, 9, 9, 9,10,10,10,10,10,10,10,10,10,
+ 10, 9, 9, 9, 9, 9, 9, 9,10, 9,10,10,10,10,10,10,
+ 10,10,10,10,10,10, 9, 9, 9, 9, 9, 9, 9, 9,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10, 9, 9, 9, 9, 9,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 9, 9, 9, 9,10, 9, 9,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10, 9, 9, 9,10, 9,10, 9,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10, 9, 9, 9,10, 9,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10, 9,
+ 9, 9, 9, 9,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10, 9, 9, 9,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,
+};
+
+static const static_codebook _44u9_p8_1 = {
+ 2, 441,
+ (long *)_vq_lengthlist__44u9_p8_1,
+ 1, -529268736, 1611661312, 5, 0,
+ (long *)_vq_quantlist__44u9_p8_1,
+ 0
+};
+
+static const long _vq_quantlist__44u9_p9_0[] = {
+ 7,
+ 6,
+ 8,
+ 5,
+ 9,
+ 4,
+ 10,
+ 3,
+ 11,
+ 2,
+ 12,
+ 1,
+ 13,
+ 0,
+ 14,
+};
+
+static const long _vq_lengthlist__44u9_p9_0[] = {
+ 1, 3, 3,11,11,11,11,11,11,11,11,11,11,11,11, 4,
+ 10,11,11,11,11,11,11,11,11,11,11,11,11,11, 4,10,
+ 10,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,
+};
+
+static const static_codebook _44u9_p9_0 = {
+ 2, 225,
+ (long *)_vq_lengthlist__44u9_p9_0,
+ 1, -510036736, 1631393792, 4, 0,
+ (long *)_vq_quantlist__44u9_p9_0,
+ 0
+};
+
+static const long _vq_quantlist__44u9_p9_1[] = {
+ 9,
+ 8,
+ 10,
+ 7,
+ 11,
+ 6,
+ 12,
+ 5,
+ 13,
+ 4,
+ 14,
+ 3,
+ 15,
+ 2,
+ 16,
+ 1,
+ 17,
+ 0,
+ 18,
+};
+
+static const long _vq_lengthlist__44u9_p9_1[] = {
+ 1, 4, 4, 7, 7, 8, 7, 8, 7, 9, 8,10, 9,10,10,11,
+ 11,12,12, 4, 7, 6, 9, 9,10, 9, 9, 8,10,10,11,10,
+ 12,10,13,12,13,12, 4, 6, 6, 9, 9, 9, 9, 9, 9,10,
+ 10,11,11,11,12,12,12,12,12, 7, 9, 8,11,10,10,10,
+ 11,10,11,11,12,12,13,12,13,13,13,13, 7, 8, 9,10,
+ 10,11,11,10,10,11,11,11,12,13,13,13,13,14,14, 8,
+ 9, 9,11,11,12,11,12,12,13,12,12,13,13,14,15,14,
+ 14,14, 8, 9, 9,10,11,11,11,12,12,13,12,13,13,14,
+ 14,14,15,14,16, 8, 9, 9,11,10,12,12,12,12,15,13,
+ 13,13,17,14,15,15,15,14, 8, 9, 9,10,11,11,12,13,
+ 12,13,13,13,14,15,14,14,14,16,15, 9,11,10,12,12,
+ 13,13,13,13,14,14,16,15,14,14,14,15,15,17, 9,10,
+ 10,11,11,13,13,13,14,14,13,15,14,15,14,15,16,15,
+ 16,10,11,11,12,12,13,14,15,14,15,14,14,15,17,16,
+ 15,15,17,17,10,12,11,13,12,14,14,13,14,15,15,15,
+ 15,16,17,17,15,17,16,11,12,12,14,13,15,14,15,16,
+ 17,15,17,15,17,15,15,16,17,15,11,11,12,14,14,14,
+ 14,14,15,15,16,15,17,17,17,16,17,16,15,12,12,13,
+ 14,14,14,15,14,15,15,16,16,17,16,17,15,17,17,16,
+ 12,14,12,14,14,15,15,15,14,14,16,16,16,15,16,16,
+ 15,17,15,12,13,13,14,15,14,15,17,15,17,16,17,17,
+ 17,16,17,16,17,17,12,13,13,14,16,15,15,15,16,15,
+ 17,17,15,17,15,17,16,16,17,
+};
+
+static const static_codebook _44u9_p9_1 = {
+ 2, 361,
+ (long *)_vq_lengthlist__44u9_p9_1,
+ 1, -518287360, 1622704128, 5, 0,
+ (long *)_vq_quantlist__44u9_p9_1,
+ 0
+};
+
+static const long _vq_quantlist__44u9_p9_2[] = {
+ 24,
+ 23,
+ 25,
+ 22,
+ 26,
+ 21,
+ 27,
+ 20,
+ 28,
+ 19,
+ 29,
+ 18,
+ 30,
+ 17,
+ 31,
+ 16,
+ 32,
+ 15,
+ 33,
+ 14,
+ 34,
+ 13,
+ 35,
+ 12,
+ 36,
+ 11,
+ 37,
+ 10,
+ 38,
+ 9,
+ 39,
+ 8,
+ 40,
+ 7,
+ 41,
+ 6,
+ 42,
+ 5,
+ 43,
+ 4,
+ 44,
+ 3,
+ 45,
+ 2,
+ 46,
+ 1,
+ 47,
+ 0,
+ 48,
+};
+
+static const long _vq_lengthlist__44u9_p9_2[] = {
+ 2, 4, 4, 5, 4, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 7, 6, 7, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7,
+};
+
+static const static_codebook _44u9_p9_2 = {
+ 1, 49,
+ (long *)_vq_lengthlist__44u9_p9_2,
+ 1, -526909440, 1611661312, 6, 0,
+ (long *)_vq_quantlist__44u9_p9_2,
+ 0
+};
+
+static const long _huff_lengthlist__44un1__long[] = {
+ 5, 6,12, 9,14, 9, 9,19, 6, 1, 5, 5, 8, 7, 9,19,
+ 12, 4, 4, 7, 7, 9,11,18, 9, 5, 6, 6, 8, 7, 8,17,
+ 14, 8, 7, 8, 8,10,12,18, 9, 6, 8, 6, 8, 6, 8,18,
+ 9, 8,11, 8,11, 7, 5,15,16,18,18,18,17,15,11,18,
+};
+
+static const static_codebook _huff_book__44un1__long = {
+ 2, 64,
+ (long *)_huff_lengthlist__44un1__long,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
+static const long _vq_quantlist__44un1__p1_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44un1__p1_0[] = {
+ 1, 4, 4, 5, 8, 7, 5, 7, 8, 5, 8, 8, 8,10,11, 8,
+ 10,11, 5, 8, 8, 8,11,10, 8,11,10, 4, 9, 9, 8,11,
+ 11, 8,11,11, 8,12,11,10,12,14,11,13,13, 7,11,11,
+ 10,13,11,11,13,14, 4, 8, 9, 8,11,11, 8,11,12, 7,
+ 11,11,11,14,13,10,11,13, 8,11,12,11,13,13,10,14,
+ 12,
+};
+
+static const static_codebook _44un1__p1_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44un1__p1_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44un1__p1_0,
+ 0
+};
+
+static const long _vq_quantlist__44un1__p2_0[] = {
+ 1,
+ 0,
+ 2,
+};
+
+static const long _vq_lengthlist__44un1__p2_0[] = {
+ 2, 4, 4, 5, 6, 6, 5, 6, 6, 5, 7, 7, 7, 8, 8, 6,
+ 7, 9, 5, 7, 7, 6, 8, 7, 7, 9, 8, 4, 7, 7, 7, 9,
+ 8, 7, 8, 8, 7, 9, 8, 8, 8,10, 9,10,10, 6, 8, 8,
+ 7,10, 8, 9,10,10, 5, 7, 7, 7, 8, 8, 7, 8, 9, 6,
+ 8, 8, 9,10,10, 7, 8,10, 6, 8, 9, 9,10,10, 8,10,
+ 8,
+};
+
+static const static_codebook _44un1__p2_0 = {
+ 4, 81,
+ (long *)_vq_lengthlist__44un1__p2_0,
+ 1, -535822336, 1611661312, 2, 0,
+ (long *)_vq_quantlist__44un1__p2_0,
+ 0
+};
+
+static const long _vq_quantlist__44un1__p3_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44un1__p3_0[] = {
+ 1, 5, 5, 8, 8, 5, 8, 7, 9, 9, 5, 7, 8, 9, 9, 9,
+ 10, 9,12,12, 9, 9,10,11,12, 6, 8, 8,10,10, 8,10,
+ 10,11,11, 8, 9,10,11,11,10,11,11,13,13,10,11,11,
+ 12,13, 6, 8, 8,10,10, 8,10, 9,11,11, 8,10,10,11,
+ 11,10,11,11,13,12,10,11,11,13,12, 9,11,11,15,13,
+ 10,12,11,15,13,10,11,11,15,14,12,14,13,16,15,12,
+ 13,13,17,16, 9,11,11,13,15,10,11,12,14,15,10,11,
+ 12,14,15,12,13,13,15,16,12,13,13,16,16, 5, 8, 8,
+ 11,11, 8,10,10,12,12, 8,10,10,12,12,11,12,12,14,
+ 14,11,12,12,14,14, 8,11,10,13,12,10,11,12,12,13,
+ 10,12,12,13,13,12,12,13,13,15,11,12,13,15,14, 7,
+ 10,10,12,12, 9,12,11,13,12,10,12,12,13,14,12,13,
+ 12,15,13,11,13,12,14,15,10,12,12,16,14,11,12,12,
+ 16,15,11,13,12,17,16,13,13,15,15,17,13,15,15,20,
+ 17,10,12,12,14,16,11,12,12,15,15,11,13,13,15,18,
+ 13,14,13,15,15,13,15,14,16,16, 5, 8, 8,11,11, 8,
+ 10,10,12,12, 8,10,10,12,12,11,12,12,14,14,11,12,
+ 12,14,15, 7,10,10,13,12,10,12,12,14,13, 9,10,12,
+ 12,13,11,13,13,15,15,11,12,13,13,15, 8,10,10,12,
+ 13,10,12,12,13,13,10,12,11,13,13,11,13,12,15,15,
+ 12,13,12,15,13,10,12,12,16,14,11,12,12,16,15,10,
+ 12,12,16,14,14,15,14,18,16,13,13,14,15,16,10,12,
+ 12,14,16,11,13,13,16,16,11,13,12,14,16,13,15,15,
+ 18,18,13,15,13,16,14, 8,11,11,16,16,10,13,13,17,
+ 16,10,12,12,16,15,14,16,15,20,17,13,14,14,17,17,
+ 9,12,12,16,16,11,13,14,16,17,11,13,13,16,16,15,
+ 15,19,18, 0,14,15,15,18,18, 9,12,12,17,16,11,13,
+ 12,17,16,11,12,13,15,17,15,16,15, 0,19,14,15,14,
+ 19,18,12,14,14, 0,16,13,14,14,19,18,13,15,16,17,
+ 16,15,15,17,18, 0,14,16,16,19, 0,12,14,14,16,18,
+ 13,15,13,17,18,13,15,14,17,18,15,18,14,18,18,16,
+ 17,16, 0,17, 8,11,11,15,15,10,12,12,16,16,10,13,
+ 13,16,16,13,15,14,17,17,14,15,17,17,18, 9,12,12,
+ 16,15,11,13,13,16,16,11,12,13,17,17,14,14,15,17,
+ 17,14,15,16, 0,18, 9,12,12,16,17,11,13,13,16,17,
+ 11,14,13,18,17,14,16,14,17,17,15,17,17,18,18,12,
+ 14,14, 0,16,13,15,15,19, 0,12,13,15, 0, 0,14,17,
+ 16,19, 0,16,15,18,18, 0,12,14,14,17, 0,13,14,14,
+ 17, 0,13,15,14, 0,18,15,16,16, 0,18,15,18,15, 0,
+ 17,
+};
+
+static const static_codebook _44un1__p3_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44un1__p3_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44un1__p3_0,
+ 0
+};
+
+static const long _vq_quantlist__44un1__p4_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44un1__p4_0[] = {
+ 3, 5, 5, 9, 9, 5, 6, 6,10, 9, 5, 6, 6, 9,10,10,
+ 10,10,12,11, 9,10,10,12,12, 5, 7, 7,10,10, 7, 7,
+ 8,10,11, 7, 7, 8,10,11,10,10,11,11,13,10,10,11,
+ 11,13, 6, 7, 7,10,10, 7, 8, 7,11,10, 7, 8, 7,10,
+ 10,10,11, 9,13,11,10,11,10,13,11,10,10,10,14,13,
+ 10,11,11,14,13,10,10,11,13,14,12,12,13,15,15,12,
+ 12,13,13,14,10,10,10,12,13,10,11,10,13,13,10,11,
+ 11,13,13,12,13,12,14,13,12,13,13,14,13, 5, 7, 7,
+ 10,10, 7, 8, 8,11,10, 7, 8, 8,10,10,11,11,11,13,
+ 13,10,11,11,12,12, 7, 8, 8,11,11, 7, 8, 9,10,12,
+ 8, 9, 9,11,11,11,10,12,11,14,11,11,12,13,13, 6,
+ 8, 8,10,11, 7, 9, 7,12,10, 8, 9,10,11,12,10,12,
+ 10,14,11,11,12,11,13,13,10,11,11,14,14,10,10,11,
+ 13,14,11,12,12,15,13,12,11,14,12,16,12,13,14,15,
+ 16,10,10,11,13,14,10,11,10,14,12,11,12,12,13,14,
+ 12,13,11,15,12,14,14,14,15,15, 5, 7, 7,10,10, 7,
+ 8, 8,10,10, 7, 8, 8,10,11,10,11,10,12,12,10,11,
+ 11,12,13, 6, 8, 8,11,11, 8, 9, 9,12,11, 7, 7, 9,
+ 10,12,11,11,11,12,13,11,10,12,11,15, 7, 8, 8,11,
+ 11, 8, 9, 9,11,11, 7, 9, 8,12,10,11,12,11,13,12,
+ 11,12,10,15,11,10,11,10,14,12,11,12,11,14,13,10,
+ 10,11,13,14,13,13,13,17,15,12,11,14,12,15,10,10,
+ 11,13,14,11,12,12,14,14,10,11,10,14,13,13,14,13,
+ 16,17,12,14,11,16,12, 9,10,10,14,13,10,11,10,14,
+ 14,10,11,11,13,13,13,14,14,16,15,12,13,13,14,14,
+ 9,11,10,14,13,10,10,12,13,14,11,12,11,14,13,13,
+ 14,14,14,15,13,14,14,15,15, 9,10,11,13,14,10,11,
+ 10,15,13,11,11,12,12,15,13,14,12,15,14,13,13,14,
+ 14,15,12,13,12,16,14,11,11,12,15,14,13,15,13,16,
+ 14,13,12,15,12,17,15,16,15,16,16,12,12,13,13,15,
+ 11,13,11,15,14,13,13,14,15,17,13,14,12, 0,13,14,
+ 15,14,15, 0, 9,10,10,13,13,10,11,11,13,13,10,11,
+ 11,13,13,12,13,12,14,14,13,14,14,15,17, 9,10,10,
+ 13,13,11,12,11,15,12,10,10,11,13,16,13,14,13,15,
+ 14,13,13,14,15,16,10,10,11,13,14,11,11,12,13,14,
+ 10,12,11,14,14,13,13,13,14,15,13,15,13,16,15,12,
+ 13,12,15,13,12,15,13,15,15,11,11,13,14,15,15,15,
+ 15,15,17,13,12,14,13,17,12,12,14,14,15,13,13,14,
+ 14,16,11,13,11,16,15,14,16,16,17, 0,14,13,11,16,
+ 12,
+};
+
+static const static_codebook _44un1__p4_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44un1__p4_0,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44un1__p4_0,
+ 0
+};
+
+static const long _vq_quantlist__44un1__p5_0[] = {
+ 4,
+ 3,
+ 5,
+ 2,
+ 6,
+ 1,
+ 7,
+ 0,
+ 8,
+};
+
+static const long _vq_lengthlist__44un1__p5_0[] = {
+ 1, 4, 4, 7, 7, 8, 8, 9, 9, 4, 6, 5, 8, 7, 8, 8,
+ 10, 9, 4, 6, 6, 8, 8, 8, 8,10,10, 7, 8, 7, 9, 9,
+ 9, 9,11,10, 7, 8, 8, 9, 9, 9, 9,10,11, 8, 8, 8,
+ 9, 9,10,10,11,11, 8, 8, 8, 9, 9,10,10,11,11, 9,
+ 10,10,11,10,11,11,12,12, 9,10,10,10,11,11,11,12,
+ 12,
+};
+
+static const static_codebook _44un1__p5_0 = {
+ 2, 81,
+ (long *)_vq_lengthlist__44un1__p5_0,
+ 1, -531628032, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44un1__p5_0,
+ 0
+};
+
+static const long _vq_quantlist__44un1__p6_0[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44un1__p6_0[] = {
+ 1, 4, 4, 6, 6, 8, 8,10,10,11,11,15,15, 4, 5, 5,
+ 8, 8, 9, 9,11,11,12,12,16,16, 4, 5, 6, 8, 8, 9,
+ 9,11,11,12,12,14,14, 7, 8, 8, 9, 9,10,10,11,12,
+ 13,13,16,17, 7, 8, 8, 9, 9,10,10,12,12,12,13,15,
+ 15, 9,10,10,10,10,11,11,12,12,13,13,15,16, 9, 9,
+ 9,10,10,11,11,13,12,13,13,17,17,10,11,11,11,12,
+ 12,12,13,13,14,15, 0,18,10,11,11,12,12,12,13,14,
+ 13,14,14,17,16,11,12,12,13,13,14,14,14,14,15,16,
+ 17,16,11,12,12,13,13,14,14,14,14,15,15,17,17,14,
+ 15,15,16,16,16,17,17,16, 0,17, 0,18,14,15,15,16,
+ 16, 0,15,18,18, 0,16, 0, 0,
+};
+
+static const static_codebook _44un1__p6_0 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44un1__p6_0,
+ 1, -526516224, 1616117760, 4, 0,
+ (long *)_vq_quantlist__44un1__p6_0,
+ 0
+};
+
+static const long _vq_quantlist__44un1__p6_1[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44un1__p6_1[] = {
+ 2, 4, 4, 5, 5, 4, 5, 5, 5, 5, 4, 5, 5, 6, 5, 5,
+ 6, 5, 6, 6, 5, 6, 6, 6, 6,
+};
+
+static const static_codebook _44un1__p6_1 = {
+ 2, 25,
+ (long *)_vq_lengthlist__44un1__p6_1,
+ 1, -533725184, 1611661312, 3, 0,
+ (long *)_vq_quantlist__44un1__p6_1,
+ 0
+};
+
+static const long _vq_quantlist__44un1__p7_0[] = {
+ 2,
+ 1,
+ 3,
+ 0,
+ 4,
+};
+
+static const long _vq_lengthlist__44un1__p7_0[] = {
+ 1, 5, 3,11,11,11,11,11,11,11, 8,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,10,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,10,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11, 8,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,10,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11, 7,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,10,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+ 10,
+};
+
+static const static_codebook _44un1__p7_0 = {
+ 4, 625,
+ (long *)_vq_lengthlist__44un1__p7_0,
+ 1, -518709248, 1626677248, 3, 0,
+ (long *)_vq_quantlist__44un1__p7_0,
+ 0
+};
+
+static const long _vq_quantlist__44un1__p7_1[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44un1__p7_1[] = {
+ 1, 4, 4, 6, 6, 6, 6, 9, 8, 9, 8, 8, 8, 5, 7, 7,
+ 7, 7, 8, 8, 8,10, 8,10, 8, 9, 5, 7, 7, 8, 7, 7,
+ 8,10,10,11,10,12,11, 7, 8, 8, 9, 9, 9,10,11,11,
+ 11,11,11,11, 7, 8, 8, 8, 9, 9, 9,10,10,10,11,11,
+ 12, 7, 8, 8, 9, 9,10,11,11,12,11,12,11,11, 7, 8,
+ 8, 9, 9,10,10,11,11,11,12,12,11, 8,10,10,10,10,
+ 11,11,14,11,12,12,12,13, 9,10,10,10,10,12,11,14,
+ 11,14,11,12,13,10,11,11,11,11,13,11,14,14,13,13,
+ 13,14,11,11,11,12,11,12,12,12,13,14,14,13,14,12,
+ 11,12,12,12,12,13,13,13,14,13,14,14,11,12,12,14,
+ 12,13,13,12,13,13,14,14,14,
+};
+
+static const static_codebook _44un1__p7_1 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44un1__p7_1,
+ 1, -523010048, 1618608128, 4, 0,
+ (long *)_vq_quantlist__44un1__p7_1,
+ 0
+};
+
+static const long _vq_quantlist__44un1__p7_2[] = {
+ 6,
+ 5,
+ 7,
+ 4,
+ 8,
+ 3,
+ 9,
+ 2,
+ 10,
+ 1,
+ 11,
+ 0,
+ 12,
+};
+
+static const long _vq_lengthlist__44un1__p7_2[] = {
+ 3, 4, 4, 6, 6, 7, 7, 8, 8, 9, 9, 9, 8, 4, 5, 5,
+ 6, 6, 8, 8, 9, 8, 9, 9, 9, 9, 4, 5, 5, 7, 6, 8,
+ 8, 8, 8, 9, 8, 9, 8, 6, 7, 7, 7, 8, 8, 8, 9, 9,
+ 9, 9, 9, 9, 6, 7, 7, 7, 7, 8, 8, 9, 9, 9, 9, 9,
+ 9, 7, 8, 8, 8, 8, 9, 8, 9, 9,10, 9, 9,10, 7, 8,
+ 8, 8, 8, 9, 9, 9, 9, 9, 9,10,10, 8, 9, 9, 9, 9,
+ 9, 9, 9, 9,10,10, 9,10, 8, 9, 9, 9, 9, 9, 9, 9,
+ 9, 9, 9,10,10, 9, 9, 9,10, 9, 9,10, 9, 9,10,10,
+ 10,10, 9, 9, 9, 9, 9, 9, 9,10, 9,10,10,10,10, 9,
+ 9, 9,10, 9, 9,10,10, 9,10,10,10,10, 9, 9, 9,10,
+ 9, 9, 9,10,10,10,10,10,10,
+};
+
+static const static_codebook _44un1__p7_2 = {
+ 2, 169,
+ (long *)_vq_lengthlist__44un1__p7_2,
+ 1, -531103744, 1611661312, 4, 0,
+ (long *)_vq_quantlist__44un1__p7_2,
+ 0
+};
+
+static const long _huff_lengthlist__44un1__short[] = {
+ 12,12,14,12,14,14,14,14,12, 6, 6, 8, 9, 9,11,14,
+ 12, 4, 2, 6, 6, 7,11,14,13, 6, 5, 7, 8, 9,11,14,
+ 13, 8, 5, 8, 6, 8,12,14,12, 7, 7, 8, 8, 8,10,14,
+ 12, 6, 3, 4, 4, 4, 7,14,11, 7, 4, 6, 6, 6, 8,14,
+};
+
+static const static_codebook _huff_book__44un1__short = {
+ 2, 64,
+ (long *)_huff_lengthlist__44un1__short,
+ 0, 0, 0, 0, 0,
+ NULL,
+ 0
+};
+
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: basic codebook pack/unpack/code/decode operations
+ last mod: $Id: codebook.c 18183 2012-02-03 20:51:27Z xiphmont $
+
+ ********************************************************************/
+
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <ogg/ogg.h>
+#include "vorbis/codec.h"
+#include "codebook.h"
+#include "scales.h"
+#include "misc.h"
+#include "os.h"
+
+/* packs the given codebook into the bitstream **************************/
+
+int vorbis_staticbook_pack(const static_codebook *c,oggpack_buffer *opb){
+ long i,j;
+ int ordered=0;
+
+ /* first the basic parameters */
+ oggpack_write(opb,0x564342,24);
+ oggpack_write(opb,c->dim,16);
+ oggpack_write(opb,c->entries,24);
+
+ /* pack the codewords. There are two packings; length ordered and
+ length random. Decide between the two now. */
+
+ for(i=1;i<c->entries;i++)
+ if(c->lengthlist[i-1]==0 || c->lengthlist[i]<c->lengthlist[i-1])break;
+ if(i==c->entries)ordered=1;
+
+ if(ordered){
+ /* length ordered. We only need to say how many codewords of
+ each length. The actual codewords are generated
+ deterministically */
+
+ long count=0;
+ oggpack_write(opb,1,1); /* ordered */
+ oggpack_write(opb,c->lengthlist[0]-1,5); /* 1 to 32 */
+
+ for(i=1;i<c->entries;i++){
+ long this=c->lengthlist[i];
+ long last=c->lengthlist[i-1];
+ if(this>last){
+ for(j=last;j<this;j++){
+ oggpack_write(opb,i-count,_ilog(c->entries-count));
+ count=i;
+ }
+ }
+ }
+ oggpack_write(opb,i-count,_ilog(c->entries-count));
+
+ }else{
+ /* length random. Again, we don't code the codeword itself, just
+ the length. This time, though, we have to encode each length */
+ oggpack_write(opb,0,1); /* unordered */
+
+ /* algortihmic mapping has use for 'unused entries', which we tag
+ here. The algorithmic mapping happens as usual, but the unused
+ entry has no codeword. */
+ for(i=0;i<c->entries;i++)
+ if(c->lengthlist[i]==0)break;
+
+ if(i==c->entries){
+ oggpack_write(opb,0,1); /* no unused entries */
+ for(i=0;i<c->entries;i++)
+ oggpack_write(opb,c->lengthlist[i]-1,5);
+ }else{
+ oggpack_write(opb,1,1); /* we have unused entries; thus we tag */
+ for(i=0;i<c->entries;i++){
+ if(c->lengthlist[i]==0){
+ oggpack_write(opb,0,1);
+ }else{
+ oggpack_write(opb,1,1);
+ oggpack_write(opb,c->lengthlist[i]-1,5);
+ }
+ }
+ }
+ }
+
+ /* is the entry number the desired return value, or do we have a
+ mapping? If we have a mapping, what type? */
+ oggpack_write(opb,c->maptype,4);
+ switch(c->maptype){
+ case 0:
+ /* no mapping */
+ break;
+ case 1:case 2:
+ /* implicitly populated value mapping */
+ /* explicitly populated value mapping */
+
+ if(!c->quantlist){
+ /* no quantlist? error */
+ return(-1);
+ }
+
+ /* values that define the dequantization */
+ oggpack_write(opb,c->q_min,32);
+ oggpack_write(opb,c->q_delta,32);
+ oggpack_write(opb,c->q_quant-1,4);
+ oggpack_write(opb,c->q_sequencep,1);
+
+ {
+ int quantvals;
+ switch(c->maptype){
+ case 1:
+ /* a single column of (c->entries/c->dim) quantized values for
+ building a full value list algorithmically (square lattice) */
+ quantvals=_book_maptype1_quantvals(c);
+ break;
+ case 2:
+ /* every value (c->entries*c->dim total) specified explicitly */
+ quantvals=c->entries*c->dim;
+ break;
+ default: /* NOT_REACHABLE */
+ quantvals=-1;
+ }
+
+ /* quantized values */
+ for(i=0;i<quantvals;i++)
+ oggpack_write(opb,labs(c->quantlist[i]),c->q_quant);
+
+ }
+ break;
+ default:
+ /* error case; we don't have any other map types now */
+ return(-1);
+ }
+
+ return(0);
+}
+
+/* unpacks a codebook from the packet buffer into the codebook struct,
+ readies the codebook auxiliary structures for decode *************/
+static_codebook *vorbis_staticbook_unpack(oggpack_buffer *opb){
+ long i,j;
+ static_codebook *s=_ogg_calloc(1,sizeof(*s));
+ s->allocedp=1;
+
+ /* make sure alignment is correct */
+ if(oggpack_read(opb,24)!=0x564342)goto _eofout;
+
+ /* first the basic parameters */
+ s->dim=oggpack_read(opb,16);
+ s->entries=oggpack_read(opb,24);
+ if(s->entries==-1)goto _eofout;
+
+ if(_ilog(s->dim)+_ilog(s->entries)>24)goto _eofout;
+
+ /* codeword ordering.... length ordered or unordered? */
+ switch((int)oggpack_read(opb,1)){
+ case 0:{
+ long unused;
+ /* allocated but unused entries? */
+ unused=oggpack_read(opb,1);
+ if((s->entries*(unused?1:5)+7)>>3>opb->storage-oggpack_bytes(opb))
+ goto _eofout;
+ /* unordered */
+ s->lengthlist=_ogg_malloc(sizeof(*s->lengthlist)*s->entries);
+
+ /* allocated but unused entries? */
+ if(unused){
+ /* yes, unused entries */
+
+ for(i=0;i<s->entries;i++){
+ if(oggpack_read(opb,1)){
+ long num=oggpack_read(opb,5);
+ if(num==-1)goto _eofout;
+ s->lengthlist[i]=num+1;
+ }else
+ s->lengthlist[i]=0;
+ }
+ }else{
+ /* all entries used; no tagging */
+ for(i=0;i<s->entries;i++){
+ long num=oggpack_read(opb,5);
+ if(num==-1)goto _eofout;
+ s->lengthlist[i]=num+1;
+ }
+ }
+
+ break;
+ }
+ case 1:
+ /* ordered */
+ {
+ long length=oggpack_read(opb,5)+1;
+ if(length==0)goto _eofout;
+ s->lengthlist=_ogg_malloc(sizeof(*s->lengthlist)*s->entries);
+
+ for(i=0;i<s->entries;){
+ long num=oggpack_read(opb,_ilog(s->entries-i));
+ if(num==-1)goto _eofout;
+ if(length>32 || num>s->entries-i ||
+ (num>0 && (num-1)>>(length-1)>1)){
+ goto _errout;
+ }
+ if(length>32)goto _errout;
+ for(j=0;j<num;j++,i++)
+ s->lengthlist[i]=length;
+ length++;
+ }
+ }
+ break;
+ default:
+ /* EOF */
+ goto _eofout;
+ }
+
+ /* Do we have a mapping to unpack? */
+ switch((s->maptype=oggpack_read(opb,4))){
+ case 0:
+ /* no mapping */
+ break;
+ case 1: case 2:
+ /* implicitly populated value mapping */
+ /* explicitly populated value mapping */
+
+ s->q_min=oggpack_read(opb,32);
+ s->q_delta=oggpack_read(opb,32);
+ s->q_quant=oggpack_read(opb,4)+1;
+ s->q_sequencep=oggpack_read(opb,1);
+ if(s->q_sequencep==-1)goto _eofout;
+
+ {
+ int quantvals=0;
+ switch(s->maptype){
+ case 1:
+ quantvals=(s->dim==0?0:_book_maptype1_quantvals(s));
+ break;
+ case 2:
+ quantvals=s->entries*s->dim;
+ break;
+ }
+
+ /* quantized values */
+ if(((quantvals*s->q_quant+7)>>3)>opb->storage-oggpack_bytes(opb))
+ goto _eofout;
+ s->quantlist=_ogg_malloc(sizeof(*s->quantlist)*quantvals);
+ for(i=0;i<quantvals;i++)
+ s->quantlist[i]=oggpack_read(opb,s->q_quant);
+
+ if(quantvals&&s->quantlist[quantvals-1]==-1)goto _eofout;
+ }
+ break;
+ default:
+ goto _errout;
+ }
+
+ /* all set */
+ return(s);
+
+ _errout:
+ _eofout:
+ vorbis_staticbook_destroy(s);
+ return(NULL);
+}
+
+/* returns the number of bits ************************************************/
+int vorbis_book_encode(codebook *book, int a, oggpack_buffer *b){
+ if(a<0 || a>=book->c->entries)return(0);
+ oggpack_write(b,book->codelist[a],book->c->lengthlist[a]);
+ return(book->c->lengthlist[a]);
+}
+
+/* the 'eliminate the decode tree' optimization actually requires the
+ codewords to be MSb first, not LSb. This is an annoying inelegancy
+ (and one of the first places where carefully thought out design
+ turned out to be wrong; Vorbis II and future Ogg codecs should go
+ to an MSb bitpacker), but not actually the huge hit it appears to
+ be. The first-stage decode table catches most words so that
+ bitreverse is not in the main execution path. */
+
+static ogg_uint32_t bitreverse(ogg_uint32_t x){
+ x= ((x>>16)&0x0000ffff) | ((x<<16)&0xffff0000);
+ x= ((x>> 8)&0x00ff00ff) | ((x<< 8)&0xff00ff00);
+ x= ((x>> 4)&0x0f0f0f0f) | ((x<< 4)&0xf0f0f0f0);
+ x= ((x>> 2)&0x33333333) | ((x<< 2)&0xcccccccc);
+ return((x>> 1)&0x55555555) | ((x<< 1)&0xaaaaaaaa);
+}
+
+STIN long decode_packed_entry_number(codebook *book, oggpack_buffer *b){
+ int read=book->dec_maxlength;
+ long lo,hi;
+ long lok = oggpack_look(b,book->dec_firsttablen);
+
+ if (lok >= 0) {
+ long entry = book->dec_firsttable[lok];
+ if(entry&0x80000000UL){
+ lo=(entry>>15)&0x7fff;
+ hi=book->used_entries-(entry&0x7fff);
+ }else{
+ oggpack_adv(b, book->dec_codelengths[entry-1]);
+ return(entry-1);
+ }
+ }else{
+ lo=0;
+ hi=book->used_entries;
+ }
+
+ lok = oggpack_look(b, read);
+
+ while(lok<0 && read>1)
+ lok = oggpack_look(b, --read);
+ if(lok<0)return -1;
+
+ /* bisect search for the codeword in the ordered list */
+ {
+ ogg_uint32_t testword=bitreverse((ogg_uint32_t)lok);
+
+ while(hi-lo>1){
+ long p=(hi-lo)>>1;
+ long test=book->codelist[lo+p]>testword;
+ lo+=p&(test-1);
+ hi-=p&(-test);
+ }
+
+ if(book->dec_codelengths[lo]<=read){
+ oggpack_adv(b, book->dec_codelengths[lo]);
+ return(lo);
+ }
+ }
+
+ oggpack_adv(b, read);
+
+ return(-1);
+}
+
+/* Decode side is specced and easier, because we don't need to find
+ matches using different criteria; we simply read and map. There are
+ two things we need to do 'depending':
+
+ We may need to support interleave. We don't really, but it's
+ convenient to do it here rather than rebuild the vector later.
+
+ Cascades may be additive or multiplicitive; this is not inherent in
+ the codebook, but set in the code using the codebook. Like
+ interleaving, it's easiest to do it here.
+ addmul==0 -> declarative (set the value)
+ addmul==1 -> additive
+ addmul==2 -> multiplicitive */
+
+/* returns the [original, not compacted] entry number or -1 on eof *********/
+long vorbis_book_decode(codebook *book, oggpack_buffer *b){
+ if(book->used_entries>0){
+ long packed_entry=decode_packed_entry_number(book,b);
+ if(packed_entry>=0)
+ return(book->dec_index[packed_entry]);
+ }
+
+ /* if there's no dec_index, the codebook unpacking isn't collapsed */
+ return(-1);
+}
+
+/* returns 0 on OK or -1 on eof *************************************/
+/* decode vector / dim granularity gaurding is done in the upper layer */
+long vorbis_book_decodevs_add(codebook *book,float *a,oggpack_buffer *b,int n){
+ if(book->used_entries>0){
+ int step=n/book->dim;
+ long *entry = alloca(sizeof(*entry)*step);
+ float **t = alloca(sizeof(*t)*step);
+ int i,j,o;
+
+ for (i = 0; i < step; i++) {
+ entry[i]=decode_packed_entry_number(book,b);
+ if(entry[i]==-1)return(-1);
+ t[i] = book->valuelist+entry[i]*book->dim;
+ }
+ for(i=0,o=0;i<book->dim;i++,o+=step)
+ for (j=0;j<step;j++)
+ a[o+j]+=t[j][i];
+ }
+ return(0);
+}
+
+/* decode vector / dim granularity gaurding is done in the upper layer */
+long vorbis_book_decodev_add(codebook *book,float *a,oggpack_buffer *b,int n){
+ if(book->used_entries>0){
+ int i,j,entry;
+ float *t;
+
+ if(book->dim>8){
+ for(i=0;i<n;){
+ entry = decode_packed_entry_number(book,b);
+ if(entry==-1)return(-1);
+ t = book->valuelist+entry*book->dim;
+ for (j=0;j<book->dim;)
+ a[i++]+=t[j++];
+ }
+ }else{
+ for(i=0;i<n;){
+ entry = decode_packed_entry_number(book,b);
+ if(entry==-1)return(-1);
+ t = book->valuelist+entry*book->dim;
+ j=0;
+ switch((int)book->dim){
+ case 8:
+ a[i++]+=t[j++];
+ case 7:
+ a[i++]+=t[j++];
+ case 6:
+ a[i++]+=t[j++];
+ case 5:
+ a[i++]+=t[j++];
+ case 4:
+ a[i++]+=t[j++];
+ case 3:
+ a[i++]+=t[j++];
+ case 2:
+ a[i++]+=t[j++];
+ case 1:
+ a[i++]+=t[j++];
+ case 0:
+ break;
+ }
+ }
+ }
+ }
+ return(0);
+}
+
+/* unlike the others, we guard against n not being an integer number
+ of <dim> internally rather than in the upper layer (called only by
+ floor0) */
+long vorbis_book_decodev_set(codebook *book,float *a,oggpack_buffer *b,int n){
+ if(book->used_entries>0){
+ int i,j,entry;
+ float *t;
+
+ for(i=0;i<n;){
+ entry = decode_packed_entry_number(book,b);
+ if(entry==-1)return(-1);
+ t = book->valuelist+entry*book->dim;
+ for (j=0;i<n && j<book->dim;){
+ a[i++]=t[j++];
+ }
+ }
+ }else{
+ int i;
+
+ for(i=0;i<n;){
+ a[i++]=0.f;
+ }
+ }
+ return(0);
+}
+
+long vorbis_book_decodevv_add(codebook *book,float **a,long offset,int ch,
+ oggpack_buffer *b,int n){
+
+ long i,j,entry;
+ int chptr=0;
+ if(book->used_entries>0){
+ for(i=offset/ch;i<(offset+n)/ch;){
+ entry = decode_packed_entry_number(book,b);
+ if(entry==-1)return(-1);
+ {
+ const float *t = book->valuelist+entry*book->dim;
+ for (j=0;j<book->dim;j++){
+ a[chptr++][i]+=t[j];
+ if(chptr==ch){
+ chptr=0;
+ i++;
+ }
+ }
+ }
+ }
+ }
+ return(0);
+}
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: basic shared codebook operations
+ last mod: $Id: codebook.h 17030 2010-03-25 06:52:55Z xiphmont $
+
+ ********************************************************************/
+
+#ifndef _V_CODEBOOK_H_
+#define _V_CODEBOOK_H_
+
+#include <ogg/ogg.h>
+
+/* This structure encapsulates huffman and VQ style encoding books; it
+ doesn't do anything specific to either.
+
+ valuelist/quantlist are nonNULL (and q_* significant) only if
+ there's entry->value mapping to be done.
+
+ If encode-side mapping must be done (and thus the entry needs to be
+ hunted), the auxiliary encode pointer will point to a decision
+ tree. This is true of both VQ and huffman, but is mostly useful
+ with VQ.
+
+*/
+
+typedef struct static_codebook{
+ long dim; /* codebook dimensions (elements per vector) */
+ long entries; /* codebook entries */
+ long *lengthlist; /* codeword lengths in bits */
+
+ /* mapping ***************************************************************/
+ int maptype; /* 0=none
+ 1=implicitly populated values from map column
+ 2=listed arbitrary values */
+
+ /* The below does a linear, single monotonic sequence mapping. */
+ long q_min; /* packed 32 bit float; quant value 0 maps to minval */
+ long q_delta; /* packed 32 bit float; val 1 - val 0 == delta */
+ int q_quant; /* bits: 0 < quant <= 16 */
+ int q_sequencep; /* bitflag */
+
+ long *quantlist; /* map == 1: (int)(entries^(1/dim)) element column map
+ map == 2: list of dim*entries quantized entry vals
+ */
+ int allocedp;
+} static_codebook;
+
+typedef struct codebook{
+ long dim; /* codebook dimensions (elements per vector) */
+ long entries; /* codebook entries */
+ long used_entries; /* populated codebook entries */
+ const static_codebook *c;
+
+ /* for encode, the below are entry-ordered, fully populated */
+ /* for decode, the below are ordered by bitreversed codeword and only
+ used entries are populated */
+ float *valuelist; /* list of dim*entries actual entry values */
+ ogg_uint32_t *codelist; /* list of bitstream codewords for each entry */
+
+ int *dec_index; /* only used if sparseness collapsed */
+ char *dec_codelengths;
+ ogg_uint32_t *dec_firsttable;
+ int dec_firsttablen;
+ int dec_maxlength;
+
+ /* The current encoder uses only centered, integer-only lattice books. */
+ int quantvals;
+ int minval;
+ int delta;
+} codebook;
+
+extern void vorbis_staticbook_destroy(static_codebook *b);
+extern int vorbis_book_init_encode(codebook *dest,const static_codebook *source);
+extern int vorbis_book_init_decode(codebook *dest,const static_codebook *source);
+extern void vorbis_book_clear(codebook *b);
+
+extern float *_book_unquantize(const static_codebook *b,int n,int *map);
+extern float *_book_logdist(const static_codebook *b,float *vals);
+extern float _float32_unpack(long val);
+extern long _float32_pack(float val);
+extern int _best(codebook *book, float *a, int step);
+extern int _ilog(unsigned int v);
+extern long _book_maptype1_quantvals(const static_codebook *b);
+
+extern int vorbis_book_besterror(codebook *book,float *a,int step,int addmul);
+extern long vorbis_book_codeword(codebook *book,int entry);
+extern long vorbis_book_codelen(codebook *book,int entry);
+
+
+
+extern int vorbis_staticbook_pack(const static_codebook *c,oggpack_buffer *b);
+extern static_codebook *vorbis_staticbook_unpack(oggpack_buffer *b);
+
+extern int vorbis_book_encode(codebook *book, int a, oggpack_buffer *b);
+
+extern long vorbis_book_decode(codebook *book, oggpack_buffer *b);
+extern long vorbis_book_decodevs_add(codebook *book, float *a,
+ oggpack_buffer *b,int n);
+extern long vorbis_book_decodev_set(codebook *book, float *a,
+ oggpack_buffer *b,int n);
+extern long vorbis_book_decodev_add(codebook *book, float *a,
+ oggpack_buffer *b,int n);
+extern long vorbis_book_decodevv_add(codebook *book, float **a,
+ long off,int ch,
+ oggpack_buffer *b,int n);
+
+
+
+#endif
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2001 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+
+ ********************************************************************
+
+ function: libvorbis codec headers
+ last mod: $Id: codec.h 17021 2010-03-24 09:29:41Z xiphmont $
+
+ ********************************************************************/
+
+#ifndef _vorbis_codec_h_
+#define _vorbis_codec_h_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+#include <ogg/ogg.h>
+
+typedef struct vorbis_info{
+ int version;
+ int channels;
+ long rate;
+
+ /* The below bitrate declarations are *hints*.
+ Combinations of the three values carry the following implications:
+
+ all three set to the same value:
+ implies a fixed rate bitstream
+ only nominal set:
+ implies a VBR stream that averages the nominal bitrate. No hard
+ upper/lower limit
+ upper and or lower set:
+ implies a VBR bitstream that obeys the bitrate limits. nominal
+ may also be set to give a nominal rate.
+ none set:
+ the coder does not care to speculate.
+ */
+
+ long bitrate_upper;
+ long bitrate_nominal;
+ long bitrate_lower;
+ long bitrate_window;
+
+ void *codec_setup;
+} vorbis_info;
+
+/* vorbis_dsp_state buffers the current vorbis audio
+ analysis/synthesis state. The DSP state belongs to a specific
+ logical bitstream ****************************************************/
+typedef struct vorbis_dsp_state{
+ int analysisp;
+ vorbis_info *vi;
+
+ float **pcm;
+ float **pcmret;
+ int pcm_storage;
+ int pcm_current;
+ int pcm_returned;
+
+ int preextrapolate;
+ int eofflag;
+
+ long lW;
+ long W;
+ long nW;
+ long centerW;
+
+ ogg_int64_t granulepos;
+ ogg_int64_t sequence;
+
+ ogg_int64_t glue_bits;
+ ogg_int64_t time_bits;
+ ogg_int64_t floor_bits;
+ ogg_int64_t res_bits;
+
+ void *backend_state;
+} vorbis_dsp_state;
+
+typedef struct vorbis_block{
+ /* necessary stream state for linking to the framing abstraction */
+ float **pcm; /* this is a pointer into local storage */
+ oggpack_buffer opb;
+
+ long lW;
+ long W;
+ long nW;
+ int pcmend;
+ int mode;
+
+ int eofflag;
+ ogg_int64_t granulepos;
+ ogg_int64_t sequence;
+ vorbis_dsp_state *vd; /* For read-only access of configuration */
+
+ /* local storage to avoid remallocing; it's up to the mapping to
+ structure it */
+ void *localstore;
+ long localtop;
+ long localalloc;
+ long totaluse;
+ struct alloc_chain *reap;
+
+ /* bitmetrics for the frame */
+ long glue_bits;
+ long time_bits;
+ long floor_bits;
+ long res_bits;
+
+ void *internal;
+
+} vorbis_block;
+
+/* vorbis_block is a single block of data to be processed as part of
+the analysis/synthesis stream; it belongs to a specific logical
+bitstream, but is independent from other vorbis_blocks belonging to
+that logical bitstream. *************************************************/
+
+struct alloc_chain{
+ void *ptr;
+ struct alloc_chain *next;
+};
+
+/* vorbis_info contains all the setup information specific to the
+ specific compression/decompression mode in progress (eg,
+ psychoacoustic settings, channel setup, options, codebook
+ etc). vorbis_info and substructures are in backends.h.
+*********************************************************************/
+
+/* the comments are not part of vorbis_info so that vorbis_info can be
+ static storage */
+typedef struct vorbis_comment{
+ /* unlimited user comment fields. libvorbis writes 'libvorbis'
+ whatever vendor is set to in encode */
+ char **user_comments;
+ int *comment_lengths;
+ int comments;
+ char *vendor;
+
+} vorbis_comment;
+
+
+/* libvorbis encodes in two abstraction layers; first we perform DSP
+ and produce a packet (see docs/analysis.txt). The packet is then
+ coded into a framed OggSquish bitstream by the second layer (see
+ docs/framing.txt). Decode is the reverse process; we sync/frame
+ the bitstream and extract individual packets, then decode the
+ packet back into PCM audio.
+
+ The extra framing/packetizing is used in streaming formats, such as
+ files. Over the net (such as with UDP), the framing and
+ packetization aren't necessary as they're provided by the transport
+ and the streaming layer is not used */
+
+/* Vorbis PRIMITIVES: general ***************************************/
+
+extern void vorbis_info_init(vorbis_info *vi);
+extern void vorbis_info_clear(vorbis_info *vi);
+extern int vorbis_info_blocksize(vorbis_info *vi,int zo);
+extern void vorbis_comment_init(vorbis_comment *vc);
+extern void vorbis_comment_add(vorbis_comment *vc, const char *comment);
+extern void vorbis_comment_add_tag(vorbis_comment *vc,
+ const char *tag, const char *contents);
+extern char *vorbis_comment_query(vorbis_comment *vc, const char *tag, int count);
+extern int vorbis_comment_query_count(vorbis_comment *vc, const char *tag);
+extern void vorbis_comment_clear(vorbis_comment *vc);
+
+extern int vorbis_block_init(vorbis_dsp_state *v, vorbis_block *vb);
+extern int vorbis_block_clear(vorbis_block *vb);
+extern void vorbis_dsp_clear(vorbis_dsp_state *v);
+extern double vorbis_granule_time(vorbis_dsp_state *v,
+ ogg_int64_t granulepos);
+
+extern const char *vorbis_version_string(void);
+
+/* Vorbis PRIMITIVES: analysis/DSP layer ****************************/
+
+extern int vorbis_analysis_init(vorbis_dsp_state *v,vorbis_info *vi);
+extern int vorbis_commentheader_out(vorbis_comment *vc, ogg_packet *op);
+extern int vorbis_analysis_headerout(vorbis_dsp_state *v,
+ vorbis_comment *vc,
+ ogg_packet *op,
+ ogg_packet *op_comm,
+ ogg_packet *op_code);
+extern float **vorbis_analysis_buffer(vorbis_dsp_state *v,int vals);
+extern int vorbis_analysis_wrote(vorbis_dsp_state *v,int vals);
+extern int vorbis_analysis_blockout(vorbis_dsp_state *v,vorbis_block *vb);
+extern int vorbis_analysis(vorbis_block *vb,ogg_packet *op);
+
+extern int vorbis_bitrate_addblock(vorbis_block *vb);
+extern int vorbis_bitrate_flushpacket(vorbis_dsp_state *vd,
+ ogg_packet *op);
+
+/* Vorbis PRIMITIVES: synthesis layer *******************************/
+extern int vorbis_synthesis_idheader(ogg_packet *op);
+extern int vorbis_synthesis_headerin(vorbis_info *vi,vorbis_comment *vc,
+ ogg_packet *op);
+
+extern int vorbis_synthesis_init(vorbis_dsp_state *v,vorbis_info *vi);
+extern int vorbis_synthesis_restart(vorbis_dsp_state *v);
+extern int vorbis_synthesis(vorbis_block *vb,ogg_packet *op);
+extern int vorbis_synthesis_trackonly(vorbis_block *vb,ogg_packet *op);
+extern int vorbis_synthesis_blockin(vorbis_dsp_state *v,vorbis_block *vb);
+extern int vorbis_synthesis_pcmout(vorbis_dsp_state *v,float ***pcm);
+extern int vorbis_synthesis_lapout(vorbis_dsp_state *v,float ***pcm);
+extern int vorbis_synthesis_read(vorbis_dsp_state *v,int samples);
+extern long vorbis_packet_blocksize(vorbis_info *vi,ogg_packet *op);
+
+extern int vorbis_synthesis_halfrate(vorbis_info *v,int flag);
+extern int vorbis_synthesis_halfrate_p(vorbis_info *v);
+
+/* Vorbis ERRORS and return codes ***********************************/
+
+#define OV_FALSE -1
+#define OV_EOF -2
+#define OV_HOLE -3
+
+#define OV_EREAD -128
+#define OV_EFAULT -129
+#define OV_EIMPL -130
+#define OV_EINVAL -131
+#define OV_ENOTVORBIS -132
+#define OV_EBADHEADER -133
+#define OV_EVERSION -134
+#define OV_ENOTAUDIO -135
+#define OV_EBADPACKET -136
+#define OV_EBADLINK -137
+#define OV_ENOSEEK -138
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif
+
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: libvorbis codec headers
+ last mod: $Id: codec_internal.h 16227 2009-07-08 06:58:46Z xiphmont $
+
+ ********************************************************************/
+
+#ifndef _V_CODECI_H_
+#define _V_CODECI_H_
+
+#include "envelope.h"
+#include "codebook.h"
+
+#define BLOCKTYPE_IMPULSE 0
+#define BLOCKTYPE_PADDING 1
+#define BLOCKTYPE_TRANSITION 0
+#define BLOCKTYPE_LONG 1
+
+#define PACKETBLOBS 15
+
+typedef struct vorbis_block_internal{
+ float **pcmdelay; /* this is a pointer into local storage */
+ float ampmax;
+ int blocktype;
+
+ oggpack_buffer *packetblob[PACKETBLOBS]; /* initialized, must be freed;
+ blob [PACKETBLOBS/2] points to
+ the oggpack_buffer in the
+ main vorbis_block */
+} vorbis_block_internal;
+
+typedef void vorbis_look_floor;
+typedef void vorbis_look_residue;
+typedef void vorbis_look_transform;
+
+/* mode ************************************************************/
+typedef struct {
+ int blockflag;
+ int windowtype;
+ int transformtype;
+ int mapping;
+} vorbis_info_mode;
+
+typedef void vorbis_info_floor;
+typedef void vorbis_info_residue;
+typedef void vorbis_info_mapping;
+
+#include "psy.h"
+#include "bitrate.h"
+
+typedef struct private_state {
+ /* local lookup storage */
+ envelope_lookup *ve; /* envelope lookup */
+ int window[2];
+ vorbis_look_transform **transform[2]; /* block, type */
+ drft_lookup fft_look[2];
+
+ int modebits;
+ vorbis_look_floor **flr;
+ vorbis_look_residue **residue;
+ vorbis_look_psy *psy;
+ vorbis_look_psy_global *psy_g_look;
+
+ /* local storage, only used on the encoding side. This way the
+ application does not need to worry about freeing some packets'
+ memory and not others'; packet storage is always tracked.
+ Cleared next call to a _dsp_ function */
+ unsigned char *header;
+ unsigned char *header1;
+ unsigned char *header2;
+
+ bitrate_manager_state bms;
+
+ ogg_int64_t sample_count;
+} private_state;
+
+/* codec_setup_info contains all the setup information specific to the
+ specific compression/decompression mode in progress (eg,
+ psychoacoustic settings, channel setup, options, codebook
+ etc).
+*********************************************************************/
+
+#include "highlevel.h"
+typedef struct codec_setup_info {
+
+ /* Vorbis supports only short and long blocks, but allows the
+ encoder to choose the sizes */
+
+ long blocksizes[2];
+
+ /* modes are the primary means of supporting on-the-fly different
+ blocksizes, different channel mappings (LR or M/A),
+ different residue backends, etc. Each mode consists of a
+ blocksize flag and a mapping (along with the mapping setup */
+
+ int modes;
+ int maps;
+ int floors;
+ int residues;
+ int books;
+ int psys; /* encode only */
+
+ vorbis_info_mode *mode_param[64];
+ int map_type[64];
+ vorbis_info_mapping *map_param[64];
+ int floor_type[64];
+ vorbis_info_floor *floor_param[64];
+ int residue_type[64];
+ vorbis_info_residue *residue_param[64];
+ static_codebook *book_param[256];
+ codebook *fullbooks;
+
+ vorbis_info_psy *psy_param[4]; /* encode only */
+ vorbis_info_psy_global psy_g_param;
+
+ bitrate_manager_info bi;
+ highlevel_encode_setup hi; /* used only by vorbisenc.c. It's a
+ highly redundant structure, but
+ improves clarity of program flow. */
+ int halfrate_flag; /* painless downsample for decode */
+} codec_setup_info;
+
+extern vorbis_look_psy_global *_vp_global_look(vorbis_info *vi);
+extern void _vp_global_free(vorbis_look_psy_global *look);
+
+
+
+typedef struct {
+ int sorted_index[VIF_POSIT+2];
+ int forward_index[VIF_POSIT+2];
+ int reverse_index[VIF_POSIT+2];
+
+ int hineighbor[VIF_POSIT];
+ int loneighbor[VIF_POSIT];
+ int posts;
+
+ int n;
+ int quant_q;
+ vorbis_info_floor1 *vi;
+
+ long phrasebits;
+ long postbits;
+ long frames;
+} vorbis_look_floor1;
+
+
+
+extern int *floor1_fit(vorbis_block *vb,vorbis_look_floor1 *look,
+ const float *logmdct, /* in */
+ const float *logmask);
+extern int *floor1_interpolate_fit(vorbis_block *vb,vorbis_look_floor1 *look,
+ int *A,int *B,
+ int del);
+extern int floor1_encode(oggpack_buffer *opb,vorbis_block *vb,
+ vorbis_look_floor1 *look,
+ int *post,int *ilogmask);
+#endif
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: PCM data envelope analysis
+ last mod: $Id: envelope.c 16227 2009-07-08 06:58:46Z xiphmont $
+
+ ********************************************************************/
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <math.h>
+#include <ogg/ogg.h>
+#include "vorbis/codec.h"
+#include "codec_internal.h"
+
+#include "os.h"
+#include "scales.h"
+#include "envelope.h"
+#include "mdct.h"
+#include "misc.h"
+
+void _ve_envelope_init(envelope_lookup *e,vorbis_info *vi){
+ codec_setup_info *ci=vi->codec_setup;
+ vorbis_info_psy_global *gi=&ci->psy_g_param;
+ int ch=vi->channels;
+ int i,j;
+ int n=e->winlength=128;
+ e->searchstep=64; /* not random */
+
+ e->minenergy=gi->preecho_minenergy;
+ e->ch=ch;
+ e->storage=128;
+ e->cursor=ci->blocksizes[1]/2;
+ e->mdct_win=_ogg_calloc(n,sizeof(*e->mdct_win));
+ mdct_init(&e->mdct,n);
+
+ for(i=0;i<n;i++){
+ e->mdct_win[i]=sin(i/(n-1.)*M_PI);
+ e->mdct_win[i]*=e->mdct_win[i];
+ }
+
+ /* magic follows */
+ e->band[0].begin=2; e->band[0].end=4;
+ e->band[1].begin=4; e->band[1].end=5;
+ e->band[2].begin=6; e->band[2].end=6;
+ e->band[3].begin=9; e->band[3].end=8;
+ e->band[4].begin=13; e->band[4].end=8;
+ e->band[5].begin=17; e->band[5].end=8;
+ e->band[6].begin=22; e->band[6].end=8;
+
+ for(j=0;j<VE_BANDS;j++){
+ n=e->band[j].end;
+ e->band[j].window=_ogg_malloc(n*sizeof(*e->band[0].window));
+ for(i=0;i<n;i++){
+ e->band[j].window[i]=sin((i+.5)/n*M_PI);
+ e->band[j].total+=e->band[j].window[i];
+ }
+ e->band[j].total=1./e->band[j].total;
+ }
+
+ e->filter=_ogg_calloc(VE_BANDS*ch,sizeof(*e->filter));
+ e->mark=_ogg_calloc(e->storage,sizeof(*e->mark));
+
+}
+
+void _ve_envelope_clear(envelope_lookup *e){
+ int i;
+ mdct_clear(&e->mdct);
+ for(i=0;i<VE_BANDS;i++)
+ _ogg_free(e->band[i].window);
+ _ogg_free(e->mdct_win);
+ _ogg_free(e->filter);
+ _ogg_free(e->mark);
+ memset(e,0,sizeof(*e));
+}
+
+/* fairly straight threshhold-by-band based until we find something
+ that works better and isn't patented. */
+
+static int _ve_amp(envelope_lookup *ve,
+ vorbis_info_psy_global *gi,
+ float *data,
+ envelope_band *bands,
+ envelope_filter_state *filters){
+ long n=ve->winlength;
+ int ret=0;
+ long i,j;
+ float decay;
+
+ /* we want to have a 'minimum bar' for energy, else we're just
+ basing blocks on quantization noise that outweighs the signal
+ itself (for low power signals) */
+
+ float minV=ve->minenergy;
+ float *vec=alloca(n*sizeof(*vec));
+
+ /* stretch is used to gradually lengthen the number of windows
+ considered prevoius-to-potential-trigger */
+ int stretch=max(VE_MINSTRETCH,ve->stretch/2);
+ float penalty=gi->stretch_penalty-(ve->stretch/2-VE_MINSTRETCH);
+ if(penalty<0.f)penalty=0.f;
+ if(penalty>gi->stretch_penalty)penalty=gi->stretch_penalty;
+
+ /*_analysis_output_always("lpcm",seq2,data,n,0,0,
+ totalshift+pos*ve->searchstep);*/
+
+ /* window and transform */
+ for(i=0;i<n;i++)
+ vec[i]=data[i]*ve->mdct_win[i];
+ mdct_forward(&ve->mdct,vec,vec);
+
+ /*_analysis_output_always("mdct",seq2,vec,n/2,0,1,0); */
+
+ /* near-DC spreading function; this has nothing to do with
+ psychoacoustics, just sidelobe leakage and window size */
+ {
+ float temp=vec[0]*vec[0]+.7*vec[1]*vec[1]+.2*vec[2]*vec[2];
+ int ptr=filters->nearptr;
+
+ /* the accumulation is regularly refreshed from scratch to avoid
+ floating point creep */
+ if(ptr==0){
+ decay=filters->nearDC_acc=filters->nearDC_partialacc+temp;
+ filters->nearDC_partialacc=temp;
+ }else{
+ decay=filters->nearDC_acc+=temp;
+ filters->nearDC_partialacc+=temp;
+ }
+ filters->nearDC_acc-=filters->nearDC[ptr];
+ filters->nearDC[ptr]=temp;
+
+ decay*=(1./(VE_NEARDC+1));
+ filters->nearptr++;
+ if(filters->nearptr>=VE_NEARDC)filters->nearptr=0;
+ decay=todB(&decay)*.5-15.f;
+ }
+
+ /* perform spreading and limiting, also smooth the spectrum. yes,
+ the MDCT results in all real coefficients, but it still *behaves*
+ like real/imaginary pairs */
+ for(i=0;i<n/2;i+=2){
+ float val=vec[i]*vec[i]+vec[i+1]*vec[i+1];
+ val=todB(&val)*.5f;
+ if(val<decay)val=decay;
+ if(val<minV)val=minV;
+ vec[i>>1]=val;
+ decay-=8.;
+ }
+
+ /*_analysis_output_always("spread",seq2++,vec,n/4,0,0,0);*/
+
+ /* perform preecho/postecho triggering by band */
+ for(j=0;j<VE_BANDS;j++){
+ float acc=0.;
+ float valmax,valmin;
+
+ /* accumulate amplitude */
+ for(i=0;i<bands[j].end;i++)
+ acc+=vec[i+bands[j].begin]*bands[j].window[i];
+
+ acc*=bands[j].total;
+
+ /* convert amplitude to delta */
+ {
+ int p,this=filters[j].ampptr;
+ float postmax,postmin,premax=-99999.f,premin=99999.f;
+
+ p=this;
+ p--;
+ if(p<0)p+=VE_AMP;
+ postmax=max(acc,filters[j].ampbuf[p]);
+ postmin=min(acc,filters[j].ampbuf[p]);
+
+ for(i=0;i<stretch;i++){
+ p--;
+ if(p<0)p+=VE_AMP;
+ premax=max(premax,filters[j].ampbuf[p]);
+ premin=min(premin,filters[j].ampbuf[p]);
+ }
+
+ valmin=postmin-premin;
+ valmax=postmax-premax;
+
+ /*filters[j].markers[pos]=valmax;*/
+ filters[j].ampbuf[this]=acc;
+ filters[j].ampptr++;
+ if(filters[j].ampptr>=VE_AMP)filters[j].ampptr=0;
+ }
+
+ /* look at min/max, decide trigger */
+ if(valmax>gi->preecho_thresh[j]+penalty){
+ ret|=1;
+ ret|=4;
+ }
+ if(valmin<gi->postecho_thresh[j]-penalty)ret|=2;
+ }
+
+ return(ret);
+}
+
+#if 0
+static int seq=0;
+static ogg_int64_t totalshift=-1024;
+#endif
+
+long _ve_envelope_search(vorbis_dsp_state *v){
+ vorbis_info *vi=v->vi;
+ codec_setup_info *ci=vi->codec_setup;
+ vorbis_info_psy_global *gi=&ci->psy_g_param;
+ envelope_lookup *ve=((private_state *)(v->backend_state))->ve;
+ long i,j;
+
+ int first=ve->current/ve->searchstep;
+ int last=v->pcm_current/ve->searchstep-VE_WIN;
+ if(first<0)first=0;
+
+ /* make sure we have enough storage to match the PCM */
+ if(last+VE_WIN+VE_POST>ve->storage){
+ ve->storage=last+VE_WIN+VE_POST; /* be sure */
+ ve->mark=_ogg_realloc(ve->mark,ve->storage*sizeof(*ve->mark));
+ }
+
+ for(j=first;j<last;j++){
+ int ret=0;
+
+ ve->stretch++;
+ if(ve->stretch>VE_MAXSTRETCH*2)
+ ve->stretch=VE_MAXSTRETCH*2;
+
+ for(i=0;i<ve->ch;i++){
+ float *pcm=v->pcm[i]+ve->searchstep*(j);
+ ret|=_ve_amp(ve,gi,pcm,ve->band,ve->filter+i*VE_BANDS);
+ }
+
+ ve->mark[j+VE_POST]=0;
+ if(ret&1){
+ ve->mark[j]=1;
+ ve->mark[j+1]=1;
+ }
+
+ if(ret&2){
+ ve->mark[j]=1;
+ if(j>0)ve->mark[j-1]=1;
+ }
+
+ if(ret&4)ve->stretch=-1;
+ }
+
+ ve->current=last*ve->searchstep;
+
+ {
+ long centerW=v->centerW;
+ long testW=
+ centerW+
+ ci->blocksizes[v->W]/4+
+ ci->blocksizes[1]/2+
+ ci->blocksizes[0]/4;
+
+ j=ve->cursor;
+
+ while(j<ve->current-(ve->searchstep)){/* account for postecho
+ working back one window */
+ if(j>=testW)return(1);
+
+ ve->cursor=j;
+
+ if(ve->mark[j/ve->searchstep]){
+ if(j>centerW){
+
+#if 0
+ if(j>ve->curmark){
+ float *marker=alloca(v->pcm_current*sizeof(*marker));
+ int l,m;
+ memset(marker,0,sizeof(*marker)*v->pcm_current);
+ fprintf(stderr,"mark! seq=%d, cursor:%fs time:%fs\n",
+ seq,
+ (totalshift+ve->cursor)/44100.,
+ (totalshift+j)/44100.);
+ _analysis_output_always("pcmL",seq,v->pcm[0],v->pcm_current,0,0,totalshift);
+ _analysis_output_always("pcmR",seq,v->pcm[1],v->pcm_current,0,0,totalshift);
+
+ _analysis_output_always("markL",seq,v->pcm[0],j,0,0,totalshift);
+ _analysis_output_always("markR",seq,v->pcm[1],j,0,0,totalshift);
+
+ for(m=0;m<VE_BANDS;m++){
+ char buf[80];
+ sprintf(buf,"delL%d",m);
+ for(l=0;l<last;l++)marker[l*ve->searchstep]=ve->filter[m].markers[l]*.1;
+ _analysis_output_always(buf,seq,marker,v->pcm_current,0,0,totalshift);
+ }
+
+ for(m=0;m<VE_BANDS;m++){
+ char buf[80];
+ sprintf(buf,"delR%d",m);
+ for(l=0;l<last;l++)marker[l*ve->searchstep]=ve->filter[m+VE_BANDS].markers[l]*.1;
+ _analysis_output_always(buf,seq,marker,v->pcm_current,0,0,totalshift);
+ }
+
+ for(l=0;l<last;l++)marker[l*ve->searchstep]=ve->mark[l]*.4;
+ _analysis_output_always("mark",seq,marker,v->pcm_current,0,0,totalshift);
+
+
+ seq++;
+
+ }
+#endif
+
+ ve->curmark=j;
+ if(j>=testW)return(1);
+ return(0);
+ }
+ }
+ j+=ve->searchstep;
+ }
+ }
+
+ return(-1);
+}
+
+int _ve_envelope_mark(vorbis_dsp_state *v){
+ envelope_lookup *ve=((private_state *)(v->backend_state))->ve;
+ vorbis_info *vi=v->vi;
+ codec_setup_info *ci=vi->codec_setup;
+ long centerW=v->centerW;
+ long beginW=centerW-ci->blocksizes[v->W]/4;
+ long endW=centerW+ci->blocksizes[v->W]/4;
+ if(v->W){
+ beginW-=ci->blocksizes[v->lW]/4;
+ endW+=ci->blocksizes[v->nW]/4;
+ }else{
+ beginW-=ci->blocksizes[0]/4;
+ endW+=ci->blocksizes[0]/4;
+ }
+
+ if(ve->curmark>=beginW && ve->curmark<endW)return(1);
+ {
+ long first=beginW/ve->searchstep;
+ long last=endW/ve->searchstep;
+ long i;
+ for(i=first;i<last;i++)
+ if(ve->mark[i])return(1);
+ }
+ return(0);
+}
+
+void _ve_envelope_shift(envelope_lookup *e,long shift){
+ int smallsize=e->current/e->searchstep+VE_POST; /* adjust for placing marks
+ ahead of ve->current */
+ int smallshift=shift/e->searchstep;
+
+ memmove(e->mark,e->mark+smallshift,(smallsize-smallshift)*sizeof(*e->mark));
+
+#if 0
+ for(i=0;i<VE_BANDS*e->ch;i++)
+ memmove(e->filter[i].markers,
+ e->filter[i].markers+smallshift,
+ (1024-smallshift)*sizeof(*(*e->filter).markers));
+ totalshift+=shift;
+#endif
+
+ e->current-=shift;
+ if(e->curmark>=0)
+ e->curmark-=shift;
+ e->cursor-=shift;
+}
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: PCM data envelope analysis and manipulation
+ last mod: $Id: envelope.h 16227 2009-07-08 06:58:46Z xiphmont $
+
+ ********************************************************************/
+
+#ifndef _V_ENVELOPE_
+#define _V_ENVELOPE_
+
+#include "mdct.h"
+
+#define VE_PRE 16
+#define VE_WIN 4
+#define VE_POST 2
+#define VE_AMP (VE_PRE+VE_POST-1)
+
+#define VE_BANDS 7
+#define VE_NEARDC 15
+
+#define VE_MINSTRETCH 2 /* a bit less than short block */
+#define VE_MAXSTRETCH 12 /* one-third full block */
+
+typedef struct {
+ float ampbuf[VE_AMP];
+ int ampptr;
+
+ float nearDC[VE_NEARDC];
+ float nearDC_acc;
+ float nearDC_partialacc;
+ int nearptr;
+
+} envelope_filter_state;
+
+typedef struct {
+ int begin;
+ int end;
+ float *window;
+ float total;
+} envelope_band;
+
+typedef struct {
+ int ch;
+ int winlength;
+ int searchstep;
+ float minenergy;
+
+ mdct_lookup mdct;
+ float *mdct_win;
+
+ envelope_band band[VE_BANDS];
+ envelope_filter_state *filter;
+ int stretch;
+
+ int *mark;
+
+ long storage;
+ long current;
+ long curmark;
+ long cursor;
+} envelope_lookup;
+
+extern void _ve_envelope_init(envelope_lookup *e,vorbis_info *vi);
+extern void _ve_envelope_clear(envelope_lookup *e);
+extern long _ve_envelope_search(vorbis_dsp_state *v);
+extern void _ve_envelope_shift(envelope_lookup *e,long shift);
+extern int _ve_envelope_mark(vorbis_dsp_state *v);
+
+
+#endif
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: floor backend 0 implementation
+ last mod: $Id: floor0.c 18184 2012-02-03 20:55:12Z xiphmont $
+
+ ********************************************************************/
+
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <ogg/ogg.h>
+#include "vorbis/codec.h"
+#include "codec_internal.h"
+#include "registry.h"
+#include "lpc.h"
+#include "lsp.h"
+#include "codebook.h"
+#include "scales.h"
+#include "misc.h"
+#include "os.h"
+
+#include "misc.h"
+#include <stdio.h>
+
+typedef struct {
+ int ln;
+ int m;
+ int **linearmap;
+ int n[2];
+
+ vorbis_info_floor0 *vi;
+
+ long bits;
+ long frames;
+} vorbis_look_floor0;
+
+
+/***********************************************/
+
+static void floor0_free_info(vorbis_info_floor *i){
+ vorbis_info_floor0 *info=(vorbis_info_floor0 *)i;
+ if(info){
+ memset(info,0,sizeof(*info));
+ _ogg_free(info);
+ }
+}
+
+static void floor0_free_look(vorbis_look_floor *i){
+ vorbis_look_floor0 *look=(vorbis_look_floor0 *)i;
+ if(look){
+
+ if(look->linearmap){
+
+ if(look->linearmap[0])_ogg_free(look->linearmap[0]);
+ if(look->linearmap[1])_ogg_free(look->linearmap[1]);
+
+ _ogg_free(look->linearmap);
+ }
+ memset(look,0,sizeof(*look));
+ _ogg_free(look);
+ }
+}
+
+static vorbis_info_floor *floor0_unpack (vorbis_info *vi,oggpack_buffer *opb){
+ codec_setup_info *ci=vi->codec_setup;
+ int j;
+
+ vorbis_info_floor0 *info=_ogg_malloc(sizeof(*info));
+ info->order=oggpack_read(opb,8);
+ info->rate=oggpack_read(opb,16);
+ info->barkmap=oggpack_read(opb,16);
+ info->ampbits=oggpack_read(opb,6);
+ info->ampdB=oggpack_read(opb,8);
+ info->numbooks=oggpack_read(opb,4)+1;
+
+ if(info->order<1)goto err_out;
+ if(info->rate<1)goto err_out;
+ if(info->barkmap<1)goto err_out;
+ if(info->numbooks<1)goto err_out;
+
+ for(j=0;j<info->numbooks;j++){
+ info->books[j]=oggpack_read(opb,8);
+ if(info->books[j]<0 || info->books[j]>=ci->books)goto err_out;
+ if(ci->book_param[info->books[j]]->maptype==0)goto err_out;
+ if(ci->book_param[info->books[j]]->dim<1)goto err_out;
+ }
+ return(info);
+
+ err_out:
+ floor0_free_info(info);
+ return(NULL);
+}
+
+/* initialize Bark scale and normalization lookups. We could do this
+ with static tables, but Vorbis allows a number of possible
+ combinations, so it's best to do it computationally.
+
+ The below is authoritative in terms of defining scale mapping.
+ Note that the scale depends on the sampling rate as well as the
+ linear block and mapping sizes */
+
+static void floor0_map_lazy_init(vorbis_block *vb,
+ vorbis_info_floor *infoX,
+ vorbis_look_floor0 *look){
+ if(!look->linearmap[vb->W]){
+ vorbis_dsp_state *vd=vb->vd;
+ vorbis_info *vi=vd->vi;
+ codec_setup_info *ci=vi->codec_setup;
+ vorbis_info_floor0 *info=(vorbis_info_floor0 *)infoX;
+ int W=vb->W;
+ int n=ci->blocksizes[W]/2,j;
+
+ /* we choose a scaling constant so that:
+ floor(bark(rate/2-1)*C)=mapped-1
+ floor(bark(rate/2)*C)=mapped */
+ float scale=look->ln/toBARK(info->rate/2.f);
+
+ /* the mapping from a linear scale to a smaller bark scale is
+ straightforward. We do *not* make sure that the linear mapping
+ does not skip bark-scale bins; the decoder simply skips them and
+ the encoder may do what it wishes in filling them. They're
+ necessary in some mapping combinations to keep the scale spacing
+ accurate */
+ look->linearmap[W]=_ogg_malloc((n+1)*sizeof(**look->linearmap));
+ for(j=0;j<n;j++){
+ int val=floor( toBARK((info->rate/2.f)/n*j)
+ *scale); /* bark numbers represent band edges */
+ if(val>=look->ln)val=look->ln-1; /* guard against the approximation */
+ look->linearmap[W][j]=val;
+ }
+ look->linearmap[W][j]=-1;
+ look->n[W]=n;
+ }
+}
+
+static vorbis_look_floor *floor0_look(vorbis_dsp_state *vd,
+ vorbis_info_floor *i){
+ vorbis_info_floor0 *info=(vorbis_info_floor0 *)i;
+ vorbis_look_floor0 *look=_ogg_calloc(1,sizeof(*look));
+ look->m=info->order;
+ look->ln=info->barkmap;
+ look->vi=info;
+
+ look->linearmap=_ogg_calloc(2,sizeof(*look->linearmap));
+
+ return look;
+}
+
+static void *floor0_inverse1(vorbis_block *vb,vorbis_look_floor *i){
+ vorbis_look_floor0 *look=(vorbis_look_floor0 *)i;
+ vorbis_info_floor0 *info=look->vi;
+ int j,k;
+
+ int ampraw=oggpack_read(&vb->opb,info->ampbits);
+ if(ampraw>0){ /* also handles the -1 out of data case */
+ long maxval=(1<<info->ampbits)-1;
+ float amp=(float)ampraw/maxval*info->ampdB;
+ int booknum=oggpack_read(&vb->opb,_ilog(info->numbooks));
+
+ if(booknum!=-1 && booknum<info->numbooks){ /* be paranoid */
+ codec_setup_info *ci=vb->vd->vi->codec_setup;
+ codebook *b=ci->fullbooks+info->books[booknum];
+ float last=0.f;
+
+ /* the additional b->dim is a guard against any possible stack
+ smash; b->dim is provably more than we can overflow the
+ vector */
+ float *lsp=_vorbis_block_alloc(vb,sizeof(*lsp)*(look->m+b->dim+1));
+
+ if(vorbis_book_decodev_set(b,lsp,&vb->opb,look->m)==-1)goto eop;
+ for(j=0;j<look->m;){
+ for(k=0;j<look->m && k<b->dim;k++,j++)lsp[j]+=last;
+ last=lsp[j-1];
+ }
+
+ lsp[look->m]=amp;
+ return(lsp);
+ }
+ }
+ eop:
+ return(NULL);
+}
+
+static int floor0_inverse2(vorbis_block *vb,vorbis_look_floor *i,
+ void *memo,float *out){
+ vorbis_look_floor0 *look=(vorbis_look_floor0 *)i;
+ vorbis_info_floor0 *info=look->vi;
+
+ floor0_map_lazy_init(vb,info,look);
+
+ if(memo){
+ float *lsp=(float *)memo;
+ float amp=lsp[look->m];
+
+ /* take the coefficients back to a spectral envelope curve */
+ vorbis_lsp_to_curve(out,
+ look->linearmap[vb->W],
+ look->n[vb->W],
+ look->ln,
+ lsp,look->m,amp,(float)info->ampdB);
+ return(1);
+ }
+ memset(out,0,sizeof(*out)*look->n[vb->W]);
+ return(0);
+}
+
+/* export hooks */
+const vorbis_func_floor floor0_exportbundle={
+ NULL,&floor0_unpack,&floor0_look,&floor0_free_info,
+ &floor0_free_look,&floor0_inverse1,&floor0_inverse2
+};
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: floor backend 1 implementation
+ last mod: $Id: floor1.c 18151 2012-01-20 07:35:26Z xiphmont $
+
+ ********************************************************************/
+
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <ogg/ogg.h>
+#include "vorbis/codec.h"
+#include "codec_internal.h"
+#include "registry.h"
+#include "codebook.h"
+#include "misc.h"
+#include "scales.h"
+
+#include <stdio.h>
+
+#define floor1_rangedB 140 /* floor 1 fixed at -140dB to 0dB range */
+
+typedef struct lsfit_acc{
+ int x0;
+ int x1;
+
+ int xa;
+ int ya;
+ int x2a;
+ int y2a;
+ int xya;
+ int an;
+
+ int xb;
+ int yb;
+ int x2b;
+ int y2b;
+ int xyb;
+ int bn;
+} lsfit_acc;
+
+/***********************************************/
+
+static void floor1_free_info(vorbis_info_floor *i){
+ vorbis_info_floor1 *info=(vorbis_info_floor1 *)i;
+ if(info){
+ memset(info,0,sizeof(*info));
+ _ogg_free(info);
+ }
+}
+
+static void floor1_free_look(vorbis_look_floor *i){
+ vorbis_look_floor1 *look=(vorbis_look_floor1 *)i;
+ if(look){
+ /*fprintf(stderr,"floor 1 bit usage %f:%f (%f total)\n",
+ (float)look->phrasebits/look->frames,
+ (float)look->postbits/look->frames,
+ (float)(look->postbits+look->phrasebits)/look->frames);*/
+
+ memset(look,0,sizeof(*look));
+ _ogg_free(look);
+ }
+}
+
+static int ilog(unsigned int v){
+ int ret=0;
+ while(v){
+ ret++;
+ v>>=1;
+ }
+ return(ret);
+}
+
+static int ilog2(unsigned int v){
+ int ret=0;
+ if(v)--v;
+ while(v){
+ ret++;
+ v>>=1;
+ }
+ return(ret);
+}
+
+static void floor1_pack (vorbis_info_floor *i,oggpack_buffer *opb){
+ vorbis_info_floor1 *info=(vorbis_info_floor1 *)i;
+ int j,k;
+ int count=0;
+ int rangebits;
+ int maxposit=info->postlist[1];
+ int maxclass=-1;
+
+ /* save out partitions */
+ oggpack_write(opb,info->partitions,5); /* only 0 to 31 legal */
+ for(j=0;j<info->partitions;j++){
+ oggpack_write(opb,info->partitionclass[j],4); /* only 0 to 15 legal */
+ if(maxclass<info->partitionclass[j])maxclass=info->partitionclass[j];
+ }
+
+ /* save out partition classes */
+ for(j=0;j<maxclass+1;j++){
+ oggpack_write(opb,info->class_dim[j]-1,3); /* 1 to 8 */
+ oggpack_write(opb,info->class_subs[j],2); /* 0 to 3 */
+ if(info->class_subs[j])oggpack_write(opb,info->class_book[j],8);
+ for(k=0;k<(1<<info->class_subs[j]);k++)
+ oggpack_write(opb,info->class_subbook[j][k]+1,8);
+ }
+
+ /* save out the post list */
+ oggpack_write(opb,info->mult-1,2); /* only 1,2,3,4 legal now */
+ oggpack_write(opb,ilog2(maxposit),4);
+ rangebits=ilog2(maxposit);
+
+ for(j=0,k=0;j<info->partitions;j++){
+ count+=info->class_dim[info->partitionclass[j]];
+ for(;k<count;k++)
+ oggpack_write(opb,info->postlist[k+2],rangebits);
+ }
+}
+
+static int icomp(const void *a,const void *b){
+ return(**(int **)a-**(int **)b);
+}
+
+static vorbis_info_floor *floor1_unpack (vorbis_info *vi,oggpack_buffer *opb){
+ codec_setup_info *ci=vi->codec_setup;
+ int j,k,count=0,maxclass=-1,rangebits;
+
+ vorbis_info_floor1 *info=_ogg_calloc(1,sizeof(*info));
+ /* read partitions */
+ info->partitions=oggpack_read(opb,5); /* only 0 to 31 legal */
+ for(j=0;j<info->partitions;j++){
+ info->partitionclass[j]=oggpack_read(opb,4); /* only 0 to 15 legal */
+ if(info->partitionclass[j]<0)goto err_out;
+ if(maxclass<info->partitionclass[j])maxclass=info->partitionclass[j];
+ }
+
+ /* read partition classes */
+ for(j=0;j<maxclass+1;j++){
+ info->class_dim[j]=oggpack_read(opb,3)+1; /* 1 to 8 */
+ info->class_subs[j]=oggpack_read(opb,2); /* 0,1,2,3 bits */
+ if(info->class_subs[j]<0)
+ goto err_out;
+ if(info->class_subs[j])info->class_book[j]=oggpack_read(opb,8);
+ if(info->class_book[j]<0 || info->class_book[j]>=ci->books)
+ goto err_out;
+ for(k=0;k<(1<<info->class_subs[j]);k++){
+ info->class_subbook[j][k]=oggpack_read(opb,8)-1;
+ if(info->class_subbook[j][k]<-1 || info->class_subbook[j][k]>=ci->books)
+ goto err_out;
+ }
+ }
+
+ /* read the post list */
+ info->mult=oggpack_read(opb,2)+1; /* only 1,2,3,4 legal now */
+ rangebits=oggpack_read(opb,4);
+ if(rangebits<0)goto err_out;
+
+ for(j=0,k=0;j<info->partitions;j++){
+ count+=info->class_dim[info->partitionclass[j]];
+ if(count>VIF_POSIT) goto err_out;
+ for(;k<count;k++){
+ int t=info->postlist[k+2]=oggpack_read(opb,rangebits);
+ if(t<0 || t>=(1<<rangebits))
+ goto err_out;
+ }
+ }
+ info->postlist[0]=0;
+ info->postlist[1]=1<<rangebits;
+
+ /* don't allow repeated values in post list as they'd result in
+ zero-length segments */
+ {
+ int *sortpointer[VIF_POSIT+2];
+ for(j=0;j<count+2;j++)sortpointer[j]=info->postlist+j;
+ qsort(sortpointer,count+2,sizeof(*sortpointer),icomp);
+
+ for(j=1;j<count+2;j++)
+ if(*sortpointer[j-1]==*sortpointer[j])goto err_out;
+ }
+
+ return(info);
+
+ err_out:
+ floor1_free_info(info);
+ return(NULL);
+}
+
+static vorbis_look_floor *floor1_look(vorbis_dsp_state *vd,
+ vorbis_info_floor *in){
+
+ int *sortpointer[VIF_POSIT+2];
+ vorbis_info_floor1 *info=(vorbis_info_floor1 *)in;
+ vorbis_look_floor1 *look=_ogg_calloc(1,sizeof(*look));
+ int i,j,n=0;
+
+ look->vi=info;
+ look->n=info->postlist[1];
+
+ /* we drop each position value in-between already decoded values,
+ and use linear interpolation to predict each new value past the
+ edges. The positions are read in the order of the position
+ list... we precompute the bounding positions in the lookup. Of
+ course, the neighbors can change (if a position is declined), but
+ this is an initial mapping */
+
+ for(i=0;i<info->partitions;i++)n+=info->class_dim[info->partitionclass[i]];
+ n+=2;
+ look->posts=n;
+
+ /* also store a sorted position index */
+ for(i=0;i<n;i++)sortpointer[i]=info->postlist+i;
+ qsort(sortpointer,n,sizeof(*sortpointer),icomp);
+
+ /* points from sort order back to range number */
+ for(i=0;i<n;i++)look->forward_index[i]=sortpointer[i]-info->postlist;
+ /* points from range order to sorted position */
+ for(i=0;i<n;i++)look->reverse_index[look->forward_index[i]]=i;
+ /* we actually need the post values too */
+ for(i=0;i<n;i++)look->sorted_index[i]=info->postlist[look->forward_index[i]];
+
+ /* quantize values to multiplier spec */
+ switch(info->mult){
+ case 1: /* 1024 -> 256 */
+ look->quant_q=256;
+ break;
+ case 2: /* 1024 -> 128 */
+ look->quant_q=128;
+ break;
+ case 3: /* 1024 -> 86 */
+ look->quant_q=86;
+ break;
+ case 4: /* 1024 -> 64 */
+ look->quant_q=64;
+ break;
+ }
+
+ /* discover our neighbors for decode where we don't use fit flags
+ (that would push the neighbors outward) */
+ for(i=0;i<n-2;i++){
+ int lo=0;
+ int hi=1;
+ int lx=0;
+ int hx=look->n;
+ int currentx=info->postlist[i+2];
+ for(j=0;j<i+2;j++){
+ int x=info->postlist[j];
+ if(x>lx && x<currentx){
+ lo=j;
+ lx=x;
+ }
+ if(x<hx && x>currentx){
+ hi=j;
+ hx=x;
+ }
+ }
+ look->loneighbor[i]=lo;
+ look->hineighbor[i]=hi;
+ }
+
+ return(look);
+}
+
+static int render_point(int x0,int x1,int y0,int y1,int x){
+ y0&=0x7fff; /* mask off flag */
+ y1&=0x7fff;
+
+ {
+ int dy=y1-y0;
+ int adx=x1-x0;
+ int ady=abs(dy);
+ int err=ady*(x-x0);
+
+ int off=err/adx;
+ if(dy<0)return(y0-off);
+ return(y0+off);
+ }
+}
+
+static int vorbis_dBquant(const float *x){
+ int i= *x*7.3142857f+1023.5f;
+ if(i>1023)return(1023);
+ if(i<0)return(0);
+ return i;
+}
+
+static const float FLOOR1_fromdB_LOOKUP[256]={
+ 1.0649863e-07F, 1.1341951e-07F, 1.2079015e-07F, 1.2863978e-07F,
+ 1.3699951e-07F, 1.4590251e-07F, 1.5538408e-07F, 1.6548181e-07F,
+ 1.7623575e-07F, 1.8768855e-07F, 1.9988561e-07F, 2.128753e-07F,
+ 2.2670913e-07F, 2.4144197e-07F, 2.5713223e-07F, 2.7384213e-07F,
+ 2.9163793e-07F, 3.1059021e-07F, 3.3077411e-07F, 3.5226968e-07F,
+ 3.7516214e-07F, 3.9954229e-07F, 4.2550680e-07F, 4.5315863e-07F,
+ 4.8260743e-07F, 5.1396998e-07F, 5.4737065e-07F, 5.8294187e-07F,
+ 6.2082472e-07F, 6.6116941e-07F, 7.0413592e-07F, 7.4989464e-07F,
+ 7.9862701e-07F, 8.5052630e-07F, 9.0579828e-07F, 9.6466216e-07F,
+ 1.0273513e-06F, 1.0941144e-06F, 1.1652161e-06F, 1.2409384e-06F,
+ 1.3215816e-06F, 1.4074654e-06F, 1.4989305e-06F, 1.5963394e-06F,
+ 1.7000785e-06F, 1.8105592e-06F, 1.9282195e-06F, 2.0535261e-06F,
+ 2.1869758e-06F, 2.3290978e-06F, 2.4804557e-06F, 2.6416497e-06F,
+ 2.8133190e-06F, 2.9961443e-06F, 3.1908506e-06F, 3.3982101e-06F,
+ 3.6190449e-06F, 3.8542308e-06F, 4.1047004e-06F, 4.3714470e-06F,
+ 4.6555282e-06F, 4.9580707e-06F, 5.2802740e-06F, 5.6234160e-06F,
+ 5.9888572e-06F, 6.3780469e-06F, 6.7925283e-06F, 7.2339451e-06F,
+ 7.7040476e-06F, 8.2047000e-06F, 8.7378876e-06F, 9.3057248e-06F,
+ 9.9104632e-06F, 1.0554501e-05F, 1.1240392e-05F, 1.1970856e-05F,
+ 1.2748789e-05F, 1.3577278e-05F, 1.4459606e-05F, 1.5399272e-05F,
+ 1.6400004e-05F, 1.7465768e-05F, 1.8600792e-05F, 1.9809576e-05F,
+ 2.1096914e-05F, 2.2467911e-05F, 2.3928002e-05F, 2.5482978e-05F,
+ 2.7139006e-05F, 2.8902651e-05F, 3.0780908e-05F, 3.2781225e-05F,
+ 3.4911534e-05F, 3.7180282e-05F, 3.9596466e-05F, 4.2169667e-05F,
+ 4.4910090e-05F, 4.7828601e-05F, 5.0936773e-05F, 5.4246931e-05F,
+ 5.7772202e-05F, 6.1526565e-05F, 6.5524908e-05F, 6.9783085e-05F,
+ 7.4317983e-05F, 7.9147585e-05F, 8.4291040e-05F, 8.9768747e-05F,
+ 9.5602426e-05F, 0.00010181521F, 0.00010843174F, 0.00011547824F,
+ 0.00012298267F, 0.00013097477F, 0.00013948625F, 0.00014855085F,
+ 0.00015820453F, 0.00016848555F, 0.00017943469F, 0.00019109536F,
+ 0.00020351382F, 0.00021673929F, 0.00023082423F, 0.00024582449F,
+ 0.00026179955F, 0.00027881276F, 0.00029693158F, 0.00031622787F,
+ 0.00033677814F, 0.00035866388F, 0.00038197188F, 0.00040679456F,
+ 0.00043323036F, 0.00046138411F, 0.00049136745F, 0.00052329927F,
+ 0.00055730621F, 0.00059352311F, 0.00063209358F, 0.00067317058F,
+ 0.00071691700F, 0.00076350630F, 0.00081312324F, 0.00086596457F,
+ 0.00092223983F, 0.00098217216F, 0.0010459992F, 0.0011139742F,
+ 0.0011863665F, 0.0012634633F, 0.0013455702F, 0.0014330129F,
+ 0.0015261382F, 0.0016253153F, 0.0017309374F, 0.0018434235F,
+ 0.0019632195F, 0.0020908006F, 0.0022266726F, 0.0023713743F,
+ 0.0025254795F, 0.0026895994F, 0.0028643847F, 0.0030505286F,
+ 0.0032487691F, 0.0034598925F, 0.0036847358F, 0.0039241906F,
+ 0.0041792066F, 0.0044507950F, 0.0047400328F, 0.0050480668F,
+ 0.0053761186F, 0.0057254891F, 0.0060975636F, 0.0064938176F,
+ 0.0069158225F, 0.0073652516F, 0.0078438871F, 0.0083536271F,
+ 0.0088964928F, 0.009474637F, 0.010090352F, 0.010746080F,
+ 0.011444421F, 0.012188144F, 0.012980198F, 0.013823725F,
+ 0.014722068F, 0.015678791F, 0.016697687F, 0.017782797F,
+ 0.018938423F, 0.020169149F, 0.021479854F, 0.022875735F,
+ 0.024362330F, 0.025945531F, 0.027631618F, 0.029427276F,
+ 0.031339626F, 0.033376252F, 0.035545228F, 0.037855157F,
+ 0.040315199F, 0.042935108F, 0.045725273F, 0.048696758F,
+ 0.051861348F, 0.055231591F, 0.058820850F, 0.062643361F,
+ 0.066714279F, 0.071049749F, 0.075666962F, 0.080584227F,
+ 0.085821044F, 0.091398179F, 0.097337747F, 0.10366330F,
+ 0.11039993F, 0.11757434F, 0.12521498F, 0.13335215F,
+ 0.14201813F, 0.15124727F, 0.16107617F, 0.17154380F,
+ 0.18269168F, 0.19456402F, 0.20720788F, 0.22067342F,
+ 0.23501402F, 0.25028656F, 0.26655159F, 0.28387361F,
+ 0.30232132F, 0.32196786F, 0.34289114F, 0.36517414F,
+ 0.38890521F, 0.41417847F, 0.44109412F, 0.46975890F,
+ 0.50028648F, 0.53279791F, 0.56742212F, 0.60429640F,
+ 0.64356699F, 0.68538959F, 0.72993007F, 0.77736504F,
+ 0.82788260F, 0.88168307F, 0.9389798F, 1.F,
+};
+
+static void render_line(int n, int x0,int x1,int y0,int y1,float *d){
+ int dy=y1-y0;
+ int adx=x1-x0;
+ int ady=abs(dy);
+ int base=dy/adx;
+ int sy=(dy<0?base-1:base+1);
+ int x=x0;
+ int y=y0;
+ int err=0;
+
+ ady-=abs(base*adx);
+
+ if(n>x1)n=x1;
+
+ if(x<n)
+ d[x]*=FLOOR1_fromdB_LOOKUP[y];
+
+ while(++x<n){
+ err=err+ady;
+ if(err>=adx){
+ err-=adx;
+ y+=sy;
+ }else{
+ y+=base;
+ }
+ d[x]*=FLOOR1_fromdB_LOOKUP[y];
+ }
+}
+
+static void render_line0(int n, int x0,int x1,int y0,int y1,int *d){
+ int dy=y1-y0;
+ int adx=x1-x0;
+ int ady=abs(dy);
+ int base=dy/adx;
+ int sy=(dy<0?base-1:base+1);
+ int x=x0;
+ int y=y0;
+ int err=0;
+
+ ady-=abs(base*adx);
+
+ if(n>x1)n=x1;
+
+ if(x<n)
+ d[x]=y;
+
+ while(++x<n){
+ err=err+ady;
+ if(err>=adx){
+ err-=adx;
+ y+=sy;
+ }else{
+ y+=base;
+ }
+ d[x]=y;
+ }
+}
+
+/* the floor has already been filtered to only include relevant sections */
+static int accumulate_fit(const float *flr,const float *mdct,
+ int x0, int x1,lsfit_acc *a,
+ int n,vorbis_info_floor1 *info){
+ long i;
+
+ int xa=0,ya=0,x2a=0,y2a=0,xya=0,na=0, xb=0,yb=0,x2b=0,y2b=0,xyb=0,nb=0;
+
+ memset(a,0,sizeof(*a));
+ a->x0=x0;
+ a->x1=x1;
+ if(x1>=n)x1=n-1;
+
+ for(i=x0;i<=x1;i++){
+ int quantized=vorbis_dBquant(flr+i);
+ if(quantized){
+ if(mdct[i]+info->twofitatten>=flr[i]){
+ xa += i;
+ ya += quantized;
+ x2a += i*i;
+ y2a += quantized*quantized;
+ xya += i*quantized;
+ na++;
+ }else{
+ xb += i;
+ yb += quantized;
+ x2b += i*i;
+ y2b += quantized*quantized;
+ xyb += i*quantized;
+ nb++;
+ }
+ }
+ }
+
+ a->xa=xa;
+ a->ya=ya;
+ a->x2a=x2a;
+ a->y2a=y2a;
+ a->xya=xya;
+ a->an=na;
+
+ a->xb=xb;
+ a->yb=yb;
+ a->x2b=x2b;
+ a->y2b=y2b;
+ a->xyb=xyb;
+ a->bn=nb;
+
+ return(na);
+}
+
+static int fit_line(lsfit_acc *a,int fits,int *y0,int *y1,
+ vorbis_info_floor1 *info){
+ double xb=0,yb=0,x2b=0,y2b=0,xyb=0,bn=0;
+ int i;
+ int x0=a[0].x0;
+ int x1=a[fits-1].x1;
+
+ for(i=0;i<fits;i++){
+ double weight = (a[i].bn+a[i].an)*info->twofitweight/(a[i].an+1)+1.;
+
+ xb+=a[i].xb + a[i].xa * weight;
+ yb+=a[i].yb + a[i].ya * weight;
+ x2b+=a[i].x2b + a[i].x2a * weight;
+ y2b+=a[i].y2b + a[i].y2a * weight;
+ xyb+=a[i].xyb + a[i].xya * weight;
+ bn+=a[i].bn + a[i].an * weight;
+ }
+
+ if(*y0>=0){
+ xb+= x0;
+ yb+= *y0;
+ x2b+= x0 * x0;
+ y2b+= *y0 * *y0;
+ xyb+= *y0 * x0;
+ bn++;
+ }
+
+ if(*y1>=0){
+ xb+= x1;
+ yb+= *y1;
+ x2b+= x1 * x1;
+ y2b+= *y1 * *y1;
+ xyb+= *y1 * x1;
+ bn++;
+ }
+
+ {
+ double denom=(bn*x2b-xb*xb);
+
+ if(denom>0.){
+ double a=(yb*x2b-xyb*xb)/denom;
+ double b=(bn*xyb-xb*yb)/denom;
+ *y0=rint(a+b*x0);
+ *y1=rint(a+b*x1);
+
+ /* limit to our range! */
+ if(*y0>1023)*y0=1023;
+ if(*y1>1023)*y1=1023;
+ if(*y0<0)*y0=0;
+ if(*y1<0)*y1=0;
+
+ return 0;
+ }else{
+ *y0=0;
+ *y1=0;
+ return 1;
+ }
+ }
+}
+
+static int inspect_error(int x0,int x1,int y0,int y1,const float *mask,
+ const float *mdct,
+ vorbis_info_floor1 *info){
+ int dy=y1-y0;
+ int adx=x1-x0;
+ int ady=abs(dy);
+ int base=dy/adx;
+ int sy=(dy<0?base-1:base+1);
+ int x=x0;
+ int y=y0;
+ int err=0;
+ int val=vorbis_dBquant(mask+x);
+ int mse=0;
+ int n=0;
+
+ ady-=abs(base*adx);
+
+ mse=(y-val);
+ mse*=mse;
+ n++;
+ if(mdct[x]+info->twofitatten>=mask[x]){
+ if(y+info->maxover<val)return(1);
+ if(y-info->maxunder>val)return(1);
+ }
+
+ while(++x<x1){
+ err=err+ady;
+ if(err>=adx){
+ err-=adx;
+ y+=sy;
+ }else{
+ y+=base;
+ }
+
+ val=vorbis_dBquant(mask+x);
+ mse+=((y-val)*(y-val));
+ n++;
+ if(mdct[x]+info->twofitatten>=mask[x]){
+ if(val){
+ if(y+info->maxover<val)return(1);
+ if(y-info->maxunder>val)return(1);
+ }
+ }
+ }
+
+ if(info->maxover*info->maxover/n>info->maxerr)return(0);
+ if(info->maxunder*info->maxunder/n>info->maxerr)return(0);
+ if(mse/n>info->maxerr)return(1);
+ return(0);
+}
+
+static int post_Y(int *A,int *B,int pos){
+ if(A[pos]<0)
+ return B[pos];
+ if(B[pos]<0)
+ return A[pos];
+
+ return (A[pos]+B[pos])>>1;
+}
+
+int *floor1_fit(vorbis_block *vb,vorbis_look_floor1 *look,
+ const float *logmdct, /* in */
+ const float *logmask){
+ long i,j;
+ vorbis_info_floor1 *info=look->vi;
+ long n=look->n;
+ long posts=look->posts;
+ long nonzero=0;
+ lsfit_acc fits[VIF_POSIT+1];
+ int fit_valueA[VIF_POSIT+2]; /* index by range list position */
+ int fit_valueB[VIF_POSIT+2]; /* index by range list position */
+
+ int loneighbor[VIF_POSIT+2]; /* sorted index of range list position (+2) */
+ int hineighbor[VIF_POSIT+2];
+ int *output=NULL;
+ int memo[VIF_POSIT+2];
+
+ for(i=0;i<posts;i++)fit_valueA[i]=-200; /* mark all unused */
+ for(i=0;i<posts;i++)fit_valueB[i]=-200; /* mark all unused */
+ for(i=0;i<posts;i++)loneighbor[i]=0; /* 0 for the implicit 0 post */
+ for(i=0;i<posts;i++)hineighbor[i]=1; /* 1 for the implicit post at n */
+ for(i=0;i<posts;i++)memo[i]=-1; /* no neighbor yet */
+
+ /* quantize the relevant floor points and collect them into line fit
+ structures (one per minimal division) at the same time */
+ if(posts==0){
+ nonzero+=accumulate_fit(logmask,logmdct,0,n,fits,n,info);
+ }else{
+ for(i=0;i<posts-1;i++)
+ nonzero+=accumulate_fit(logmask,logmdct,look->sorted_index[i],
+ look->sorted_index[i+1],fits+i,
+ n,info);
+ }
+
+ if(nonzero){
+ /* start by fitting the implicit base case.... */
+ int y0=-200;
+ int y1=-200;
+ fit_line(fits,posts-1,&y0,&y1,info);
+
+ fit_valueA[0]=y0;
+ fit_valueB[0]=y0;
+ fit_valueB[1]=y1;
+ fit_valueA[1]=y1;
+
+ /* Non degenerate case */
+ /* start progressive splitting. This is a greedy, non-optimal
+ algorithm, but simple and close enough to the best
+ answer. */
+ for(i=2;i<posts;i++){
+ int sortpos=look->reverse_index[i];
+ int ln=loneighbor[sortpos];
+ int hn=hineighbor[sortpos];
+
+ /* eliminate repeat searches of a particular range with a memo */
+ if(memo[ln]!=hn){
+ /* haven't performed this error search yet */
+ int lsortpos=look->reverse_index[ln];
+ int hsortpos=look->reverse_index[hn];
+ memo[ln]=hn;
+
+ {
+ /* A note: we want to bound/minimize *local*, not global, error */
+ int lx=info->postlist[ln];
+ int hx=info->postlist[hn];
+ int ly=post_Y(fit_valueA,fit_valueB,ln);
+ int hy=post_Y(fit_valueA,fit_valueB,hn);
+
+ if(ly==-1 || hy==-1){
+ exit(1);
+ }
+
+ if(inspect_error(lx,hx,ly,hy,logmask,logmdct,info)){
+ /* outside error bounds/begin search area. Split it. */
+ int ly0=-200;
+ int ly1=-200;
+ int hy0=-200;
+ int hy1=-200;
+ int ret0=fit_line(fits+lsortpos,sortpos-lsortpos,&ly0,&ly1,info);
+ int ret1=fit_line(fits+sortpos,hsortpos-sortpos,&hy0,&hy1,info);
+
+ if(ret0){
+ ly0=ly;
+ ly1=hy0;
+ }
+ if(ret1){
+ hy0=ly1;
+ hy1=hy;
+ }
+
+ if(ret0 && ret1){
+ fit_valueA[i]=-200;
+ fit_valueB[i]=-200;
+ }else{
+ /* store new edge values */
+ fit_valueB[ln]=ly0;
+ if(ln==0)fit_valueA[ln]=ly0;
+ fit_valueA[i]=ly1;
+ fit_valueB[i]=hy0;
+ fit_valueA[hn]=hy1;
+ if(hn==1)fit_valueB[hn]=hy1;
+
+ if(ly1>=0 || hy0>=0){
+ /* store new neighbor values */
+ for(j=sortpos-1;j>=0;j--)
+ if(hineighbor[j]==hn)
+ hineighbor[j]=i;
+ else
+ break;
+ for(j=sortpos+1;j<posts;j++)
+ if(loneighbor[j]==ln)
+ loneighbor[j]=i;
+ else
+ break;
+ }
+ }
+ }else{
+ fit_valueA[i]=-200;
+ fit_valueB[i]=-200;
+ }
+ }
+ }
+ }
+
+ output=_vorbis_block_alloc(vb,sizeof(*output)*posts);
+
+ output[0]=post_Y(fit_valueA,fit_valueB,0);
+ output[1]=post_Y(fit_valueA,fit_valueB,1);
+
+ /* fill in posts marked as not using a fit; we will zero
+ back out to 'unused' when encoding them so long as curve
+ interpolation doesn't force them into use */
+ for(i=2;i<posts;i++){
+ int ln=look->loneighbor[i-2];
+ int hn=look->hineighbor[i-2];
+ int x0=info->postlist[ln];
+ int x1=info->postlist[hn];
+ int y0=output[ln];
+ int y1=output[hn];
+
+ int predicted=render_point(x0,x1,y0,y1,info->postlist[i]);
+ int vx=post_Y(fit_valueA,fit_valueB,i);
+
+ if(vx>=0 && predicted!=vx){
+ output[i]=vx;
+ }else{
+ output[i]= predicted|0x8000;
+ }
+ }
+ }
+
+ return(output);
+
+}
+
+int *floor1_interpolate_fit(vorbis_block *vb,vorbis_look_floor1 *look,
+ int *A,int *B,
+ int del){
+
+ long i;
+ long posts=look->posts;
+ int *output=NULL;
+
+ if(A && B){
+ output=_vorbis_block_alloc(vb,sizeof(*output)*posts);
+
+ /* overly simpleminded--- look again post 1.2 */
+ for(i=0;i<posts;i++){
+ output[i]=((65536-del)*(A[i]&0x7fff)+del*(B[i]&0x7fff)+32768)>>16;
+ if(A[i]&0x8000 && B[i]&0x8000)output[i]|=0x8000;
+ }
+ }
+
+ return(output);
+}
+
+
+int floor1_encode(oggpack_buffer *opb,vorbis_block *vb,
+ vorbis_look_floor1 *look,
+ int *post,int *ilogmask){
+
+ long i,j;
+ vorbis_info_floor1 *info=look->vi;
+ long posts=look->posts;
+ codec_setup_info *ci=vb->vd->vi->codec_setup;
+ int out[VIF_POSIT+2];
+ static_codebook **sbooks=ci->book_param;
+ codebook *books=ci->fullbooks;
+
+ /* quantize values to multiplier spec */
+ if(post){
+ for(i=0;i<posts;i++){
+ int val=post[i]&0x7fff;
+ switch(info->mult){
+ case 1: /* 1024 -> 256 */
+ val>>=2;
+ break;
+ case 2: /* 1024 -> 128 */
+ val>>=3;
+ break;
+ case 3: /* 1024 -> 86 */
+ val/=12;
+ break;
+ case 4: /* 1024 -> 64 */
+ val>>=4;
+ break;
+ }
+ post[i]=val | (post[i]&0x8000);
+ }
+
+ out[0]=post[0];
+ out[1]=post[1];
+
+ /* find prediction values for each post and subtract them */
+ for(i=2;i<posts;i++){
+ int ln=look->loneighbor[i-2];
+ int hn=look->hineighbor[i-2];
+ int x0=info->postlist[ln];
+ int x1=info->postlist[hn];
+ int y0=post[ln];
+ int y1=post[hn];
+
+ int predicted=render_point(x0,x1,y0,y1,info->postlist[i]);
+
+ if((post[i]&0x8000) || (predicted==post[i])){
+ post[i]=predicted|0x8000; /* in case there was roundoff jitter
+ in interpolation */
+ out[i]=0;
+ }else{
+ int headroom=(look->quant_q-predicted<predicted?
+ look->quant_q-predicted:predicted);
+
+ int val=post[i]-predicted;
+
+ /* at this point the 'deviation' value is in the range +/- max
+ range, but the real, unique range can always be mapped to
+ only [0-maxrange). So we want to wrap the deviation into
+ this limited range, but do it in the way that least screws
+ an essentially gaussian probability distribution. */
+
+ if(val<0)
+ if(val<-headroom)
+ val=headroom-val-1;
+ else
+ val=-1-(val<<1);
+ else
+ if(val>=headroom)
+ val= val+headroom;
+ else
+ val<<=1;
+
+ out[i]=val;
+ post[ln]&=0x7fff;
+ post[hn]&=0x7fff;
+ }
+ }
+
+ /* we have everything we need. pack it out */
+ /* mark nontrivial floor */
+ oggpack_write(opb,1,1);
+
+ /* beginning/end post */
+ look->frames++;
+ look->postbits+=ilog(look->quant_q-1)*2;
+ oggpack_write(opb,out[0],ilog(look->quant_q-1));
+ oggpack_write(opb,out[1],ilog(look->quant_q-1));
+
+
+ /* partition by partition */
+ for(i=0,j=2;i<info->partitions;i++){
+ int class=info->partitionclass[i];
+ int cdim=info->class_dim[class];
+ int csubbits=info->class_subs[class];
+ int csub=1<<csubbits;
+ int bookas[8]={0,0,0,0,0,0,0,0};
+ int cval=0;
+ int cshift=0;
+ int k,l;
+
+ /* generate the partition's first stage cascade value */
+ if(csubbits){
+ int maxval[8];
+ for(k=0;k<csub;k++){
+ int booknum=info->class_subbook[class][k];
+ if(booknum<0){
+ maxval[k]=1;
+ }else{
+ maxval[k]=sbooks[info->class_subbook[class][k]]->entries;
+ }
+ }
+ for(k=0;k<cdim;k++){
+ for(l=0;l<csub;l++){
+ int val=out[j+k];
+ if(val<maxval[l]){
+ bookas[k]=l;
+ break;
+ }
+ }
+ cval|= bookas[k]<<cshift;
+ cshift+=csubbits;
+ }
+ /* write it */
+ look->phrasebits+=
+ vorbis_book_encode(books+info->class_book[class],cval,opb);
+
+#ifdef TRAIN_FLOOR1
+ {
+ FILE *of;
+ char buffer[80];
+ sprintf(buffer,"line_%dx%ld_class%d.vqd",
+ vb->pcmend/2,posts-2,class);
+ of=fopen(buffer,"a");
+ fprintf(of,"%d\n",cval);
+ fclose(of);
+ }
+#endif
+ }
+
+ /* write post values */
+ for(k=0;k<cdim;k++){
+ int book=info->class_subbook[class][bookas[k]];
+ if(book>=0){
+ /* hack to allow training with 'bad' books */
+ if(out[j+k]<(books+book)->entries)
+ look->postbits+=vorbis_book_encode(books+book,
+ out[j+k],opb);
+ /*else
+ fprintf(stderr,"+!");*/
+
+#ifdef TRAIN_FLOOR1
+ {
+ FILE *of;
+ char buffer[80];
+ sprintf(buffer,"line_%dx%ld_%dsub%d.vqd",
+ vb->pcmend/2,posts-2,class,bookas[k]);
+ of=fopen(buffer,"a");
+ fprintf(of,"%d\n",out[j+k]);
+ fclose(of);
+ }
+#endif
+ }
+ }
+ j+=cdim;
+ }
+
+ {
+ /* generate quantized floor equivalent to what we'd unpack in decode */
+ /* render the lines */
+ int hx=0;
+ int lx=0;
+ int ly=post[0]*info->mult;
+ int n=ci->blocksizes[vb->W]/2;
+
+ for(j=1;j<look->posts;j++){
+ int current=look->forward_index[j];
+ int hy=post[current]&0x7fff;
+ if(hy==post[current]){
+
+ hy*=info->mult;
+ hx=info->postlist[current];
+
+ render_line0(n,lx,hx,ly,hy,ilogmask);
+
+ lx=hx;
+ ly=hy;
+ }
+ }
+ for(j=hx;j<vb->pcmend/2;j++)ilogmask[j]=ly; /* be certain */
+ return(1);
+ }
+ }else{
+ oggpack_write(opb,0,1);
+ memset(ilogmask,0,vb->pcmend/2*sizeof(*ilogmask));
+ return(0);
+ }
+}
+
+static void *floor1_inverse1(vorbis_block *vb,vorbis_look_floor *in){
+ vorbis_look_floor1 *look=(vorbis_look_floor1 *)in;
+ vorbis_info_floor1 *info=look->vi;
+ codec_setup_info *ci=vb->vd->vi->codec_setup;
+
+ int i,j,k;
+ codebook *books=ci->fullbooks;
+
+ /* unpack wrapped/predicted values from stream */
+ if(oggpack_read(&vb->opb,1)==1){
+ int *fit_value=_vorbis_block_alloc(vb,(look->posts)*sizeof(*fit_value));
+
+ fit_value[0]=oggpack_read(&vb->opb,ilog(look->quant_q-1));
+ fit_value[1]=oggpack_read(&vb->opb,ilog(look->quant_q-1));
+
+ /* partition by partition */
+ for(i=0,j=2;i<info->partitions;i++){
+ int class=info->partitionclass[i];
+ int cdim=info->class_dim[class];
+ int csubbits=info->class_subs[class];
+ int csub=1<<csubbits;
+ int cval=0;
+
+ /* decode the partition's first stage cascade value */
+ if(csubbits){
+ cval=vorbis_book_decode(books+info->class_book[class],&vb->opb);
+
+ if(cval==-1)goto eop;
+ }
+
+ for(k=0;k<cdim;k++){
+ int book=info->class_subbook[class][cval&(csub-1)];
+ cval>>=csubbits;
+ if(book>=0){
+ if((fit_value[j+k]=vorbis_book_decode(books+book,&vb->opb))==-1)
+ goto eop;
+ }else{
+ fit_value[j+k]=0;
+ }
+ }
+ j+=cdim;
+ }
+
+ /* unwrap positive values and reconsitute via linear interpolation */
+ for(i=2;i<look->posts;i++){
+ int predicted=render_point(info->postlist[look->loneighbor[i-2]],
+ info->postlist[look->hineighbor[i-2]],
+ fit_value[look->loneighbor[i-2]],
+ fit_value[look->hineighbor[i-2]],
+ info->postlist[i]);
+ int hiroom=look->quant_q-predicted;
+ int loroom=predicted;
+ int room=(hiroom<loroom?hiroom:loroom)<<1;
+ int val=fit_value[i];
+
+ if(val){
+ if(val>=room){
+ if(hiroom>loroom){
+ val = val-loroom;
+ }else{
+ val = -1-(val-hiroom);
+ }
+ }else{
+ if(val&1){
+ val= -((val+1)>>1);
+ }else{
+ val>>=1;
+ }
+ }
+
+ fit_value[i]=(val+predicted)&0x7fff;
+ fit_value[look->loneighbor[i-2]]&=0x7fff;
+ fit_value[look->hineighbor[i-2]]&=0x7fff;
+
+ }else{
+ fit_value[i]=predicted|0x8000;
+ }
+
+ }
+
+ return(fit_value);
+ }
+ eop:
+ return(NULL);
+}
+
+static int floor1_inverse2(vorbis_block *vb,vorbis_look_floor *in,void *memo,
+ float *out){
+ vorbis_look_floor1 *look=(vorbis_look_floor1 *)in;
+ vorbis_info_floor1 *info=look->vi;
+
+ codec_setup_info *ci=vb->vd->vi->codec_setup;
+ int n=ci->blocksizes[vb->W]/2;
+ int j;
+
+ if(memo){
+ /* render the lines */
+ int *fit_value=(int *)memo;
+ int hx=0;
+ int lx=0;
+ int ly=fit_value[0]*info->mult;
+ /* guard lookup against out-of-range values */
+ ly=(ly<0?0:ly>255?255:ly);
+
+ for(j=1;j<look->posts;j++){
+ int current=look->forward_index[j];
+ int hy=fit_value[current]&0x7fff;
+ if(hy==fit_value[current]){
+
+ hx=info->postlist[current];
+ hy*=info->mult;
+ /* guard lookup against out-of-range values */
+ hy=(hy<0?0:hy>255?255:hy);
+
+ render_line(n,lx,hx,ly,hy,out);
+
+ lx=hx;
+ ly=hy;
+ }
+ }
+ for(j=hx;j<n;j++)out[j]*=FLOOR1_fromdB_LOOKUP[ly]; /* be certain */
+ return(1);
+ }
+ memset(out,0,sizeof(*out)*n);
+ return(0);
+}
+
+/* export hooks */
+const vorbis_func_floor floor1_exportbundle={
+ &floor1_pack,&floor1_unpack,&floor1_look,&floor1_free_info,
+ &floor1_free_look,&floor1_inverse1,&floor1_inverse2
+};
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: highlevel encoder setup struct separated out for vorbisenc clarity
+ last mod: $Id: highlevel.h 17195 2010-05-05 21:49:51Z giles $
+
+ ********************************************************************/
+
+typedef struct highlevel_byblocktype {
+ double tone_mask_setting;
+ double tone_peaklimit_setting;
+ double noise_bias_setting;
+ double noise_compand_setting;
+} highlevel_byblocktype;
+
+typedef struct highlevel_encode_setup {
+ int set_in_stone;
+ const void *setup;
+ double base_setting;
+
+ double impulse_noisetune;
+
+ /* bitrate management below all settable */
+ float req;
+ int managed;
+ long bitrate_min;
+ long bitrate_av;
+ double bitrate_av_damp;
+ long bitrate_max;
+ long bitrate_reservoir;
+ double bitrate_reservoir_bias;
+
+ int impulse_block_p;
+ int noise_normalize_p;
+ int coupling_p;
+
+ double stereo_point_setting;
+ double lowpass_kHz;
+ int lowpass_altered;
+
+ double ath_floating_dB;
+ double ath_absolute_dB;
+
+ double amplitude_track_dBpersec;
+ double trigger_setting;
+
+ highlevel_byblocktype block[4]; /* padding, impulse, transition, long */
+
+} highlevel_encode_setup;
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2010 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: maintain the info structure, info <-> header packets
+ last mod: $Id: info.c 18186 2012-02-03 22:08:44Z xiphmont $
+
+ ********************************************************************/
+
+/* general handling of the header and the vorbis_info structure (and
+ substructures) */
+
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <ogg/ogg.h>
+#include "vorbis/codec.h"
+#include "codec_internal.h"
+#include "codebook.h"
+#include "registry.h"
+#include "window.h"
+#include "psy.h"
+#include "misc.h"
+#include "os.h"
+
+#define GENERAL_VENDOR_STRING "Xiph.Org libVorbis 1.3.3"
+#define ENCODE_VENDOR_STRING "Xiph.Org libVorbis I 20120203 (Omnipresent)"
+
+/* helpers */
+static int ilog2(unsigned int v){
+ int ret=0;
+ if(v)--v;
+ while(v){
+ ret++;
+ v>>=1;
+ }
+ return(ret);
+}
+
+static void _v_writestring(oggpack_buffer *o,const char *s, int bytes){
+
+ while(bytes--){
+ oggpack_write(o,*s++,8);
+ }
+}
+
+static void _v_readstring(oggpack_buffer *o,char *buf,int bytes){
+ while(bytes--){
+ *buf++=oggpack_read(o,8);
+ }
+}
+
+void vorbis_comment_init(vorbis_comment *vc){
+ memset(vc,0,sizeof(*vc));
+}
+
+void vorbis_comment_add(vorbis_comment *vc,const char *comment){
+ vc->user_comments=_ogg_realloc(vc->user_comments,
+ (vc->comments+2)*sizeof(*vc->user_comments));
+ vc->comment_lengths=_ogg_realloc(vc->comment_lengths,
+ (vc->comments+2)*sizeof(*vc->comment_lengths));
+ vc->comment_lengths[vc->comments]=strlen(comment);
+ vc->user_comments[vc->comments]=_ogg_malloc(vc->comment_lengths[vc->comments]+1);
+ strcpy(vc->user_comments[vc->comments], comment);
+ vc->comments++;
+ vc->user_comments[vc->comments]=NULL;
+}
+
+void vorbis_comment_add_tag(vorbis_comment *vc, const char *tag, const char *contents){
+ char *comment=alloca(strlen(tag)+strlen(contents)+2); /* +2 for = and \0 */
+ strcpy(comment, tag);
+ strcat(comment, "=");
+ strcat(comment, contents);
+ vorbis_comment_add(vc, comment);
+}
+
+/* This is more or less the same as strncasecmp - but that doesn't exist
+ * everywhere, and this is a fairly trivial function, so we include it */
+static int tagcompare(const char *s1, const char *s2, int n){
+ int c=0;
+ while(c < n){
+ if(toupper(s1[c]) != toupper(s2[c]))
+ return !0;
+ c++;
+ }
+ return 0;
+}
+
+char *vorbis_comment_query(vorbis_comment *vc, const char *tag, int count){
+ long i;
+ int found = 0;
+ int taglen = strlen(tag)+1; /* +1 for the = we append */
+ char *fulltag = alloca(taglen+ 1);
+
+ strcpy(fulltag, tag);
+ strcat(fulltag, "=");
+
+ for(i=0;i<vc->comments;i++){
+ if(!tagcompare(vc->user_comments[i], fulltag, taglen)){
+ if(count == found)
+ /* We return a pointer to the data, not a copy */
+ return vc->user_comments[i] + taglen;
+ else
+ found++;
+ }
+ }
+ return NULL; /* didn't find anything */
+}
+
+int vorbis_comment_query_count(vorbis_comment *vc, const char *tag){
+ int i,count=0;
+ int taglen = strlen(tag)+1; /* +1 for the = we append */
+ char *fulltag = alloca(taglen+1);
+ strcpy(fulltag,tag);
+ strcat(fulltag, "=");
+
+ for(i=0;i<vc->comments;i++){
+ if(!tagcompare(vc->user_comments[i], fulltag, taglen))
+ count++;
+ }
+
+ return count;
+}
+
+void vorbis_comment_clear(vorbis_comment *vc){
+ if(vc){
+ long i;
+ if(vc->user_comments){
+ for(i=0;i<vc->comments;i++)
+ if(vc->user_comments[i])_ogg_free(vc->user_comments[i]);
+ _ogg_free(vc->user_comments);
+ }
+ if(vc->comment_lengths)_ogg_free(vc->comment_lengths);
+ if(vc->vendor)_ogg_free(vc->vendor);
+ memset(vc,0,sizeof(*vc));
+ }
+}
+
+/* blocksize 0 is guaranteed to be short, 1 is guaranteed to be long.
+ They may be equal, but short will never ge greater than long */
+int vorbis_info_blocksize(vorbis_info *vi,int zo){
+ codec_setup_info *ci = vi->codec_setup;
+ return ci ? ci->blocksizes[zo] : -1;
+}
+
+/* used by synthesis, which has a full, alloced vi */
+void vorbis_info_init(vorbis_info *vi){
+ memset(vi,0,sizeof(*vi));
+ vi->codec_setup=_ogg_calloc(1,sizeof(codec_setup_info));
+}
+
+void vorbis_info_clear(vorbis_info *vi){
+ codec_setup_info *ci=vi->codec_setup;
+ int i;
+
+ if(ci){
+
+ for(i=0;i<ci->modes;i++)
+ if(ci->mode_param[i])_ogg_free(ci->mode_param[i]);
+
+ for(i=0;i<ci->maps;i++) /* unpack does the range checking */
+ if(ci->map_param[i]) /* this may be cleaning up an aborted
+ unpack, in which case the below type
+ cannot be trusted */
+ _mapping_P[ci->map_type[i]]->free_info(ci->map_param[i]);
+
+ for(i=0;i<ci->floors;i++) /* unpack does the range checking */
+ if(ci->floor_param[i]) /* this may be cleaning up an aborted
+ unpack, in which case the below type
+ cannot be trusted */
+ _floor_P[ci->floor_type[i]]->free_info(ci->floor_param[i]);
+
+ for(i=0;i<ci->residues;i++) /* unpack does the range checking */
+ if(ci->residue_param[i]) /* this may be cleaning up an aborted
+ unpack, in which case the below type
+ cannot be trusted */
+ _residue_P[ci->residue_type[i]]->free_info(ci->residue_param[i]);
+
+ for(i=0;i<ci->books;i++){
+ if(ci->book_param[i]){
+ /* knows if the book was not alloced */
+ vorbis_staticbook_destroy(ci->book_param[i]);
+ }
+ if(ci->fullbooks)
+ vorbis_book_clear(ci->fullbooks+i);
+ }
+ if(ci->fullbooks)
+ _ogg_free(ci->fullbooks);
+
+ for(i=0;i<ci->psys;i++)
+ _vi_psy_free(ci->psy_param[i]);
+
+ _ogg_free(ci);
+ }
+
+ memset(vi,0,sizeof(*vi));
+}
+
+/* Header packing/unpacking ********************************************/
+
+static int _vorbis_unpack_info(vorbis_info *vi,oggpack_buffer *opb){
+ codec_setup_info *ci=vi->codec_setup;
+ if(!ci)return(OV_EFAULT);
+
+ vi->version=oggpack_read(opb,32);
+ if(vi->version!=0)return(OV_EVERSION);
+
+ vi->channels=oggpack_read(opb,8);
+ vi->rate=oggpack_read(opb,32);
+
+ vi->bitrate_upper=oggpack_read(opb,32);
+ vi->bitrate_nominal=oggpack_read(opb,32);
+ vi->bitrate_lower=oggpack_read(opb,32);
+
+ ci->blocksizes[0]=1<<oggpack_read(opb,4);
+ ci->blocksizes[1]=1<<oggpack_read(opb,4);
+
+ if(vi->rate<1)goto err_out;
+ if(vi->channels<1)goto err_out;
+ if(ci->blocksizes[0]<64)goto err_out;
+ if(ci->blocksizes[1]<ci->blocksizes[0])goto err_out;
+ if(ci->blocksizes[1]>8192)goto err_out;
+
+ if(oggpack_read(opb,1)!=1)goto err_out; /* EOP check */
+
+ return(0);
+ err_out:
+ vorbis_info_clear(vi);
+ return(OV_EBADHEADER);
+}
+
+static int _vorbis_unpack_comment(vorbis_comment *vc,oggpack_buffer *opb){
+ int i;
+ int vendorlen=oggpack_read(opb,32);
+ if(vendorlen<0)goto err_out;
+ if(vendorlen>opb->storage-8)goto err_out;
+ vc->vendor=_ogg_calloc(vendorlen+1,1);
+ _v_readstring(opb,vc->vendor,vendorlen);
+ i=oggpack_read(opb,32);
+ if(i<0)goto err_out;
+ if(i>((opb->storage-oggpack_bytes(opb))>>2))goto err_out;
+ vc->comments=i;
+ vc->user_comments=_ogg_calloc(vc->comments+1,sizeof(*vc->user_comments));
+ vc->comment_lengths=_ogg_calloc(vc->comments+1, sizeof(*vc->comment_lengths));
+
+ for(i=0;i<vc->comments;i++){
+ int len=oggpack_read(opb,32);
+ if(len<0)goto err_out;
+ if(len>opb->storage-oggpack_bytes(opb))goto err_out;
+ vc->comment_lengths[i]=len;
+ vc->user_comments[i]=_ogg_calloc(len+1,1);
+ _v_readstring(opb,vc->user_comments[i],len);
+ }
+ if(oggpack_read(opb,1)!=1)goto err_out; /* EOP check */
+
+ return(0);
+ err_out:
+ vorbis_comment_clear(vc);
+ return(OV_EBADHEADER);
+}
+
+/* all of the real encoding details are here. The modes, books,
+ everything */
+static int _vorbis_unpack_books(vorbis_info *vi,oggpack_buffer *opb){
+ codec_setup_info *ci=vi->codec_setup;
+ int i;
+ if(!ci)return(OV_EFAULT);
+
+ /* codebooks */
+ ci->books=oggpack_read(opb,8)+1;
+ if(ci->books<=0)goto err_out;
+ for(i=0;i<ci->books;i++){
+ ci->book_param[i]=vorbis_staticbook_unpack(opb);
+ if(!ci->book_param[i])goto err_out;
+ }
+
+ /* time backend settings; hooks are unused */
+ {
+ int times=oggpack_read(opb,6)+1;
+ if(times<=0)goto err_out;
+ for(i=0;i<times;i++){
+ int test=oggpack_read(opb,16);
+ if(test<0 || test>=VI_TIMEB)goto err_out;
+ }
+ }
+
+ /* floor backend settings */
+ ci->floors=oggpack_read(opb,6)+1;
+ if(ci->floors<=0)goto err_out;
+ for(i=0;i<ci->floors;i++){
+ ci->floor_type[i]=oggpack_read(opb,16);
+ if(ci->floor_type[i]<0 || ci->floor_type[i]>=VI_FLOORB)goto err_out;
+ ci->floor_param[i]=_floor_P[ci->floor_type[i]]->unpack(vi,opb);
+ if(!ci->floor_param[i])goto err_out;
+ }
+
+ /* residue backend settings */
+ ci->residues=oggpack_read(opb,6)+1;
+ if(ci->residues<=0)goto err_out;
+ for(i=0;i<ci->residues;i++){
+ ci->residue_type[i]=oggpack_read(opb,16);
+ if(ci->residue_type[i]<0 || ci->residue_type[i]>=VI_RESB)goto err_out;
+ ci->residue_param[i]=_residue_P[ci->residue_type[i]]->unpack(vi,opb);
+ if(!ci->residue_param[i])goto err_out;
+ }
+
+ /* map backend settings */
+ ci->maps=oggpack_read(opb,6)+1;
+ if(ci->maps<=0)goto err_out;
+ for(i=0;i<ci->maps;i++){
+ ci->map_type[i]=oggpack_read(opb,16);
+ if(ci->map_type[i]<0 || ci->map_type[i]>=VI_MAPB)goto err_out;
+ ci->map_param[i]=_mapping_P[ci->map_type[i]]->unpack(vi,opb);
+ if(!ci->map_param[i])goto err_out;
+ }
+
+ /* mode settings */
+ ci->modes=oggpack_read(opb,6)+1;
+ if(ci->modes<=0)goto err_out;
+ for(i=0;i<ci->modes;i++){
+ ci->mode_param[i]=_ogg_calloc(1,sizeof(*ci->mode_param[i]));
+ ci->mode_param[i]->blockflag=oggpack_read(opb,1);
+ ci->mode_param[i]->windowtype=oggpack_read(opb,16);
+ ci->mode_param[i]->transformtype=oggpack_read(opb,16);
+ ci->mode_param[i]->mapping=oggpack_read(opb,8);
+
+ if(ci->mode_param[i]->windowtype>=VI_WINDOWB)goto err_out;
+ if(ci->mode_param[i]->transformtype>=VI_WINDOWB)goto err_out;
+ if(ci->mode_param[i]->mapping>=ci->maps)goto err_out;
+ if(ci->mode_param[i]->mapping<0)goto err_out;
+ }
+
+ if(oggpack_read(opb,1)!=1)goto err_out; /* top level EOP check */
+
+ return(0);
+ err_out:
+ vorbis_info_clear(vi);
+ return(OV_EBADHEADER);
+}
+
+/* Is this packet a vorbis ID header? */
+int vorbis_synthesis_idheader(ogg_packet *op){
+ oggpack_buffer opb;
+ char buffer[6];
+
+ if(op){
+ oggpack_readinit(&opb,op->packet,op->bytes);
+
+ if(!op->b_o_s)
+ return(0); /* Not the initial packet */
+
+ if(oggpack_read(&opb,8) != 1)
+ return 0; /* not an ID header */
+
+ memset(buffer,0,6);
+ _v_readstring(&opb,buffer,6);
+ if(memcmp(buffer,"vorbis",6))
+ return 0; /* not vorbis */
+
+ return 1;
+ }
+
+ return 0;
+}
+
+/* The Vorbis header is in three packets; the initial small packet in
+ the first page that identifies basic parameters, a second packet
+ with bitstream comments and a third packet that holds the
+ codebook. */
+
+int vorbis_synthesis_headerin(vorbis_info *vi,vorbis_comment *vc,ogg_packet *op){
+ oggpack_buffer opb;
+
+ if(op){
+ oggpack_readinit(&opb,op->packet,op->bytes);
+
+ /* Which of the three types of header is this? */
+ /* Also verify header-ness, vorbis */
+ {
+ char buffer[6];
+ int packtype=oggpack_read(&opb,8);
+ memset(buffer,0,6);
+ _v_readstring(&opb,buffer,6);
+ if(memcmp(buffer,"vorbis",6)){
+ /* not a vorbis header */
+ return(OV_ENOTVORBIS);
+ }
+ switch(packtype){
+ case 0x01: /* least significant *bit* is read first */
+ if(!op->b_o_s){
+ /* Not the initial packet */
+ return(OV_EBADHEADER);
+ }
+ if(vi->rate!=0){
+ /* previously initialized info header */
+ return(OV_EBADHEADER);
+ }
+
+ return(_vorbis_unpack_info(vi,&opb));
+
+ case 0x03: /* least significant *bit* is read first */
+ if(vi->rate==0){
+ /* um... we didn't get the initial header */
+ return(OV_EBADHEADER);
+ }
+
+ return(_vorbis_unpack_comment(vc,&opb));
+
+ case 0x05: /* least significant *bit* is read first */
+ if(vi->rate==0 || vc->vendor==NULL){
+ /* um... we didn;t get the initial header or comments yet */
+ return(OV_EBADHEADER);
+ }
+
+ return(_vorbis_unpack_books(vi,&opb));
+
+ default:
+ /* Not a valid vorbis header type */
+ return(OV_EBADHEADER);
+ break;
+ }
+ }
+ }
+ return(OV_EBADHEADER);
+}
+
+/* pack side **********************************************************/
+
+static int _vorbis_pack_info(oggpack_buffer *opb,vorbis_info *vi){
+ codec_setup_info *ci=vi->codec_setup;
+ if(!ci)return(OV_EFAULT);
+
+ /* preamble */
+ oggpack_write(opb,0x01,8);
+ _v_writestring(opb,"vorbis", 6);
+
+ /* basic information about the stream */
+ oggpack_write(opb,0x00,32);
+ oggpack_write(opb,vi->channels,8);
+ oggpack_write(opb,vi->rate,32);
+
+ oggpack_write(opb,vi->bitrate_upper,32);
+ oggpack_write(opb,vi->bitrate_nominal,32);
+ oggpack_write(opb,vi->bitrate_lower,32);
+
+ oggpack_write(opb,ilog2(ci->blocksizes[0]),4);
+ oggpack_write(opb,ilog2(ci->blocksizes[1]),4);
+ oggpack_write(opb,1,1);
+
+ return(0);
+}
+
+static int _vorbis_pack_comment(oggpack_buffer *opb,vorbis_comment *vc){
+ int bytes = strlen(ENCODE_VENDOR_STRING);
+
+ /* preamble */
+ oggpack_write(opb,0x03,8);
+ _v_writestring(opb,"vorbis", 6);
+
+ /* vendor */
+ oggpack_write(opb,bytes,32);
+ _v_writestring(opb,ENCODE_VENDOR_STRING, bytes);
+
+ /* comments */
+
+ oggpack_write(opb,vc->comments,32);
+ if(vc->comments){
+ int i;
+ for(i=0;i<vc->comments;i++){
+ if(vc->user_comments[i]){
+ oggpack_write(opb,vc->comment_lengths[i],32);
+ _v_writestring(opb,vc->user_comments[i], vc->comment_lengths[i]);
+ }else{
+ oggpack_write(opb,0,32);
+ }
+ }
+ }
+ oggpack_write(opb,1,1);
+
+ return(0);
+}
+
+static int _vorbis_pack_books(oggpack_buffer *opb,vorbis_info *vi){
+ codec_setup_info *ci=vi->codec_setup;
+ int i;
+ if(!ci)return(OV_EFAULT);
+
+ oggpack_write(opb,0x05,8);
+ _v_writestring(opb,"vorbis", 6);
+
+ /* books */
+ oggpack_write(opb,ci->books-1,8);
+ for(i=0;i<ci->books;i++)
+ if(vorbis_staticbook_pack(ci->book_param[i],opb))goto err_out;
+
+ /* times; hook placeholders */
+ oggpack_write(opb,0,6);
+ oggpack_write(opb,0,16);
+
+ /* floors */
+ oggpack_write(opb,ci->floors-1,6);
+ for(i=0;i<ci->floors;i++){
+ oggpack_write(opb,ci->floor_type[i],16);
+ if(_floor_P[ci->floor_type[i]]->pack)
+ _floor_P[ci->floor_type[i]]->pack(ci->floor_param[i],opb);
+ else
+ goto err_out;
+ }
+
+ /* residues */
+ oggpack_write(opb,ci->residues-1,6);
+ for(i=0;i<ci->residues;i++){
+ oggpack_write(opb,ci->residue_type[i],16);
+ _residue_P[ci->residue_type[i]]->pack(ci->residue_param[i],opb);
+ }
+
+ /* maps */
+ oggpack_write(opb,ci->maps-1,6);
+ for(i=0;i<ci->maps;i++){
+ oggpack_write(opb,ci->map_type[i],16);
+ _mapping_P[ci->map_type[i]]->pack(vi,ci->map_param[i],opb);
+ }
+
+ /* modes */
+ oggpack_write(opb,ci->modes-1,6);
+ for(i=0;i<ci->modes;i++){
+ oggpack_write(opb,ci->mode_param[i]->blockflag,1);
+ oggpack_write(opb,ci->mode_param[i]->windowtype,16);
+ oggpack_write(opb,ci->mode_param[i]->transformtype,16);
+ oggpack_write(opb,ci->mode_param[i]->mapping,8);
+ }
+ oggpack_write(opb,1,1);
+
+ return(0);
+err_out:
+ return(-1);
+}
+
+int vorbis_commentheader_out(vorbis_comment *vc,
+ ogg_packet *op){
+
+ oggpack_buffer opb;
+
+ oggpack_writeinit(&opb);
+ if(_vorbis_pack_comment(&opb,vc)){
+ oggpack_writeclear(&opb);
+ return OV_EIMPL;
+ }
+
+ op->packet = _ogg_malloc(oggpack_bytes(&opb));
+ memcpy(op->packet, opb.buffer, oggpack_bytes(&opb));
+
+ op->bytes=oggpack_bytes(&opb);
+ op->b_o_s=0;
+ op->e_o_s=0;
+ op->granulepos=0;
+ op->packetno=1;
+
+ oggpack_writeclear(&opb);
+ return 0;
+}
+
+int vorbis_analysis_headerout(vorbis_dsp_state *v,
+ vorbis_comment *vc,
+ ogg_packet *op,
+ ogg_packet *op_comm,
+ ogg_packet *op_code){
+ int ret=OV_EIMPL;
+ vorbis_info *vi=v->vi;
+ oggpack_buffer opb;
+ private_state *b=v->backend_state;
+
+ if(!b){
+ ret=OV_EFAULT;
+ goto err_out;
+ }
+
+ /* first header packet **********************************************/
+
+ oggpack_writeinit(&opb);
+ if(_vorbis_pack_info(&opb,vi))goto err_out;
+
+ /* build the packet */
+ if(b->header)_ogg_free(b->header);
+ b->header=_ogg_malloc(oggpack_bytes(&opb));
+ memcpy(b->header,opb.buffer,oggpack_bytes(&opb));
+ op->packet=b->header;
+ op->bytes=oggpack_bytes(&opb);
+ op->b_o_s=1;
+ op->e_o_s=0;
+ op->granulepos=0;
+ op->packetno=0;
+
+ /* second header packet (comments) **********************************/
+
+ oggpack_reset(&opb);
+ if(_vorbis_pack_comment(&opb,vc))goto err_out;
+
+ if(b->header1)_ogg_free(b->header1);
+ b->header1=_ogg_malloc(oggpack_bytes(&opb));
+ memcpy(b->header1,opb.buffer,oggpack_bytes(&opb));
+ op_comm->packet=b->header1;
+ op_comm->bytes=oggpack_bytes(&opb);
+ op_comm->b_o_s=0;
+ op_comm->e_o_s=0;
+ op_comm->granulepos=0;
+ op_comm->packetno=1;
+
+ /* third header packet (modes/codebooks) ****************************/
+
+ oggpack_reset(&opb);
+ if(_vorbis_pack_books(&opb,vi))goto err_out;
+
+ if(b->header2)_ogg_free(b->header2);
+ b->header2=_ogg_malloc(oggpack_bytes(&opb));
+ memcpy(b->header2,opb.buffer,oggpack_bytes(&opb));
+ op_code->packet=b->header2;
+ op_code->bytes=oggpack_bytes(&opb);
+ op_code->b_o_s=0;
+ op_code->e_o_s=0;
+ op_code->granulepos=0;
+ op_code->packetno=2;
+
+ oggpack_writeclear(&opb);
+ return(0);
+ err_out:
+ memset(op,0,sizeof(*op));
+ memset(op_comm,0,sizeof(*op_comm));
+ memset(op_code,0,sizeof(*op_code));
+
+ if(b){
+ oggpack_writeclear(&opb);
+ if(b->header)_ogg_free(b->header);
+ if(b->header1)_ogg_free(b->header1);
+ if(b->header2)_ogg_free(b->header2);
+ b->header=NULL;
+ b->header1=NULL;
+ b->header2=NULL;
+ }
+ return(ret);
+}
+
+double vorbis_granule_time(vorbis_dsp_state *v,ogg_int64_t granulepos){
+ if(granulepos == -1) return -1;
+
+ /* We're not guaranteed a 64 bit unsigned type everywhere, so we
+ have to put the unsigned granpo in a signed type. */
+ if(granulepos>=0){
+ return((double)granulepos/v->vi->rate);
+ }else{
+ ogg_int64_t granuleoff=0xffffffff;
+ granuleoff<<=31;
+ granuleoff|=0x7ffffffff;
+ return(((double)granulepos+2+granuleoff+granuleoff)/v->vi->rate);
+ }
+}
+
+const char *vorbis_version_string(void){
+ return GENERAL_VENDOR_STRING;
+}
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: lookup based functions
+ last mod: $Id: lookup.c 16227 2009-07-08 06:58:46Z xiphmont $
+
+ ********************************************************************/
+
+#include <math.h>
+#include "lookup.h"
+#include "lookup_data.h"
+#include "os.h"
+#include "misc.h"
+
+#ifdef FLOAT_LOOKUP
+
+/* interpolated lookup based cos function, domain 0 to PI only */
+float vorbis_coslook(float a){
+ double d=a*(.31830989*(float)COS_LOOKUP_SZ);
+ int i=vorbis_ftoi(d-.5);
+
+ return COS_LOOKUP[i]+ (d-i)*(COS_LOOKUP[i+1]-COS_LOOKUP[i]);
+}
+
+/* interpolated 1./sqrt(p) where .5 <= p < 1. */
+float vorbis_invsqlook(float a){
+ double d=a*(2.f*(float)INVSQ_LOOKUP_SZ)-(float)INVSQ_LOOKUP_SZ;
+ int i=vorbis_ftoi(d-.5f);
+ return INVSQ_LOOKUP[i]+ (d-i)*(INVSQ_LOOKUP[i+1]-INVSQ_LOOKUP[i]);
+}
+
+/* interpolated 1./sqrt(p) where .5 <= p < 1. */
+float vorbis_invsq2explook(int a){
+ return INVSQ2EXP_LOOKUP[a-INVSQ2EXP_LOOKUP_MIN];
+}
+
+#include <stdio.h>
+/* interpolated lookup based fromdB function, domain -140dB to 0dB only */
+float vorbis_fromdBlook(float a){
+ int i=vorbis_ftoi(a*((float)(-(1<<FROMdB2_SHIFT)))-.5f);
+ return (i<0)?1.f:
+ ((i>=(FROMdB_LOOKUP_SZ<<FROMdB_SHIFT))?0.f:
+ FROMdB_LOOKUP[i>>FROMdB_SHIFT]*FROMdB2_LOOKUP[i&FROMdB2_MASK]);
+}
+
+#endif
+
+#ifdef INT_LOOKUP
+/* interpolated 1./sqrt(p) where .5 <= a < 1. (.100000... to .111111...) in
+ 16.16 format
+
+ returns in m.8 format */
+long vorbis_invsqlook_i(long a,long e){
+ long i=(a&0x7fff)>>(INVSQ_LOOKUP_I_SHIFT-1);
+ long d=(a&INVSQ_LOOKUP_I_MASK)<<(16-INVSQ_LOOKUP_I_SHIFT); /* 0.16 */
+ long val=INVSQ_LOOKUP_I[i]- /* 1.16 */
+ (((INVSQ_LOOKUP_I[i]-INVSQ_LOOKUP_I[i+1])* /* 0.16 */
+ d)>>16); /* result 1.16 */
+
+ e+=32;
+ if(e&1)val=(val*5792)>>13; /* multiply val by 1/sqrt(2) */
+ e=(e>>1)-8;
+
+ return(val>>e);
+}
+
+/* interpolated lookup based fromdB function, domain -140dB to 0dB only */
+/* a is in n.12 format */
+float vorbis_fromdBlook_i(long a){
+ int i=(-a)>>(12-FROMdB2_SHIFT);
+ return (i<0)?1.f:
+ ((i>=(FROMdB_LOOKUP_SZ<<FROMdB_SHIFT))?0.f:
+ FROMdB_LOOKUP[i>>FROMdB_SHIFT]*FROMdB2_LOOKUP[i&FROMdB2_MASK]);
+}
+
+/* interpolated lookup based cos function, domain 0 to PI only */
+/* a is in 0.16 format, where 0==0, 2^^16-1==PI, return 0.14 */
+long vorbis_coslook_i(long a){
+ int i=a>>COS_LOOKUP_I_SHIFT;
+ int d=a&COS_LOOKUP_I_MASK;
+ return COS_LOOKUP_I[i]- ((d*(COS_LOOKUP_I[i]-COS_LOOKUP_I[i+1]))>>
+ COS_LOOKUP_I_SHIFT);
+}
+
+#endif
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: lookup based functions
+ last mod: $Id: lookup.h 16227 2009-07-08 06:58:46Z xiphmont $
+
+ ********************************************************************/
+
+#ifndef _V_LOOKUP_H_
+
+#ifdef FLOAT_LOOKUP
+extern float vorbis_coslook(float a);
+extern float vorbis_invsqlook(float a);
+extern float vorbis_invsq2explook(int a);
+extern float vorbis_fromdBlook(float a);
+#endif
+#ifdef INT_LOOKUP
+extern long vorbis_invsqlook_i(long a,long e);
+extern long vorbis_coslook_i(long a);
+extern float vorbis_fromdBlook_i(long a);
+#endif
+
+#endif
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2007 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: lookup data; generated by lookups.pl; edit there
+ last mod: $Id: lookup_data.h 16037 2009-05-26 21:10:58Z xiphmont $
+
+ ********************************************************************/
+
+#ifndef _V_LOOKUP_DATA_H_
+
+#ifdef FLOAT_LOOKUP
+#define COS_LOOKUP_SZ 128
+static const float COS_LOOKUP[COS_LOOKUP_SZ+1]={
+ +1.0000000000000f,+0.9996988186962f,+0.9987954562052f,+0.9972904566787f,
+ +0.9951847266722f,+0.9924795345987f,+0.9891765099648f,+0.9852776423889f,
+ +0.9807852804032f,+0.9757021300385f,+0.9700312531945f,+0.9637760657954f,
+ +0.9569403357322f,+0.9495281805930f,+0.9415440651830f,+0.9329927988347f,
+ +0.9238795325113f,+0.9142097557035f,+0.9039892931234f,+0.8932243011955f,
+ +0.8819212643484f,+0.8700869911087f,+0.8577286100003f,+0.8448535652497f,
+ +0.8314696123025f,+0.8175848131516f,+0.8032075314806f,+0.7883464276266f,
+ +0.7730104533627f,+0.7572088465065f,+0.7409511253550f,+0.7242470829515f,
+ +0.7071067811865f,+0.6895405447371f,+0.6715589548470f,+0.6531728429538f,
+ +0.6343932841636f,+0.6152315905806f,+0.5956993044924f,+0.5758081914178f,
+ +0.5555702330196f,+0.5349976198871f,+0.5141027441932f,+0.4928981922298f,
+ +0.4713967368260f,+0.4496113296546f,+0.4275550934303f,+0.4052413140050f,
+ +0.3826834323651f,+0.3598950365350f,+0.3368898533922f,+0.3136817403989f,
+ +0.2902846772545f,+0.2667127574749f,+0.2429801799033f,+0.2191012401569f,
+ +0.1950903220161f,+0.1709618887603f,+0.1467304744554f,+0.1224106751992f,
+ +0.0980171403296f,+0.0735645635997f,+0.0490676743274f,+0.0245412285229f,
+ +0.0000000000000f,-0.0245412285229f,-0.0490676743274f,-0.0735645635997f,
+ -0.0980171403296f,-0.1224106751992f,-0.1467304744554f,-0.1709618887603f,
+ -0.1950903220161f,-0.2191012401569f,-0.2429801799033f,-0.2667127574749f,
+ -0.2902846772545f,-0.3136817403989f,-0.3368898533922f,-0.3598950365350f,
+ -0.3826834323651f,-0.4052413140050f,-0.4275550934303f,-0.4496113296546f,
+ -0.4713967368260f,-0.4928981922298f,-0.5141027441932f,-0.5349976198871f,
+ -0.5555702330196f,-0.5758081914178f,-0.5956993044924f,-0.6152315905806f,
+ -0.6343932841636f,-0.6531728429538f,-0.6715589548470f,-0.6895405447371f,
+ -0.7071067811865f,-0.7242470829515f,-0.7409511253550f,-0.7572088465065f,
+ -0.7730104533627f,-0.7883464276266f,-0.8032075314806f,-0.8175848131516f,
+ -0.8314696123025f,-0.8448535652497f,-0.8577286100003f,-0.8700869911087f,
+ -0.8819212643484f,-0.8932243011955f,-0.9039892931234f,-0.9142097557035f,
+ -0.9238795325113f,-0.9329927988347f,-0.9415440651830f,-0.9495281805930f,
+ -0.9569403357322f,-0.9637760657954f,-0.9700312531945f,-0.9757021300385f,
+ -0.9807852804032f,-0.9852776423889f,-0.9891765099648f,-0.9924795345987f,
+ -0.9951847266722f,-0.9972904566787f,-0.9987954562052f,-0.9996988186962f,
+ -1.0000000000000f,
+};
+
+#define INVSQ_LOOKUP_SZ 32
+static const float INVSQ_LOOKUP[INVSQ_LOOKUP_SZ+1]={
+ 1.414213562373f,1.392621247646f,1.371988681140f,1.352246807566f,
+ 1.333333333333f,1.315191898443f,1.297771369046f,1.281025230441f,
+ 1.264911064067f,1.249390095109f,1.234426799697f,1.219988562661f,
+ 1.206045378311f,1.192569588000f,1.179535649239f,1.166919931983f,
+ 1.154700538379f,1.142857142857f,1.131370849898f,1.120224067222f,
+ 1.109400392450f,1.098884511590f,1.088662107904f,1.078719779941f,
+ 1.069044967650f,1.059625885652f,1.050451462878f,1.041511287847f,
+ 1.032795558989f,1.024295039463f,1.016001016002f,1.007905261358f,
+ 1.000000000000f,
+};
+
+#define INVSQ2EXP_LOOKUP_MIN (-32)
+#define INVSQ2EXP_LOOKUP_MAX 32
+static const float INVSQ2EXP_LOOKUP[INVSQ2EXP_LOOKUP_MAX-\
+ INVSQ2EXP_LOOKUP_MIN+1]={
+ 65536.f, 46340.95001f, 32768.f, 23170.47501f,
+ 16384.f, 11585.2375f, 8192.f, 5792.618751f,
+ 4096.f, 2896.309376f, 2048.f, 1448.154688f,
+ 1024.f, 724.0773439f, 512.f, 362.038672f,
+ 256.f, 181.019336f, 128.f, 90.50966799f,
+ 64.f, 45.254834f, 32.f, 22.627417f,
+ 16.f, 11.3137085f, 8.f, 5.656854249f,
+ 4.f, 2.828427125f, 2.f, 1.414213562f,
+ 1.f, 0.7071067812f, 0.5f, 0.3535533906f,
+ 0.25f, 0.1767766953f, 0.125f, 0.08838834765f,
+ 0.0625f, 0.04419417382f, 0.03125f, 0.02209708691f,
+ 0.015625f, 0.01104854346f, 0.0078125f, 0.005524271728f,
+ 0.00390625f, 0.002762135864f, 0.001953125f, 0.001381067932f,
+ 0.0009765625f, 0.000690533966f, 0.00048828125f, 0.000345266983f,
+ 0.000244140625f,0.0001726334915f,0.0001220703125f,8.631674575e-05f,
+ 6.103515625e-05f,4.315837288e-05f,3.051757812e-05f,2.157918644e-05f,
+ 1.525878906e-05f,
+};
+
+#endif
+
+#define FROMdB_LOOKUP_SZ 35
+#define FROMdB2_LOOKUP_SZ 32
+#define FROMdB_SHIFT 5
+#define FROMdB2_SHIFT 3
+#define FROMdB2_MASK 31
+
+#ifdef FLOAT_LOOKUP
+static const float FROMdB_LOOKUP[FROMdB_LOOKUP_SZ]={
+ 1.f, 0.6309573445f, 0.3981071706f, 0.2511886432f,
+ 0.1584893192f, 0.1f, 0.06309573445f, 0.03981071706f,
+ 0.02511886432f, 0.01584893192f, 0.01f, 0.006309573445f,
+ 0.003981071706f, 0.002511886432f, 0.001584893192f, 0.001f,
+ 0.0006309573445f,0.0003981071706f,0.0002511886432f,0.0001584893192f,
+ 0.0001f,6.309573445e-05f,3.981071706e-05f,2.511886432e-05f,
+ 1.584893192e-05f, 1e-05f,6.309573445e-06f,3.981071706e-06f,
+ 2.511886432e-06f,1.584893192e-06f, 1e-06f,6.309573445e-07f,
+ 3.981071706e-07f,2.511886432e-07f,1.584893192e-07f,
+};
+
+static const float FROMdB2_LOOKUP[FROMdB2_LOOKUP_SZ]={
+ 0.9928302478f, 0.9786445908f, 0.9646616199f, 0.9508784391f,
+ 0.9372921937f, 0.92390007f, 0.9106992942f, 0.8976871324f,
+ 0.8848608897f, 0.8722179097f, 0.8597555737f, 0.8474713009f,
+ 0.835362547f, 0.8234268041f, 0.8116616003f, 0.8000644989f,
+ 0.7886330981f, 0.7773650302f, 0.7662579617f, 0.755309592f,
+ 0.7445176537f, 0.7338799116f, 0.7233941627f, 0.7130582353f,
+ 0.7028699885f, 0.6928273125f, 0.6829281272f, 0.6731703824f,
+ 0.6635520573f, 0.6540711597f, 0.6447257262f, 0.6355138211f,
+};
+#endif
+
+#ifdef INT_LOOKUP
+
+#define INVSQ_LOOKUP_I_SHIFT 10
+#define INVSQ_LOOKUP_I_MASK 1023
+static const long INVSQ_LOOKUP_I[64+1]={
+ 92682l, 91966l, 91267l, 90583l,
+ 89915l, 89261l, 88621l, 87995l,
+ 87381l, 86781l, 86192l, 85616l,
+ 85051l, 84497l, 83953l, 83420l,
+ 82897l, 82384l, 81880l, 81385l,
+ 80899l, 80422l, 79953l, 79492l,
+ 79039l, 78594l, 78156l, 77726l,
+ 77302l, 76885l, 76475l, 76072l,
+ 75674l, 75283l, 74898l, 74519l,
+ 74146l, 73778l, 73415l, 73058l,
+ 72706l, 72359l, 72016l, 71679l,
+ 71347l, 71019l, 70695l, 70376l,
+ 70061l, 69750l, 69444l, 69141l,
+ 68842l, 68548l, 68256l, 67969l,
+ 67685l, 67405l, 67128l, 66855l,
+ 66585l, 66318l, 66054l, 65794l,
+ 65536l,
+};
+
+#define COS_LOOKUP_I_SHIFT 9
+#define COS_LOOKUP_I_MASK 511
+#define COS_LOOKUP_I_SZ 128
+static const long COS_LOOKUP_I[COS_LOOKUP_I_SZ+1]={
+ 16384l, 16379l, 16364l, 16340l,
+ 16305l, 16261l, 16207l, 16143l,
+ 16069l, 15986l, 15893l, 15791l,
+ 15679l, 15557l, 15426l, 15286l,
+ 15137l, 14978l, 14811l, 14635l,
+ 14449l, 14256l, 14053l, 13842l,
+ 13623l, 13395l, 13160l, 12916l,
+ 12665l, 12406l, 12140l, 11866l,
+ 11585l, 11297l, 11003l, 10702l,
+ 10394l, 10080l, 9760l, 9434l,
+ 9102l, 8765l, 8423l, 8076l,
+ 7723l, 7366l, 7005l, 6639l,
+ 6270l, 5897l, 5520l, 5139l,
+ 4756l, 4370l, 3981l, 3590l,
+ 3196l, 2801l, 2404l, 2006l,
+ 1606l, 1205l, 804l, 402l,
+ 0l, -401l, -803l, -1204l,
+ -1605l, -2005l, -2403l, -2800l,
+ -3195l, -3589l, -3980l, -4369l,
+ -4755l, -5138l, -5519l, -5896l,
+ -6269l, -6638l, -7004l, -7365l,
+ -7722l, -8075l, -8422l, -8764l,
+ -9101l, -9433l, -9759l, -10079l,
+ -10393l, -10701l, -11002l, -11296l,
+ -11584l, -11865l, -12139l, -12405l,
+ -12664l, -12915l, -13159l, -13394l,
+ -13622l, -13841l, -14052l, -14255l,
+ -14448l, -14634l, -14810l, -14977l,
+ -15136l, -15285l, -15425l, -15556l,
+ -15678l, -15790l, -15892l, -15985l,
+ -16068l, -16142l, -16206l, -16260l,
+ -16304l, -16339l, -16363l, -16378l,
+ -16383l,
+};
+
+#endif
+
+#endif
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: LPC low level routines
+ last mod: $Id: lpc.c 16227 2009-07-08 06:58:46Z xiphmont $
+
+ ********************************************************************/
+
+/* Some of these routines (autocorrelator, LPC coefficient estimator)
+ are derived from code written by Jutta Degener and Carsten Bormann;
+ thus we include their copyright below. The entirety of this file
+ is freely redistributable on the condition that both of these
+ copyright notices are preserved without modification. */
+
+/* Preserved Copyright: *********************************************/
+
+/* Copyright 1992, 1993, 1994 by Jutta Degener and Carsten Bormann,
+Technische Universita"t Berlin
+
+Any use of this software is permitted provided that this notice is not
+removed and that neither the authors nor the Technische Universita"t
+Berlin are deemed to have made any representations as to the
+suitability of this software for any purpose nor are held responsible
+for any defects of this software. THERE IS ABSOLUTELY NO WARRANTY FOR
+THIS SOFTWARE.
+
+As a matter of courtesy, the authors request to be informed about uses
+this software has found, about bugs in this software, and about any
+improvements that may be of general interest.
+
+Berlin, 28.11.1994
+Jutta Degener
+Carsten Bormann
+
+*********************************************************************/
+
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include "os.h"
+#include "smallft.h"
+#include "lpc.h"
+#include "scales.h"
+#include "misc.h"
+
+/* Autocorrelation LPC coeff generation algorithm invented by
+ N. Levinson in 1947, modified by J. Durbin in 1959. */
+
+/* Input : n elements of time doamin data
+ Output: m lpc coefficients, excitation energy */
+
+float vorbis_lpc_from_data(float *data,float *lpci,int n,int m){
+ double *aut=alloca(sizeof(*aut)*(m+1));
+ double *lpc=alloca(sizeof(*lpc)*(m));
+ double error;
+ double epsilon;
+ int i,j;
+
+ /* autocorrelation, p+1 lag coefficients */
+ j=m+1;
+ while(j--){
+ double d=0; /* double needed for accumulator depth */
+ for(i=j;i<n;i++)d+=(double)data[i]*data[i-j];
+ aut[j]=d;
+ }
+
+ /* Generate lpc coefficients from autocorr values */
+
+ /* set our noise floor to about -100dB */
+ error=aut[0] * (1. + 1e-10);
+ epsilon=1e-9*aut[0]+1e-10;
+
+ for(i=0;i<m;i++){
+ double r= -aut[i+1];
+
+ if(error<epsilon){
+ memset(lpc+i,0,(m-i)*sizeof(*lpc));
+ goto done;
+ }
+
+ /* Sum up this iteration's reflection coefficient; note that in
+ Vorbis we don't save it. If anyone wants to recycle this code
+ and needs reflection coefficients, save the results of 'r' from
+ each iteration. */
+
+ for(j=0;j<i;j++)r-=lpc[j]*aut[i-j];
+ r/=error;
+
+ /* Update LPC coefficients and total error */
+
+ lpc[i]=r;
+ for(j=0;j<i/2;j++){
+ double tmp=lpc[j];
+
+ lpc[j]+=r*lpc[i-1-j];
+ lpc[i-1-j]+=r*tmp;
+ }
+ if(i&1)lpc[j]+=lpc[j]*r;
+
+ error*=1.-r*r;
+
+ }
+
+ done:
+
+ /* slightly damp the filter */
+ {
+ double g = .99;
+ double damp = g;
+ for(j=0;j<m;j++){
+ lpc[j]*=damp;
+ damp*=g;
+ }
+ }
+
+ for(j=0;j<m;j++)lpci[j]=(float)lpc[j];
+
+ /* we need the error value to know how big an impulse to hit the
+ filter with later */
+
+ return error;
+}
+
+void vorbis_lpc_predict(float *coeff,float *prime,int m,
+ float *data,long n){
+
+ /* in: coeff[0...m-1] LPC coefficients
+ prime[0...m-1] initial values (allocated size of n+m-1)
+ out: data[0...n-1] data samples */
+
+ long i,j,o,p;
+ float y;
+ float *work=alloca(sizeof(*work)*(m+n));
+
+ if(!prime)
+ for(i=0;i<m;i++)
+ work[i]=0.f;
+ else
+ for(i=0;i<m;i++)
+ work[i]=prime[i];
+
+ for(i=0;i<n;i++){
+ y=0;
+ o=i;
+ p=m;
+ for(j=0;j<m;j++)
+ y-=work[o++]*coeff[--p];
+
+ data[i]=work[o]=y;
+ }
+}
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2007 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: LPC low level routines
+ last mod: $Id: lpc.h 16037 2009-05-26 21:10:58Z xiphmont $
+
+ ********************************************************************/
+
+#ifndef _V_LPC_H_
+#define _V_LPC_H_
+
+#include "vorbis/codec.h"
+
+/* simple linear scale LPC code */
+extern float vorbis_lpc_from_data(float *data,float *lpc,int n,int m);
+
+extern void vorbis_lpc_predict(float *coeff,float *prime,int m,
+ float *data,long n);
+
+#endif
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: LSP (also called LSF) conversion routines
+ last mod: $Id: lsp.c 17538 2010-10-15 02:52:29Z tterribe $
+
+ The LSP generation code is taken (with minimal modification and a
+ few bugfixes) from "On the Computation of the LSP Frequencies" by
+ Joseph Rothweiler (see http://www.rothweiler.us for contact info).
+ The paper is available at:
+
+ http://www.myown1.com/joe/lsf
+
+ ********************************************************************/
+
+/* Note that the lpc-lsp conversion finds the roots of polynomial with
+ an iterative root polisher (CACM algorithm 283). It *is* possible
+ to confuse this algorithm into not converging; that should only
+ happen with absurdly closely spaced roots (very sharp peaks in the
+ LPC f response) which in turn should be impossible in our use of
+ the code. If this *does* happen anyway, it's a bug in the floor
+ finder; find the cause of the confusion (probably a single bin
+ spike or accidental near-float-limit resolution problems) and
+ correct it. */
+
+#include <math.h>
+#include <string.h>
+#include <stdlib.h>
+#include "lsp.h"
+#include "os.h"
+#include "misc.h"
+#include "lookup.h"
+#include "scales.h"
+
+/* three possible LSP to f curve functions; the exact computation
+ (float), a lookup based float implementation, and an integer
+ implementation. The float lookup is likely the optimal choice on
+ any machine with an FPU. The integer implementation is *not* fixed
+ point (due to the need for a large dynamic range and thus a
+ separately tracked exponent) and thus much more complex than the
+ relatively simple float implementations. It's mostly for future
+ work on a fully fixed point implementation for processors like the
+ ARM family. */
+
+/* define either of these (preferably FLOAT_LOOKUP) to have faster
+ but less precise implementation. */
+#undef FLOAT_LOOKUP
+#undef INT_LOOKUP
+
+#ifdef FLOAT_LOOKUP
+#include "lookup.c" /* catch this in the build system; we #include for
+ compilers (like gcc) that can't inline across
+ modules */
+
+/* side effect: changes *lsp to cosines of lsp */
+void vorbis_lsp_to_curve(float *curve,int *map,int n,int ln,float *lsp,int m,
+ float amp,float ampoffset){
+ int i;
+ float wdel=M_PI/ln;
+ vorbis_fpu_control fpu;
+
+ vorbis_fpu_setround(&fpu);
+ for(i=0;i<m;i++)lsp[i]=vorbis_coslook(lsp[i]);
+
+ i=0;
+ while(i<n){
+ int k=map[i];
+ int qexp;
+ float p=.7071067812f;
+ float q=.7071067812f;
+ float w=vorbis_coslook(wdel*k);
+ float *ftmp=lsp;
+ int c=m>>1;
+
+ while(c--){
+ q*=ftmp[0]-w;
+ p*=ftmp[1]-w;
+ ftmp+=2;
+ }
+
+ if(m&1){
+ /* odd order filter; slightly assymetric */
+ /* the last coefficient */
+ q*=ftmp[0]-w;
+ q*=q;
+ p*=p*(1.f-w*w);
+ }else{
+ /* even order filter; still symmetric */
+ q*=q*(1.f+w);
+ p*=p*(1.f-w);
+ }
+
+ q=frexp(p+q,&qexp);
+ q=vorbis_fromdBlook(amp*
+ vorbis_invsqlook(q)*
+ vorbis_invsq2explook(qexp+m)-
+ ampoffset);
+
+ do{
+ curve[i++]*=q;
+ }while(map[i]==k);
+ }
+ vorbis_fpu_restore(fpu);
+}
+
+#else
+
+#ifdef INT_LOOKUP
+#include "lookup.c" /* catch this in the build system; we #include for
+ compilers (like gcc) that can't inline across
+ modules */
+
+static const int MLOOP_1[64]={
+ 0,10,11,11, 12,12,12,12, 13,13,13,13, 13,13,13,13,
+ 14,14,14,14, 14,14,14,14, 14,14,14,14, 14,14,14,14,
+ 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15,
+ 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15,
+};
+
+static const int MLOOP_2[64]={
+ 0,4,5,5, 6,6,6,6, 7,7,7,7, 7,7,7,7,
+ 8,8,8,8, 8,8,8,8, 8,8,8,8, 8,8,8,8,
+ 9,9,9,9, 9,9,9,9, 9,9,9,9, 9,9,9,9,
+ 9,9,9,9, 9,9,9,9, 9,9,9,9, 9,9,9,9,
+};
+
+static const int MLOOP_3[8]={0,1,2,2,3,3,3,3};
+
+
+/* side effect: changes *lsp to cosines of lsp */
+void vorbis_lsp_to_curve(float *curve,int *map,int n,int ln,float *lsp,int m,
+ float amp,float ampoffset){
+
+ /* 0 <= m < 256 */
+
+ /* set up for using all int later */
+ int i;
+ int ampoffseti=rint(ampoffset*4096.f);
+ int ampi=rint(amp*16.f);
+ long *ilsp=alloca(m*sizeof(*ilsp));
+ for(i=0;i<m;i++)ilsp[i]=vorbis_coslook_i(lsp[i]/M_PI*65536.f+.5f);
+
+ i=0;
+ while(i<n){
+ int j,k=map[i];
+ unsigned long pi=46341; /* 2**-.5 in 0.16 */
+ unsigned long qi=46341;
+ int qexp=0,shift;
+ long wi=vorbis_coslook_i(k*65536/ln);
+
+ qi*=labs(ilsp[0]-wi);
+ pi*=labs(ilsp[1]-wi);
+
+ for(j=3;j<m;j+=2){
+ if(!(shift=MLOOP_1[(pi|qi)>>25]))
+ if(!(shift=MLOOP_2[(pi|qi)>>19]))
+ shift=MLOOP_3[(pi|qi)>>16];
+ qi=(qi>>shift)*labs(ilsp[j-1]-wi);
+ pi=(pi>>shift)*labs(ilsp[j]-wi);
+ qexp+=shift;
+ }
+ if(!(shift=MLOOP_1[(pi|qi)>>25]))
+ if(!(shift=MLOOP_2[(pi|qi)>>19]))
+ shift=MLOOP_3[(pi|qi)>>16];
+
+ /* pi,qi normalized collectively, both tracked using qexp */
+
+ if(m&1){
+ /* odd order filter; slightly assymetric */
+ /* the last coefficient */
+ qi=(qi>>shift)*labs(ilsp[j-1]-wi);
+ pi=(pi>>shift)<<14;
+ qexp+=shift;
+
+ if(!(shift=MLOOP_1[(pi|qi)>>25]))
+ if(!(shift=MLOOP_2[(pi|qi)>>19]))
+ shift=MLOOP_3[(pi|qi)>>16];
+
+ pi>>=shift;
+ qi>>=shift;
+ qexp+=shift-14*((m+1)>>1);
+
+ pi=((pi*pi)>>16);
+ qi=((qi*qi)>>16);
+ qexp=qexp*2+m;
+
+ pi*=(1<<14)-((wi*wi)>>14);
+ qi+=pi>>14;
+
+ }else{
+ /* even order filter; still symmetric */
+
+ /* p*=p(1-w), q*=q(1+w), let normalization drift because it isn't
+ worth tracking step by step */
+
+ pi>>=shift;
+ qi>>=shift;
+ qexp+=shift-7*m;
+
+ pi=((pi*pi)>>16);
+ qi=((qi*qi)>>16);
+ qexp=qexp*2+m;
+
+ pi*=(1<<14)-wi;
+ qi*=(1<<14)+wi;
+ qi=(qi+pi)>>14;
+
+ }
+
+
+ /* we've let the normalization drift because it wasn't important;
+ however, for the lookup, things must be normalized again. We
+ need at most one right shift or a number of left shifts */
+
+ if(qi&0xffff0000){ /* checks for 1.xxxxxxxxxxxxxxxx */
+ qi>>=1; qexp++;
+ }else
+ while(qi && !(qi&0x8000)){ /* checks for 0.0xxxxxxxxxxxxxxx or less*/
+ qi<<=1; qexp--;
+ }
+
+ amp=vorbis_fromdBlook_i(ampi* /* n.4 */
+ vorbis_invsqlook_i(qi,qexp)-
+ /* m.8, m+n<=8 */
+ ampoffseti); /* 8.12[0] */
+
+ curve[i]*=amp;
+ while(map[++i]==k)curve[i]*=amp;
+ }
+}
+
+#else
+
+/* old, nonoptimized but simple version for any poor sap who needs to
+ figure out what the hell this code does, or wants the other
+ fraction of a dB precision */
+
+/* side effect: changes *lsp to cosines of lsp */
+void vorbis_lsp_to_curve(float *curve,int *map,int n,int ln,float *lsp,int m,
+ float amp,float ampoffset){
+ int i;
+ float wdel=M_PI/ln;
+ for(i=0;i<m;i++)lsp[i]=2.f*cos(lsp[i]);
+
+ i=0;
+ while(i<n){
+ int j,k=map[i];
+ float p=.5f;
+ float q=.5f;
+ float w=2.f*cos(wdel*k);
+ for(j=1;j<m;j+=2){
+ q *= w-lsp[j-1];
+ p *= w-lsp[j];
+ }
+ if(j==m){
+ /* odd order filter; slightly assymetric */
+ /* the last coefficient */
+ q*=w-lsp[j-1];
+ p*=p*(4.f-w*w);
+ q*=q;
+ }else{
+ /* even order filter; still symmetric */
+ p*=p*(2.f-w);
+ q*=q*(2.f+w);
+ }
+
+ q=fromdB(amp/sqrt(p+q)-ampoffset);
+
+ curve[i]*=q;
+ while(map[++i]==k)curve[i]*=q;
+ }
+}
+
+#endif
+#endif
+
+static void cheby(float *g, int ord) {
+ int i, j;
+
+ g[0] *= .5f;
+ for(i=2; i<= ord; i++) {
+ for(j=ord; j >= i; j--) {
+ g[j-2] -= g[j];
+ g[j] += g[j];
+ }
+ }
+}
+
+static int comp(const void *a,const void *b){
+ return (*(float *)a<*(float *)b)-(*(float *)a>*(float *)b);
+}
+
+/* Newton-Raphson-Maehly actually functioned as a decent root finder,
+ but there are root sets for which it gets into limit cycles
+ (exacerbated by zero suppression) and fails. We can't afford to
+ fail, even if the failure is 1 in 100,000,000, so we now use
+ Laguerre and later polish with Newton-Raphson (which can then
+ afford to fail) */
+
+#define EPSILON 10e-7
+static int Laguerre_With_Deflation(float *a,int ord,float *r){
+ int i,m;
+ double *defl=alloca(sizeof(*defl)*(ord+1));
+ for(i=0;i<=ord;i++)defl[i]=a[i];
+
+ for(m=ord;m>0;m--){
+ double new=0.f,delta;
+
+ /* iterate a root */
+ while(1){
+ double p=defl[m],pp=0.f,ppp=0.f,denom;
+
+ /* eval the polynomial and its first two derivatives */
+ for(i=m;i>0;i--){
+ ppp = new*ppp + pp;
+ pp = new*pp + p;
+ p = new*p + defl[i-1];
+ }
+
+ /* Laguerre's method */
+ denom=(m-1) * ((m-1)*pp*pp - m*p*ppp);
+ if(denom<0)
+ return(-1); /* complex root! The LPC generator handed us a bad filter */
+
+ if(pp>0){
+ denom = pp + sqrt(denom);
+ if(denom<EPSILON)denom=EPSILON;
+ }else{
+ denom = pp - sqrt(denom);
+ if(denom>-(EPSILON))denom=-(EPSILON);
+ }
+
+ delta = m*p/denom;
+ new -= delta;
+
+ if(delta<0.f)delta*=-1;
+
+ if(fabs(delta/new)<10e-12)break;
+ }
+
+ r[m-1]=new;
+
+ /* forward deflation */
+
+ for(i=m;i>0;i--)
+ defl[i-1]+=new*defl[i];
+ defl++;
+
+ }
+ return(0);
+}
+
+
+/* for spit-and-polish only */
+static int Newton_Raphson(float *a,int ord,float *r){
+ int i, k, count=0;
+ double error=1.f;
+ double *root=alloca(ord*sizeof(*root));
+
+ for(i=0; i<ord;i++) root[i] = r[i];
+
+ while(error>1e-20){
+ error=0;
+
+ for(i=0; i<ord; i++) { /* Update each point. */
+ double pp=0.,delta;
+ double rooti=root[i];
+ double p=a[ord];
+ for(k=ord-1; k>= 0; k--) {
+
+ pp= pp* rooti + p;
+ p = p * rooti + a[k];
+ }
+
+ delta = p/pp;
+ root[i] -= delta;
+ error+= delta*delta;
+ }
+
+ if(count>40)return(-1);
+
+ count++;
+ }
+
+ /* Replaced the original bubble sort with a real sort. With your
+ help, we can eliminate the bubble sort in our lifetime. --Monty */
+
+ for(i=0; i<ord;i++) r[i] = root[i];
+ return(0);
+}
+
+
+/* Convert lpc coefficients to lsp coefficients */
+int vorbis_lpc_to_lsp(float *lpc,float *lsp,int m){
+ int order2=(m+1)>>1;
+ int g1_order,g2_order;
+ float *g1=alloca(sizeof(*g1)*(order2+1));
+ float *g2=alloca(sizeof(*g2)*(order2+1));
+ float *g1r=alloca(sizeof(*g1r)*(order2+1));
+ float *g2r=alloca(sizeof(*g2r)*(order2+1));
+ int i;
+
+ /* even and odd are slightly different base cases */
+ g1_order=(m+1)>>1;
+ g2_order=(m) >>1;
+
+ /* Compute the lengths of the x polynomials. */
+ /* Compute the first half of K & R F1 & F2 polynomials. */
+ /* Compute half of the symmetric and antisymmetric polynomials. */
+ /* Remove the roots at +1 and -1. */
+
+ g1[g1_order] = 1.f;
+ for(i=1;i<=g1_order;i++) g1[g1_order-i] = lpc[i-1]+lpc[m-i];
+ g2[g2_order] = 1.f;
+ for(i=1;i<=g2_order;i++) g2[g2_order-i] = lpc[i-1]-lpc[m-i];
+
+ if(g1_order>g2_order){
+ for(i=2; i<=g2_order;i++) g2[g2_order-i] += g2[g2_order-i+2];
+ }else{
+ for(i=1; i<=g1_order;i++) g1[g1_order-i] -= g1[g1_order-i+1];
+ for(i=1; i<=g2_order;i++) g2[g2_order-i] += g2[g2_order-i+1];
+ }
+
+ /* Convert into polynomials in cos(alpha) */
+ cheby(g1,g1_order);
+ cheby(g2,g2_order);
+
+ /* Find the roots of the 2 even polynomials.*/
+ if(Laguerre_With_Deflation(g1,g1_order,g1r) ||
+ Laguerre_With_Deflation(g2,g2_order,g2r))
+ return(-1);
+
+ Newton_Raphson(g1,g1_order,g1r); /* if it fails, it leaves g1r alone */
+ Newton_Raphson(g2,g2_order,g2r); /* if it fails, it leaves g2r alone */
+
+ qsort(g1r,g1_order,sizeof(*g1r),comp);
+ qsort(g2r,g2_order,sizeof(*g2r),comp);
+
+ for(i=0;i<g1_order;i++)
+ lsp[i*2] = acos(g1r[i]);
+
+ for(i=0;i<g2_order;i++)
+ lsp[i*2+1] = acos(g2r[i]);
+ return(0);
+}
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: LSP (also called LSF) conversion routines
+ last mod: $Id: lsp.h 16227 2009-07-08 06:58:46Z xiphmont $
+
+ ********************************************************************/
+
+
+#ifndef _V_LSP_H_
+#define _V_LSP_H_
+
+extern int vorbis_lpc_to_lsp(float *lpc,float *lsp,int m);
+
+extern void vorbis_lsp_to_curve(float *curve,int *map,int n,int ln,
+ float *lsp,int m,
+ float amp,float ampoffset);
+
+#endif
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2010 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: channel mapping 0 implementation
+ last mod: $Id: mapping0.c 17022 2010-03-25 03:45:42Z xiphmont $
+
+ ********************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <ogg/ogg.h>
+#include "vorbis/codec.h"
+#include "codec_internal.h"
+#include "codebook.h"
+#include "window.h"
+#include "registry.h"
+#include "psy.h"
+#include "misc.h"
+
+/* simplistic, wasteful way of doing this (unique lookup for each
+ mode/submapping); there should be a central repository for
+ identical lookups. That will require minor work, so I'm putting it
+ off as low priority.
+
+ Why a lookup for each backend in a given mode? Because the
+ blocksize is set by the mode, and low backend lookups may require
+ parameters from other areas of the mode/mapping */
+
+static void mapping0_free_info(vorbis_info_mapping *i){
+ vorbis_info_mapping0 *info=(vorbis_info_mapping0 *)i;
+ if(info){
+ memset(info,0,sizeof(*info));
+ _ogg_free(info);
+ }
+}
+
+static int ilog(unsigned int v){
+ int ret=0;
+ if(v)--v;
+ while(v){
+ ret++;
+ v>>=1;
+ }
+ return(ret);
+}
+
+static void mapping0_pack(vorbis_info *vi,vorbis_info_mapping *vm,
+ oggpack_buffer *opb){
+ int i;
+ vorbis_info_mapping0 *info=(vorbis_info_mapping0 *)vm;
+
+ /* another 'we meant to do it this way' hack... up to beta 4, we
+ packed 4 binary zeros here to signify one submapping in use. We
+ now redefine that to mean four bitflags that indicate use of
+ deeper features; bit0:submappings, bit1:coupling,
+ bit2,3:reserved. This is backward compatable with all actual uses
+ of the beta code. */
+
+ if(info->submaps>1){
+ oggpack_write(opb,1,1);
+ oggpack_write(opb,info->submaps-1,4);
+ }else
+ oggpack_write(opb,0,1);
+
+ if(info->coupling_steps>0){
+ oggpack_write(opb,1,1);
+ oggpack_write(opb,info->coupling_steps-1,8);
+
+ for(i=0;i<info->coupling_steps;i++){
+ oggpack_write(opb,info->coupling_mag[i],ilog(vi->channels));
+ oggpack_write(opb,info->coupling_ang[i],ilog(vi->channels));
+ }
+ }else
+ oggpack_write(opb,0,1);
+
+ oggpack_write(opb,0,2); /* 2,3:reserved */
+
+ /* we don't write the channel submappings if we only have one... */
+ if(info->submaps>1){
+ for(i=0;i<vi->channels;i++)
+ oggpack_write(opb,info->chmuxlist[i],4);
+ }
+ for(i=0;i<info->submaps;i++){
+ oggpack_write(opb,0,8); /* time submap unused */
+ oggpack_write(opb,info->floorsubmap[i],8);
+ oggpack_write(opb,info->residuesubmap[i],8);
+ }
+}
+
+/* also responsible for range checking */
+static vorbis_info_mapping *mapping0_unpack(vorbis_info *vi,oggpack_buffer *opb){
+ int i,b;
+ vorbis_info_mapping0 *info=_ogg_calloc(1,sizeof(*info));
+ codec_setup_info *ci=vi->codec_setup;
+ memset(info,0,sizeof(*info));
+
+ b=oggpack_read(opb,1);
+ if(b<0)goto err_out;
+ if(b){
+ info->submaps=oggpack_read(opb,4)+1;
+ if(info->submaps<=0)goto err_out;
+ }else
+ info->submaps=1;
+
+ b=oggpack_read(opb,1);
+ if(b<0)goto err_out;
+ if(b){
+ info->coupling_steps=oggpack_read(opb,8)+1;
+ if(info->coupling_steps<=0)goto err_out;
+ for(i=0;i<info->coupling_steps;i++){
+ int testM=info->coupling_mag[i]=oggpack_read(opb,ilog(vi->channels));
+ int testA=info->coupling_ang[i]=oggpack_read(opb,ilog(vi->channels));
+
+ if(testM<0 ||
+ testA<0 ||
+ testM==testA ||
+ testM>=vi->channels ||
+ testA>=vi->channels) goto err_out;
+ }
+
+ }
+
+ if(oggpack_read(opb,2)!=0)goto err_out; /* 2,3:reserved */
+
+ if(info->submaps>1){
+ for(i=0;i<vi->channels;i++){
+ info->chmuxlist[i]=oggpack_read(opb,4);
+ if(info->chmuxlist[i]>=info->submaps || info->chmuxlist[i]<0)goto err_out;
+ }
+ }
+ for(i=0;i<info->submaps;i++){
+ oggpack_read(opb,8); /* time submap unused */
+ info->floorsubmap[i]=oggpack_read(opb,8);
+ if(info->floorsubmap[i]>=ci->floors || info->floorsubmap[i]<0)goto err_out;
+ info->residuesubmap[i]=oggpack_read(opb,8);
+ if(info->residuesubmap[i]>=ci->residues || info->residuesubmap[i]<0)goto err_out;
+ }
+
+ return info;
+
+ err_out:
+ mapping0_free_info(info);
+ return(NULL);
+}
+
+#include "os.h"
+#include "lpc.h"
+#include "lsp.h"
+#include "envelope.h"
+#include "mdct.h"
+#include "psy.h"
+#include "scales.h"
+
+#if 0
+static long seq=0;
+static ogg_int64_t total=0;
+static float FLOOR1_fromdB_LOOKUP[256]={
+ 1.0649863e-07F, 1.1341951e-07F, 1.2079015e-07F, 1.2863978e-07F,
+ 1.3699951e-07F, 1.4590251e-07F, 1.5538408e-07F, 1.6548181e-07F,
+ 1.7623575e-07F, 1.8768855e-07F, 1.9988561e-07F, 2.128753e-07F,
+ 2.2670913e-07F, 2.4144197e-07F, 2.5713223e-07F, 2.7384213e-07F,
+ 2.9163793e-07F, 3.1059021e-07F, 3.3077411e-07F, 3.5226968e-07F,
+ 3.7516214e-07F, 3.9954229e-07F, 4.2550680e-07F, 4.5315863e-07F,
+ 4.8260743e-07F, 5.1396998e-07F, 5.4737065e-07F, 5.8294187e-07F,
+ 6.2082472e-07F, 6.6116941e-07F, 7.0413592e-07F, 7.4989464e-07F,
+ 7.9862701e-07F, 8.5052630e-07F, 9.0579828e-07F, 9.6466216e-07F,
+ 1.0273513e-06F, 1.0941144e-06F, 1.1652161e-06F, 1.2409384e-06F,
+ 1.3215816e-06F, 1.4074654e-06F, 1.4989305e-06F, 1.5963394e-06F,
+ 1.7000785e-06F, 1.8105592e-06F, 1.9282195e-06F, 2.0535261e-06F,
+ 2.1869758e-06F, 2.3290978e-06F, 2.4804557e-06F, 2.6416497e-06F,
+ 2.8133190e-06F, 2.9961443e-06F, 3.1908506e-06F, 3.3982101e-06F,
+ 3.6190449e-06F, 3.8542308e-06F, 4.1047004e-06F, 4.3714470e-06F,
+ 4.6555282e-06F, 4.9580707e-06F, 5.2802740e-06F, 5.6234160e-06F,
+ 5.9888572e-06F, 6.3780469e-06F, 6.7925283e-06F, 7.2339451e-06F,
+ 7.7040476e-06F, 8.2047000e-06F, 8.7378876e-06F, 9.3057248e-06F,
+ 9.9104632e-06F, 1.0554501e-05F, 1.1240392e-05F, 1.1970856e-05F,
+ 1.2748789e-05F, 1.3577278e-05F, 1.4459606e-05F, 1.5399272e-05F,
+ 1.6400004e-05F, 1.7465768e-05F, 1.8600792e-05F, 1.9809576e-05F,
+ 2.1096914e-05F, 2.2467911e-05F, 2.3928002e-05F, 2.5482978e-05F,
+ 2.7139006e-05F, 2.8902651e-05F, 3.0780908e-05F, 3.2781225e-05F,
+ 3.4911534e-05F, 3.7180282e-05F, 3.9596466e-05F, 4.2169667e-05F,
+ 4.4910090e-05F, 4.7828601e-05F, 5.0936773e-05F, 5.4246931e-05F,
+ 5.7772202e-05F, 6.1526565e-05F, 6.5524908e-05F, 6.9783085e-05F,
+ 7.4317983e-05F, 7.9147585e-05F, 8.4291040e-05F, 8.9768747e-05F,
+ 9.5602426e-05F, 0.00010181521F, 0.00010843174F, 0.00011547824F,
+ 0.00012298267F, 0.00013097477F, 0.00013948625F, 0.00014855085F,
+ 0.00015820453F, 0.00016848555F, 0.00017943469F, 0.00019109536F,
+ 0.00020351382F, 0.00021673929F, 0.00023082423F, 0.00024582449F,
+ 0.00026179955F, 0.00027881276F, 0.00029693158F, 0.00031622787F,
+ 0.00033677814F, 0.00035866388F, 0.00038197188F, 0.00040679456F,
+ 0.00043323036F, 0.00046138411F, 0.00049136745F, 0.00052329927F,
+ 0.00055730621F, 0.00059352311F, 0.00063209358F, 0.00067317058F,
+ 0.00071691700F, 0.00076350630F, 0.00081312324F, 0.00086596457F,
+ 0.00092223983F, 0.00098217216F, 0.0010459992F, 0.0011139742F,
+ 0.0011863665F, 0.0012634633F, 0.0013455702F, 0.0014330129F,
+ 0.0015261382F, 0.0016253153F, 0.0017309374F, 0.0018434235F,
+ 0.0019632195F, 0.0020908006F, 0.0022266726F, 0.0023713743F,
+ 0.0025254795F, 0.0026895994F, 0.0028643847F, 0.0030505286F,
+ 0.0032487691F, 0.0034598925F, 0.0036847358F, 0.0039241906F,
+ 0.0041792066F, 0.0044507950F, 0.0047400328F, 0.0050480668F,
+ 0.0053761186F, 0.0057254891F, 0.0060975636F, 0.0064938176F,
+ 0.0069158225F, 0.0073652516F, 0.0078438871F, 0.0083536271F,
+ 0.0088964928F, 0.009474637F, 0.010090352F, 0.010746080F,
+ 0.011444421F, 0.012188144F, 0.012980198F, 0.013823725F,
+ 0.014722068F, 0.015678791F, 0.016697687F, 0.017782797F,
+ 0.018938423F, 0.020169149F, 0.021479854F, 0.022875735F,
+ 0.024362330F, 0.025945531F, 0.027631618F, 0.029427276F,
+ 0.031339626F, 0.033376252F, 0.035545228F, 0.037855157F,
+ 0.040315199F, 0.042935108F, 0.045725273F, 0.048696758F,
+ 0.051861348F, 0.055231591F, 0.058820850F, 0.062643361F,
+ 0.066714279F, 0.071049749F, 0.075666962F, 0.080584227F,
+ 0.085821044F, 0.091398179F, 0.097337747F, 0.10366330F,
+ 0.11039993F, 0.11757434F, 0.12521498F, 0.13335215F,
+ 0.14201813F, 0.15124727F, 0.16107617F, 0.17154380F,
+ 0.18269168F, 0.19456402F, 0.20720788F, 0.22067342F,
+ 0.23501402F, 0.25028656F, 0.26655159F, 0.28387361F,
+ 0.30232132F, 0.32196786F, 0.34289114F, 0.36517414F,
+ 0.38890521F, 0.41417847F, 0.44109412F, 0.46975890F,
+ 0.50028648F, 0.53279791F, 0.56742212F, 0.60429640F,
+ 0.64356699F, 0.68538959F, 0.72993007F, 0.77736504F,
+ 0.82788260F, 0.88168307F, 0.9389798F, 1.F,
+};
+
+#endif
+
+
+static int mapping0_forward(vorbis_block *vb){
+ vorbis_dsp_state *vd=vb->vd;
+ vorbis_info *vi=vd->vi;
+ codec_setup_info *ci=vi->codec_setup;
+ private_state *b=vb->vd->backend_state;
+ vorbis_block_internal *vbi=(vorbis_block_internal *)vb->internal;
+ int n=vb->pcmend;
+ int i,j,k;
+
+ int *nonzero = alloca(sizeof(*nonzero)*vi->channels);
+ float **gmdct = _vorbis_block_alloc(vb,vi->channels*sizeof(*gmdct));
+ int **iwork = _vorbis_block_alloc(vb,vi->channels*sizeof(*iwork));
+ int ***floor_posts = _vorbis_block_alloc(vb,vi->channels*sizeof(*floor_posts));
+
+ float global_ampmax=vbi->ampmax;
+ float *local_ampmax=alloca(sizeof(*local_ampmax)*vi->channels);
+ int blocktype=vbi->blocktype;
+
+ int modenumber=vb->W;
+ vorbis_info_mapping0 *info=ci->map_param[modenumber];
+ vorbis_look_psy *psy_look=b->psy+blocktype+(vb->W?2:0);
+
+ vb->mode=modenumber;
+
+ for(i=0;i<vi->channels;i++){
+ float scale=4.f/n;
+ float scale_dB;
+
+ float *pcm =vb->pcm[i];
+ float *logfft =pcm;
+
+ iwork[i]=_vorbis_block_alloc(vb,n/2*sizeof(**iwork));
+ gmdct[i]=_vorbis_block_alloc(vb,n/2*sizeof(**gmdct));
+
+ scale_dB=todB(&scale) + .345; /* + .345 is a hack; the original
+ todB estimation used on IEEE 754
+ compliant machines had a bug that
+ returned dB values about a third
+ of a decibel too high. The bug
+ was harmless because tunings
+ implicitly took that into
+ account. However, fixing the bug
+ in the estimator requires
+ changing all the tunings as well.
+ For now, it's easier to sync
+ things back up here, and
+ recalibrate the tunings in the
+ next major model upgrade. */
+
+#if 0
+ if(vi->channels==2){
+ if(i==0)
+ _analysis_output("pcmL",seq,pcm,n,0,0,total-n/2);
+ else
+ _analysis_output("pcmR",seq,pcm,n,0,0,total-n/2);
+ }else{
+ _analysis_output("pcm",seq,pcm,n,0,0,total-n/2);
+ }
+#endif
+
+ /* window the PCM data */
+ _vorbis_apply_window(pcm,b->window,ci->blocksizes,vb->lW,vb->W,vb->nW);
+
+#if 0
+ if(vi->channels==2){
+ if(i==0)
+ _analysis_output("windowedL",seq,pcm,n,0,0,total-n/2);
+ else
+ _analysis_output("windowedR",seq,pcm,n,0,0,total-n/2);
+ }else{
+ _analysis_output("windowed",seq,pcm,n,0,0,total-n/2);
+ }
+#endif
+
+ /* transform the PCM data */
+ /* only MDCT right now.... */
+ mdct_forward(b->transform[vb->W][0],pcm,gmdct[i]);
+
+ /* FFT yields more accurate tonal estimation (not phase sensitive) */
+ drft_forward(&b->fft_look[vb->W],pcm);
+ logfft[0]=scale_dB+todB(pcm) + .345; /* + .345 is a hack; the
+ original todB estimation used on
+ IEEE 754 compliant machines had a
+ bug that returned dB values about
+ a third of a decibel too high.
+ The bug was harmless because
+ tunings implicitly took that into
+ account. However, fixing the bug
+ in the estimator requires
+ changing all the tunings as well.
+ For now, it's easier to sync
+ things back up here, and
+ recalibrate the tunings in the
+ next major model upgrade. */
+ local_ampmax[i]=logfft[0];
+ for(j=1;j<n-1;j+=2){
+ float temp=pcm[j]*pcm[j]+pcm[j+1]*pcm[j+1];
+ temp=logfft[(j+1)>>1]=scale_dB+.5f*todB(&temp) + .345; /* +
+ .345 is a hack; the original todB
+ estimation used on IEEE 754
+ compliant machines had a bug that
+ returned dB values about a third
+ of a decibel too high. The bug
+ was harmless because tunings
+ implicitly took that into
+ account. However, fixing the bug
+ in the estimator requires
+ changing all the tunings as well.
+ For now, it's easier to sync
+ things back up here, and
+ recalibrate the tunings in the
+ next major model upgrade. */
+ if(temp>local_ampmax[i])local_ampmax[i]=temp;
+ }
+
+ if(local_ampmax[i]>0.f)local_ampmax[i]=0.f;
+ if(local_ampmax[i]>global_ampmax)global_ampmax=local_ampmax[i];
+
+#if 0
+ if(vi->channels==2){
+ if(i==0){
+ _analysis_output("fftL",seq,logfft,n/2,1,0,0);
+ }else{
+ _analysis_output("fftR",seq,logfft,n/2,1,0,0);
+ }
+ }else{
+ _analysis_output("fft",seq,logfft,n/2,1,0,0);
+ }
+#endif
+
+ }
+
+ {
+ float *noise = _vorbis_block_alloc(vb,n/2*sizeof(*noise));
+ float *tone = _vorbis_block_alloc(vb,n/2*sizeof(*tone));
+
+ for(i=0;i<vi->channels;i++){
+ /* the encoder setup assumes that all the modes used by any
+ specific bitrate tweaking use the same floor */
+
+ int submap=info->chmuxlist[i];
+
+ /* the following makes things clearer to *me* anyway */
+ float *mdct =gmdct[i];
+ float *logfft =vb->pcm[i];
+
+ float *logmdct =logfft+n/2;
+ float *logmask =logfft;
+
+ vb->mode=modenumber;
+
+ floor_posts[i]=_vorbis_block_alloc(vb,PACKETBLOBS*sizeof(**floor_posts));
+ memset(floor_posts[i],0,sizeof(**floor_posts)*PACKETBLOBS);
+
+ for(j=0;j<n/2;j++)
+ logmdct[j]=todB(mdct+j) + .345; /* + .345 is a hack; the original
+ todB estimation used on IEEE 754
+ compliant machines had a bug that
+ returned dB values about a third
+ of a decibel too high. The bug
+ was harmless because tunings
+ implicitly took that into
+ account. However, fixing the bug
+ in the estimator requires
+ changing all the tunings as well.
+ For now, it's easier to sync
+ things back up here, and
+ recalibrate the tunings in the
+ next major model upgrade. */
+
+#if 0
+ if(vi->channels==2){
+ if(i==0)
+ _analysis_output("mdctL",seq,logmdct,n/2,1,0,0);
+ else
+ _analysis_output("mdctR",seq,logmdct,n/2,1,0,0);
+ }else{
+ _analysis_output("mdct",seq,logmdct,n/2,1,0,0);
+ }
+#endif
+
+ /* first step; noise masking. Not only does 'noise masking'
+ give us curves from which we can decide how much resolution
+ to give noise parts of the spectrum, it also implicitly hands
+ us a tonality estimate (the larger the value in the
+ 'noise_depth' vector, the more tonal that area is) */
+
+ _vp_noisemask(psy_look,
+ logmdct,
+ noise); /* noise does not have by-frequency offset
+ bias applied yet */
+#if 0
+ if(vi->channels==2){
+ if(i==0)
+ _analysis_output("noiseL",seq,noise,n/2,1,0,0);
+ else
+ _analysis_output("noiseR",seq,noise,n/2,1,0,0);
+ }else{
+ _analysis_output("noise",seq,noise,n/2,1,0,0);
+ }
+#endif
+
+ /* second step: 'all the other crap'; all the stuff that isn't
+ computed/fit for bitrate management goes in the second psy
+ vector. This includes tone masking, peak limiting and ATH */
+
+ _vp_tonemask(psy_look,
+ logfft,
+ tone,
+ global_ampmax,
+ local_ampmax[i]);
+
+#if 0
+ if(vi->channels==2){
+ if(i==0)
+ _analysis_output("toneL",seq,tone,n/2,1,0,0);
+ else
+ _analysis_output("toneR",seq,tone,n/2,1,0,0);
+ }else{
+ _analysis_output("tone",seq,tone,n/2,1,0,0);
+ }
+#endif
+
+ /* third step; we offset the noise vectors, overlay tone
+ masking. We then do a floor1-specific line fit. If we're
+ performing bitrate management, the line fit is performed
+ multiple times for up/down tweakage on demand. */
+
+#if 0
+ {
+ float aotuv[psy_look->n];
+#endif
+
+ _vp_offset_and_mix(psy_look,
+ noise,
+ tone,
+ 1,
+ logmask,
+ mdct,
+ logmdct);
+
+#if 0
+ if(vi->channels==2){
+ if(i==0)
+ _analysis_output("aotuvM1_L",seq,aotuv,psy_look->n,1,1,0);
+ else
+ _analysis_output("aotuvM1_R",seq,aotuv,psy_look->n,1,1,0);
+ }else{
+ _analysis_output("aotuvM1",seq,aotuv,psy_look->n,1,1,0);
+ }
+ }
+#endif
+
+
+#if 0
+ if(vi->channels==2){
+ if(i==0)
+ _analysis_output("mask1L",seq,logmask,n/2,1,0,0);
+ else
+ _analysis_output("mask1R",seq,logmask,n/2,1,0,0);
+ }else{
+ _analysis_output("mask1",seq,logmask,n/2,1,0,0);
+ }
+#endif
+
+ /* this algorithm is hardwired to floor 1 for now; abort out if
+ we're *not* floor1. This won't happen unless someone has
+ broken the encode setup lib. Guard it anyway. */
+ if(ci->floor_type[info->floorsubmap[submap]]!=1)return(-1);
+
+ floor_posts[i][PACKETBLOBS/2]=
+ floor1_fit(vb,b->flr[info->floorsubmap[submap]],
+ logmdct,
+ logmask);
+
+ /* are we managing bitrate? If so, perform two more fits for
+ later rate tweaking (fits represent hi/lo) */
+ if(vorbis_bitrate_managed(vb) && floor_posts[i][PACKETBLOBS/2]){
+ /* higher rate by way of lower noise curve */
+
+ _vp_offset_and_mix(psy_look,
+ noise,
+ tone,
+ 2,
+ logmask,
+ mdct,
+ logmdct);
+
+#if 0
+ if(vi->channels==2){
+ if(i==0)
+ _analysis_output("mask2L",seq,logmask,n/2,1,0,0);
+ else
+ _analysis_output("mask2R",seq,logmask,n/2,1,0,0);
+ }else{
+ _analysis_output("mask2",seq,logmask,n/2,1,0,0);
+ }
+#endif
+
+ floor_posts[i][PACKETBLOBS-1]=
+ floor1_fit(vb,b->flr[info->floorsubmap[submap]],
+ logmdct,
+ logmask);
+
+ /* lower rate by way of higher noise curve */
+ _vp_offset_and_mix(psy_look,
+ noise,
+ tone,
+ 0,
+ logmask,
+ mdct,
+ logmdct);
+
+#if 0
+ if(vi->channels==2){
+ if(i==0)
+ _analysis_output("mask0L",seq,logmask,n/2,1,0,0);
+ else
+ _analysis_output("mask0R",seq,logmask,n/2,1,0,0);
+ }else{
+ _analysis_output("mask0",seq,logmask,n/2,1,0,0);
+ }
+#endif
+
+ floor_posts[i][0]=
+ floor1_fit(vb,b->flr[info->floorsubmap[submap]],
+ logmdct,
+ logmask);
+
+ /* we also interpolate a range of intermediate curves for
+ intermediate rates */
+ for(k=1;k<PACKETBLOBS/2;k++)
+ floor_posts[i][k]=
+ floor1_interpolate_fit(vb,b->flr[info->floorsubmap[submap]],
+ floor_posts[i][0],
+ floor_posts[i][PACKETBLOBS/2],
+ k*65536/(PACKETBLOBS/2));
+ for(k=PACKETBLOBS/2+1;k<PACKETBLOBS-1;k++)
+ floor_posts[i][k]=
+ floor1_interpolate_fit(vb,b->flr[info->floorsubmap[submap]],
+ floor_posts[i][PACKETBLOBS/2],
+ floor_posts[i][PACKETBLOBS-1],
+ (k-PACKETBLOBS/2)*65536/(PACKETBLOBS/2));
+ }
+ }
+ }
+ vbi->ampmax=global_ampmax;
+
+ /*
+ the next phases are performed once for vbr-only and PACKETBLOB
+ times for bitrate managed modes.
+
+ 1) encode actual mode being used
+ 2) encode the floor for each channel, compute coded mask curve/res
+ 3) normalize and couple.
+ 4) encode residue
+ 5) save packet bytes to the packetblob vector
+
+ */
+
+ /* iterate over the many masking curve fits we've created */
+
+ {
+ int **couple_bundle=alloca(sizeof(*couple_bundle)*vi->channels);
+ int *zerobundle=alloca(sizeof(*zerobundle)*vi->channels);
+
+ for(k=(vorbis_bitrate_managed(vb)?0:PACKETBLOBS/2);
+ k<=(vorbis_bitrate_managed(vb)?PACKETBLOBS-1:PACKETBLOBS/2);
+ k++){
+ oggpack_buffer *opb=vbi->packetblob[k];
+
+ /* start out our new packet blob with packet type and mode */
+ /* Encode the packet type */
+ oggpack_write(opb,0,1);
+ /* Encode the modenumber */
+ /* Encode frame mode, pre,post windowsize, then dispatch */
+ oggpack_write(opb,modenumber,b->modebits);
+ if(vb->W){
+ oggpack_write(opb,vb->lW,1);
+ oggpack_write(opb,vb->nW,1);
+ }
+
+ /* encode floor, compute masking curve, sep out residue */
+ for(i=0;i<vi->channels;i++){
+ int submap=info->chmuxlist[i];
+ int *ilogmask=iwork[i];
+
+ nonzero[i]=floor1_encode(opb,vb,b->flr[info->floorsubmap[submap]],
+ floor_posts[i][k],
+ ilogmask);
+#if 0
+ {
+ char buf[80];
+ sprintf(buf,"maskI%c%d",i?'R':'L',k);
+ float work[n/2];
+ for(j=0;j<n/2;j++)
+ work[j]=FLOOR1_fromdB_LOOKUP[iwork[i][j]];
+ _analysis_output(buf,seq,work,n/2,1,1,0);
+ }
+#endif
+ }
+
+ /* our iteration is now based on masking curve, not prequant and
+ coupling. Only one prequant/coupling step */
+
+ /* quantize/couple */
+ /* incomplete implementation that assumes the tree is all depth
+ one, or no tree at all */
+ _vp_couple_quantize_normalize(k,
+ &ci->psy_g_param,
+ psy_look,
+ info,
+ gmdct,
+ iwork,
+ nonzero,
+ ci->psy_g_param.sliding_lowpass[vb->W][k],
+ vi->channels);
+
+#if 0
+ for(i=0;i<vi->channels;i++){
+ char buf[80];
+ sprintf(buf,"res%c%d",i?'R':'L',k);
+ float work[n/2];
+ for(j=0;j<n/2;j++)
+ work[j]=iwork[i][j];
+ _analysis_output(buf,seq,work,n/2,1,0,0);
+ }
+#endif
+
+ /* classify and encode by submap */
+ for(i=0;i<info->submaps;i++){
+ int ch_in_bundle=0;
+ long **classifications;
+ int resnum=info->residuesubmap[i];
+
+ for(j=0;j<vi->channels;j++){
+ if(info->chmuxlist[j]==i){
+ zerobundle[ch_in_bundle]=0;
+ if(nonzero[j])zerobundle[ch_in_bundle]=1;
+ couple_bundle[ch_in_bundle++]=iwork[j];
+ }
+ }
+
+ classifications=_residue_P[ci->residue_type[resnum]]->
+ class(vb,b->residue[resnum],couple_bundle,zerobundle,ch_in_bundle);
+
+ ch_in_bundle=0;
+ for(j=0;j<vi->channels;j++)
+ if(info->chmuxlist[j]==i)
+ couple_bundle[ch_in_bundle++]=iwork[j];
+
+ _residue_P[ci->residue_type[resnum]]->
+ forward(opb,vb,b->residue[resnum],
+ couple_bundle,zerobundle,ch_in_bundle,classifications,i);
+ }
+
+ /* ok, done encoding. Next protopacket. */
+ }
+
+ }
+
+#if 0
+ seq++;
+ total+=ci->blocksizes[vb->W]/4+ci->blocksizes[vb->nW]/4;
+#endif
+ return(0);
+}
+
+static int mapping0_inverse(vorbis_block *vb,vorbis_info_mapping *l){
+ vorbis_dsp_state *vd=vb->vd;
+ vorbis_info *vi=vd->vi;
+ codec_setup_info *ci=vi->codec_setup;
+ private_state *b=vd->backend_state;
+ vorbis_info_mapping0 *info=(vorbis_info_mapping0 *)l;
+
+ int i,j;
+ long n=vb->pcmend=ci->blocksizes[vb->W];
+
+ float **pcmbundle=alloca(sizeof(*pcmbundle)*vi->channels);
+ int *zerobundle=alloca(sizeof(*zerobundle)*vi->channels);
+
+ int *nonzero =alloca(sizeof(*nonzero)*vi->channels);
+ void **floormemo=alloca(sizeof(*floormemo)*vi->channels);
+
+ /* recover the spectral envelope; store it in the PCM vector for now */
+ for(i=0;i<vi->channels;i++){
+ int submap=info->chmuxlist[i];
+ floormemo[i]=_floor_P[ci->floor_type[info->floorsubmap[submap]]]->
+ inverse1(vb,b->flr[info->floorsubmap[submap]]);
+ if(floormemo[i])
+ nonzero[i]=1;
+ else
+ nonzero[i]=0;
+ memset(vb->pcm[i],0,sizeof(*vb->pcm[i])*n/2);
+ }
+
+ /* channel coupling can 'dirty' the nonzero listing */
+ for(i=0;i<info->coupling_steps;i++){
+ if(nonzero[info->coupling_mag[i]] ||
+ nonzero[info->coupling_ang[i]]){
+ nonzero[info->coupling_mag[i]]=1;
+ nonzero[info->coupling_ang[i]]=1;
+ }
+ }
+
+ /* recover the residue into our working vectors */
+ for(i=0;i<info->submaps;i++){
+ int ch_in_bundle=0;
+ for(j=0;j<vi->channels;j++){
+ if(info->chmuxlist[j]==i){
+ if(nonzero[j])
+ zerobundle[ch_in_bundle]=1;
+ else
+ zerobundle[ch_in_bundle]=0;
+ pcmbundle[ch_in_bundle++]=vb->pcm[j];
+ }
+ }
+
+ _residue_P[ci->residue_type[info->residuesubmap[i]]]->
+ inverse(vb,b->residue[info->residuesubmap[i]],
+ pcmbundle,zerobundle,ch_in_bundle);
+ }
+
+ /* channel coupling */
+ for(i=info->coupling_steps-1;i>=0;i--){
+ float *pcmM=vb->pcm[info->coupling_mag[i]];
+ float *pcmA=vb->pcm[info->coupling_ang[i]];
+
+ for(j=0;j<n/2;j++){
+ float mag=pcmM[j];
+ float ang=pcmA[j];
+
+ if(mag>0)
+ if(ang>0){
+ pcmM[j]=mag;
+ pcmA[j]=mag-ang;
+ }else{
+ pcmA[j]=mag;
+ pcmM[j]=mag+ang;
+ }
+ else
+ if(ang>0){
+ pcmM[j]=mag;
+ pcmA[j]=mag+ang;
+ }else{
+ pcmA[j]=mag;
+ pcmM[j]=mag-ang;
+ }
+ }
+ }
+
+ /* compute and apply spectral envelope */
+ for(i=0;i<vi->channels;i++){
+ float *pcm=vb->pcm[i];
+ int submap=info->chmuxlist[i];
+ _floor_P[ci->floor_type[info->floorsubmap[submap]]]->
+ inverse2(vb,b->flr[info->floorsubmap[submap]],
+ floormemo[i],pcm);
+ }
+
+ /* transform the PCM data; takes PCM vector, vb; modifies PCM vector */
+ /* only MDCT right now.... */
+ for(i=0;i<vi->channels;i++){
+ float *pcm=vb->pcm[i];
+ mdct_backward(b->transform[vb->W][0],pcm,pcm);
+ }
+
+ /* all done! */
+ return(0);
+}
+
+/* export hooks */
+const vorbis_func_mapping mapping0_exportbundle={
+ &mapping0_pack,
+ &mapping0_unpack,
+ &mapping0_free_info,
+ &mapping0_forward,
+ &mapping0_inverse
+};
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: masking curve data for psychoacoustics
+ last mod: $Id: masking.h 16227 2009-07-08 06:58:46Z xiphmont $
+
+ ********************************************************************/
+
+#ifndef _V_MASKING_H_
+#define _V_MASKING_H_
+
+/* more detailed ATH; the bass if flat to save stressing the floor
+ overly for only a bin or two of savings. */
+
+#define MAX_ATH 88
+static const float ATH[]={
+ /*15*/ -51, -52, -53, -54, -55, -56, -57, -58,
+ /*31*/ -59, -60, -61, -62, -63, -64, -65, -66,
+ /*63*/ -67, -68, -69, -70, -71, -72, -73, -74,
+ /*125*/ -75, -76, -77, -78, -80, -81, -82, -83,
+ /*250*/ -84, -85, -86, -87, -88, -88, -89, -89,
+ /*500*/ -90, -91, -91, -92, -93, -94, -95, -96,
+ /*1k*/ -96, -97, -98, -98, -99, -99,-100,-100,
+ /*2k*/ -101,-102,-103,-104,-106,-107,-107,-107,
+ /*4k*/ -107,-105,-103,-102,-101, -99, -98, -96,
+ /*8k*/ -95, -95, -96, -97, -96, -95, -93, -90,
+ /*16k*/ -80, -70, -50, -40, -30, -30, -30, -30
+};
+
+/* The tone masking curves from Ehmer's and Fielder's papers have been
+ replaced by an empirically collected data set. The previously
+ published values were, far too often, simply on crack. */
+
+#define EHMER_OFFSET 16
+#define EHMER_MAX 56
+
+/* masking tones from -50 to 0dB, 62.5 through 16kHz at half octaves
+ test tones from -2 octaves to +5 octaves sampled at eighth octaves */
+/* (Vorbis 0dB, the loudest possible tone, is assumed to be ~100dB SPL
+ for collection of these curves) */
+
+static const float tonemasks[P_BANDS][6][EHMER_MAX]={
+ /* 62.5 Hz */
+ {{ -60, -60, -60, -60, -60, -60, -60, -60,
+ -60, -60, -60, -60, -62, -62, -65, -73,
+ -69, -68, -68, -67, -70, -70, -72, -74,
+ -75, -79, -79, -80, -83, -88, -93, -100,
+ -110, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ { -48, -48, -48, -48, -48, -48, -48, -48,
+ -48, -48, -48, -48, -48, -53, -61, -66,
+ -66, -68, -67, -70, -76, -76, -72, -73,
+ -75, -76, -78, -79, -83, -88, -93, -100,
+ -110, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ { -37, -37, -37, -37, -37, -37, -37, -37,
+ -38, -40, -42, -46, -48, -53, -55, -62,
+ -65, -58, -56, -56, -61, -60, -65, -67,
+ -69, -71, -77, -77, -78, -80, -82, -84,
+ -88, -93, -98, -106, -112, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ { -25, -25, -25, -25, -25, -25, -25, -25,
+ -25, -26, -27, -29, -32, -38, -48, -52,
+ -52, -50, -48, -48, -51, -52, -54, -60,
+ -67, -67, -66, -68, -69, -73, -73, -76,
+ -80, -81, -81, -85, -85, -86, -88, -93,
+ -100, -110, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ { -16, -16, -16, -16, -16, -16, -16, -16,
+ -17, -19, -20, -22, -26, -28, -31, -40,
+ -47, -39, -39, -40, -42, -43, -47, -51,
+ -57, -52, -55, -55, -60, -58, -62, -63,
+ -70, -67, -69, -72, -73, -77, -80, -82,
+ -83, -87, -90, -94, -98, -104, -115, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ { -8, -8, -8, -8, -8, -8, -8, -8,
+ -8, -8, -10, -11, -15, -19, -25, -30,
+ -34, -31, -30, -31, -29, -32, -35, -42,
+ -48, -42, -44, -46, -50, -50, -51, -52,
+ -59, -54, -55, -55, -58, -62, -63, -66,
+ -72, -73, -76, -75, -78, -80, -80, -81,
+ -84, -88, -90, -94, -98, -101, -106, -110}},
+ /* 88Hz */
+ {{ -66, -66, -66, -66, -66, -66, -66, -66,
+ -66, -66, -66, -66, -66, -67, -67, -67,
+ -76, -72, -71, -74, -76, -76, -75, -78,
+ -79, -79, -81, -83, -86, -89, -93, -97,
+ -100, -105, -110, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ { -47, -47, -47, -47, -47, -47, -47, -47,
+ -47, -47, -47, -48, -51, -55, -59, -66,
+ -66, -66, -67, -66, -68, -69, -70, -74,
+ -79, -77, -77, -78, -80, -81, -82, -84,
+ -86, -88, -91, -95, -100, -108, -116, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ { -36, -36, -36, -36, -36, -36, -36, -36,
+ -36, -37, -37, -41, -44, -48, -51, -58,
+ -62, -60, -57, -59, -59, -60, -63, -65,
+ -72, -71, -70, -72, -74, -77, -76, -78,
+ -81, -81, -80, -83, -86, -91, -96, -100,
+ -105, -110, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ { -28, -28, -28, -28, -28, -28, -28, -28,
+ -28, -30, -32, -32, -33, -35, -41, -49,
+ -50, -49, -47, -48, -48, -52, -51, -57,
+ -65, -61, -59, -61, -64, -69, -70, -74,
+ -77, -77, -78, -81, -84, -85, -87, -90,
+ -92, -96, -100, -107, -112, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ { -19, -19, -19, -19, -19, -19, -19, -19,
+ -20, -21, -23, -27, -30, -35, -36, -41,
+ -46, -44, -42, -40, -41, -41, -43, -48,
+ -55, -53, -52, -53, -56, -59, -58, -60,
+ -67, -66, -69, -71, -72, -75, -79, -81,
+ -84, -87, -90, -93, -97, -101, -107, -114,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ { -9, -9, -9, -9, -9, -9, -9, -9,
+ -11, -12, -12, -15, -16, -20, -23, -30,
+ -37, -34, -33, -34, -31, -32, -32, -38,
+ -47, -44, -41, -40, -47, -49, -46, -46,
+ -58, -50, -50, -54, -58, -62, -64, -67,
+ -67, -70, -72, -76, -79, -83, -87, -91,
+ -96, -100, -104, -110, -999, -999, -999, -999}},
+ /* 125 Hz */
+ {{ -62, -62, -62, -62, -62, -62, -62, -62,
+ -62, -62, -63, -64, -66, -67, -66, -68,
+ -75, -72, -76, -75, -76, -78, -79, -82,
+ -84, -85, -90, -94, -101, -110, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ { -59, -59, -59, -59, -59, -59, -59, -59,
+ -59, -59, -59, -60, -60, -61, -63, -66,
+ -71, -68, -70, -70, -71, -72, -72, -75,
+ -81, -78, -79, -82, -83, -86, -90, -97,
+ -103, -113, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ { -53, -53, -53, -53, -53, -53, -53, -53,
+ -53, -54, -55, -57, -56, -57, -55, -61,
+ -65, -60, -60, -62, -63, -63, -66, -68,
+ -74, -73, -75, -75, -78, -80, -80, -82,
+ -85, -90, -96, -101, -108, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ { -46, -46, -46, -46, -46, -46, -46, -46,
+ -46, -46, -47, -47, -47, -47, -48, -51,
+ -57, -51, -49, -50, -51, -53, -54, -59,
+ -66, -60, -62, -67, -67, -70, -72, -75,
+ -76, -78, -81, -85, -88, -94, -97, -104,
+ -112, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ { -36, -36, -36, -36, -36, -36, -36, -36,
+ -39, -41, -42, -42, -39, -38, -41, -43,
+ -52, -44, -40, -39, -37, -37, -40, -47,
+ -54, -50, -48, -50, -55, -61, -59, -62,
+ -66, -66, -66, -69, -69, -73, -74, -74,
+ -75, -77, -79, -82, -87, -91, -95, -100,
+ -108, -115, -999, -999, -999, -999, -999, -999},
+ { -28, -26, -24, -22, -20, -20, -23, -29,
+ -30, -31, -28, -27, -28, -28, -28, -35,
+ -40, -33, -32, -29, -30, -30, -30, -37,
+ -45, -41, -37, -38, -45, -47, -47, -48,
+ -53, -49, -48, -50, -49, -49, -51, -52,
+ -58, -56, -57, -56, -60, -61, -62, -70,
+ -72, -74, -78, -83, -88, -93, -100, -106}},
+ /* 177 Hz */
+ {{-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -110, -105, -100, -95, -91, -87, -83,
+ -80, -78, -76, -78, -78, -81, -83, -85,
+ -86, -85, -86, -87, -90, -97, -107, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -110, -105, -100, -95, -90,
+ -85, -81, -77, -73, -70, -67, -67, -68,
+ -75, -73, -70, -69, -70, -72, -75, -79,
+ -84, -83, -84, -86, -88, -89, -89, -93,
+ -98, -105, -112, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-105, -100, -95, -90, -85, -80, -76, -71,
+ -68, -68, -65, -63, -63, -62, -62, -64,
+ -65, -64, -61, -62, -63, -64, -66, -68,
+ -73, -73, -74, -75, -76, -81, -83, -85,
+ -88, -89, -92, -95, -100, -108, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ { -80, -75, -71, -68, -65, -63, -62, -61,
+ -61, -61, -61, -59, -56, -57, -53, -50,
+ -58, -52, -50, -50, -52, -53, -54, -58,
+ -67, -63, -67, -68, -72, -75, -78, -80,
+ -81, -81, -82, -85, -89, -90, -93, -97,
+ -101, -107, -114, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ { -65, -61, -59, -57, -56, -55, -55, -56,
+ -56, -57, -55, -53, -52, -47, -44, -44,
+ -50, -44, -41, -39, -39, -42, -40, -46,
+ -51, -49, -50, -53, -54, -63, -60, -61,
+ -62, -66, -66, -66, -70, -73, -74, -75,
+ -76, -75, -79, -85, -89, -91, -96, -102,
+ -110, -999, -999, -999, -999, -999, -999, -999},
+ { -52, -50, -49, -49, -48, -48, -48, -49,
+ -50, -50, -49, -46, -43, -39, -35, -33,
+ -38, -36, -32, -29, -32, -32, -32, -35,
+ -44, -39, -38, -38, -46, -50, -45, -46,
+ -53, -50, -50, -50, -54, -54, -53, -53,
+ -56, -57, -59, -66, -70, -72, -74, -79,
+ -83, -85, -90, -97, -114, -999, -999, -999}},
+ /* 250 Hz */
+ {{-999, -999, -999, -999, -999, -999, -110, -105,
+ -100, -95, -90, -86, -80, -75, -75, -79,
+ -80, -79, -80, -81, -82, -88, -95, -103,
+ -110, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -108, -103, -98, -93,
+ -88, -83, -79, -78, -75, -71, -67, -68,
+ -73, -73, -72, -73, -75, -77, -80, -82,
+ -88, -93, -100, -107, -114, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -110, -105, -101, -96, -90,
+ -86, -81, -77, -73, -69, -66, -61, -62,
+ -66, -64, -62, -65, -66, -70, -72, -76,
+ -81, -80, -84, -90, -95, -102, -110, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -107, -103, -97, -92, -88,
+ -83, -79, -74, -70, -66, -59, -53, -58,
+ -62, -55, -54, -54, -54, -58, -61, -62,
+ -72, -70, -72, -75, -78, -80, -81, -80,
+ -83, -83, -88, -93, -100, -107, -115, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -105, -100, -95, -90, -85,
+ -80, -75, -70, -66, -62, -56, -48, -44,
+ -48, -46, -46, -43, -46, -48, -48, -51,
+ -58, -58, -59, -60, -62, -62, -61, -61,
+ -65, -64, -65, -68, -70, -74, -75, -78,
+ -81, -86, -95, -110, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -105, -100, -95, -90, -85, -80,
+ -75, -70, -65, -61, -55, -49, -39, -33,
+ -40, -35, -32, -38, -40, -33, -35, -37,
+ -46, -41, -45, -44, -46, -42, -45, -46,
+ -52, -50, -50, -50, -54, -54, -55, -57,
+ -62, -64, -66, -68, -70, -76, -81, -90,
+ -100, -110, -999, -999, -999, -999, -999, -999}},
+ /* 354 hz */
+ {{-999, -999, -999, -999, -999, -999, -999, -999,
+ -105, -98, -90, -85, -82, -83, -80, -78,
+ -84, -79, -80, -83, -87, -89, -91, -93,
+ -99, -106, -117, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -105, -98, -90, -85, -80, -75, -70, -68,
+ -74, -72, -74, -77, -80, -82, -85, -87,
+ -92, -89, -91, -95, -100, -106, -112, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -105, -98, -90, -83, -75, -71, -63, -64,
+ -67, -62, -64, -67, -70, -73, -77, -81,
+ -84, -83, -85, -89, -90, -93, -98, -104,
+ -109, -114, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -103, -96, -88, -81, -75, -68, -58, -54,
+ -56, -54, -56, -56, -58, -60, -63, -66,
+ -74, -69, -72, -72, -75, -74, -77, -81,
+ -81, -82, -84, -87, -93, -96, -99, -104,
+ -110, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -108, -102, -96,
+ -91, -85, -80, -74, -68, -60, -51, -46,
+ -48, -46, -43, -45, -47, -47, -49, -48,
+ -56, -53, -55, -58, -57, -63, -58, -60,
+ -66, -64, -67, -70, -70, -74, -77, -84,
+ -86, -89, -91, -93, -94, -101, -109, -118,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -108, -103, -98, -93, -88,
+ -83, -78, -73, -68, -60, -53, -44, -35,
+ -38, -38, -34, -34, -36, -40, -41, -44,
+ -51, -45, -46, -47, -46, -54, -50, -49,
+ -50, -50, -50, -51, -54, -57, -58, -60,
+ -66, -66, -66, -64, -65, -68, -77, -82,
+ -87, -95, -110, -999, -999, -999, -999, -999}},
+ /* 500 Hz */
+ {{-999, -999, -999, -999, -999, -999, -999, -999,
+ -107, -102, -97, -92, -87, -83, -78, -75,
+ -82, -79, -83, -85, -89, -92, -95, -98,
+ -101, -105, -109, -113, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -106,
+ -100, -95, -90, -86, -81, -78, -74, -69,
+ -74, -74, -76, -79, -83, -84, -86, -89,
+ -92, -97, -93, -100, -103, -107, -110, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -106, -100,
+ -95, -90, -87, -83, -80, -75, -69, -60,
+ -66, -66, -68, -70, -74, -78, -79, -81,
+ -81, -83, -84, -87, -93, -96, -99, -103,
+ -107, -110, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -108, -103, -98,
+ -93, -89, -85, -82, -78, -71, -62, -55,
+ -58, -58, -54, -54, -55, -59, -61, -62,
+ -70, -66, -66, -67, -70, -72, -75, -78,
+ -84, -84, -84, -88, -91, -90, -95, -98,
+ -102, -103, -106, -110, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -108, -103, -98, -94,
+ -90, -87, -82, -79, -73, -67, -58, -47,
+ -50, -45, -41, -45, -48, -44, -44, -49,
+ -54, -51, -48, -47, -49, -50, -51, -57,
+ -58, -60, -63, -69, -70, -69, -71, -74,
+ -78, -82, -90, -95, -101, -105, -110, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -105, -101, -97, -93, -90,
+ -85, -80, -77, -72, -65, -56, -48, -37,
+ -40, -36, -34, -40, -50, -47, -38, -41,
+ -47, -38, -35, -39, -38, -43, -40, -45,
+ -50, -45, -44, -47, -50, -55, -48, -48,
+ -52, -66, -70, -76, -82, -90, -97, -105,
+ -110, -999, -999, -999, -999, -999, -999, -999}},
+ /* 707 Hz */
+ {{-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -108, -103, -98, -93, -86, -79, -76,
+ -83, -81, -85, -87, -89, -93, -98, -102,
+ -107, -112, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -108, -103, -98, -93, -86, -79, -71,
+ -77, -74, -77, -79, -81, -84, -85, -90,
+ -92, -93, -92, -98, -101, -108, -112, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -108, -103, -98, -93, -87, -78, -68, -65,
+ -66, -62, -65, -67, -70, -73, -75, -78,
+ -82, -82, -83, -84, -91, -93, -98, -102,
+ -106, -110, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -105, -100, -95, -90, -82, -74, -62, -57,
+ -58, -56, -51, -52, -52, -54, -54, -58,
+ -66, -59, -60, -63, -66, -69, -73, -79,
+ -83, -84, -80, -81, -81, -82, -88, -92,
+ -98, -105, -113, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -107,
+ -102, -97, -92, -84, -79, -69, -57, -47,
+ -52, -47, -44, -45, -50, -52, -42, -42,
+ -53, -43, -43, -48, -51, -56, -55, -52,
+ -57, -59, -61, -62, -67, -71, -78, -83,
+ -86, -94, -98, -103, -110, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -105, -100,
+ -95, -90, -84, -78, -70, -61, -51, -41,
+ -40, -38, -40, -46, -52, -51, -41, -40,
+ -46, -40, -38, -38, -41, -46, -41, -46,
+ -47, -43, -43, -45, -41, -45, -56, -67,
+ -68, -83, -87, -90, -95, -102, -107, -113,
+ -999, -999, -999, -999, -999, -999, -999, -999}},
+ /* 1000 Hz */
+ {{-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -109, -105, -101, -96, -91, -84, -77,
+ -82, -82, -85, -89, -94, -100, -106, -110,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -106, -103, -98, -92, -85, -80, -71,
+ -75, -72, -76, -80, -84, -86, -89, -93,
+ -100, -107, -113, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -107,
+ -104, -101, -97, -92, -88, -84, -80, -64,
+ -66, -63, -64, -66, -69, -73, -77, -83,
+ -83, -86, -91, -98, -104, -111, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -107,
+ -104, -101, -97, -92, -90, -84, -74, -57,
+ -58, -52, -55, -54, -50, -52, -50, -52,
+ -63, -62, -69, -76, -77, -78, -78, -79,
+ -82, -88, -94, -100, -106, -111, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -106, -102,
+ -98, -95, -90, -85, -83, -78, -70, -50,
+ -50, -41, -44, -49, -47, -50, -50, -44,
+ -55, -46, -47, -48, -48, -54, -49, -49,
+ -58, -62, -71, -81, -87, -92, -97, -102,
+ -108, -114, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -106, -102,
+ -98, -95, -90, -85, -83, -78, -70, -45,
+ -43, -41, -47, -50, -51, -50, -49, -45,
+ -47, -41, -44, -41, -39, -43, -38, -37,
+ -40, -41, -44, -50, -58, -65, -73, -79,
+ -85, -92, -97, -101, -105, -109, -113, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999}},
+ /* 1414 Hz */
+ {{-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -107, -100, -95, -87, -81,
+ -85, -83, -88, -93, -100, -107, -114, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -107, -101, -95, -88, -83, -76,
+ -73, -72, -79, -84, -90, -95, -100, -105,
+ -110, -115, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -104, -98, -92, -87, -81, -70,
+ -65, -62, -67, -71, -74, -80, -85, -91,
+ -95, -99, -103, -108, -111, -114, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -103, -97, -90, -85, -76, -60,
+ -56, -54, -60, -62, -61, -56, -63, -65,
+ -73, -74, -77, -75, -78, -81, -86, -87,
+ -88, -91, -94, -98, -103, -110, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -105,
+ -100, -97, -92, -86, -81, -79, -70, -57,
+ -51, -47, -51, -58, -60, -56, -53, -50,
+ -58, -52, -50, -50, -53, -55, -64, -69,
+ -71, -85, -82, -78, -81, -85, -95, -102,
+ -112, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -105,
+ -100, -97, -92, -85, -83, -79, -72, -49,
+ -40, -43, -43, -54, -56, -51, -50, -40,
+ -43, -38, -36, -35, -37, -38, -37, -44,
+ -54, -60, -57, -60, -70, -75, -84, -92,
+ -103, -112, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999}},
+ /* 2000 Hz */
+ {{-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -110, -102, -95, -89, -82,
+ -83, -84, -90, -92, -99, -107, -113, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -107, -101, -95, -89, -83, -72,
+ -74, -78, -85, -88, -88, -90, -92, -98,
+ -105, -111, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -109, -103, -97, -93, -87, -81, -70,
+ -70, -67, -75, -73, -76, -79, -81, -83,
+ -88, -89, -97, -103, -110, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -107, -100, -94, -88, -83, -75, -63,
+ -59, -59, -63, -66, -60, -62, -67, -67,
+ -77, -76, -81, -88, -86, -92, -96, -102,
+ -109, -116, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -105, -98, -92, -86, -81, -73, -56,
+ -52, -47, -55, -60, -58, -52, -51, -45,
+ -49, -50, -53, -54, -61, -71, -70, -69,
+ -78, -79, -87, -90, -96, -104, -112, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -103, -96, -90, -86, -78, -70, -51,
+ -42, -47, -48, -55, -54, -54, -53, -42,
+ -35, -28, -33, -38, -37, -44, -47, -49,
+ -54, -63, -68, -78, -82, -89, -94, -99,
+ -104, -109, -114, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999}},
+ /* 2828 Hz */
+ {{-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -110, -100, -90, -79,
+ -85, -81, -82, -82, -89, -94, -99, -103,
+ -109, -115, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -105, -97, -85, -72,
+ -74, -70, -70, -70, -76, -85, -91, -93,
+ -97, -103, -109, -115, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -112, -93, -81, -68,
+ -62, -60, -60, -57, -63, -70, -77, -82,
+ -90, -93, -98, -104, -109, -113, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -113, -100, -93, -84, -63,
+ -58, -48, -53, -54, -52, -52, -57, -64,
+ -66, -76, -83, -81, -85, -85, -90, -95,
+ -98, -101, -103, -106, -108, -111, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -105, -95, -86, -74, -53,
+ -50, -38, -43, -49, -43, -42, -39, -39,
+ -46, -52, -57, -56, -72, -69, -74, -81,
+ -87, -92, -94, -97, -99, -102, -105, -108,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -108, -99, -90, -76, -66, -45,
+ -43, -41, -44, -47, -43, -47, -40, -30,
+ -31, -31, -39, -33, -40, -41, -43, -53,
+ -59, -70, -73, -77, -79, -82, -84, -87,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999}},
+ /* 4000 Hz */
+ {{-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -110, -91, -76,
+ -75, -85, -93, -98, -104, -110, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -110, -91, -70,
+ -70, -75, -86, -89, -94, -98, -101, -106,
+ -110, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -110, -95, -80, -60,
+ -65, -64, -74, -83, -88, -91, -95, -99,
+ -103, -107, -110, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -110, -95, -80, -58,
+ -55, -49, -66, -68, -71, -78, -78, -80,
+ -88, -85, -89, -97, -100, -105, -110, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -110, -95, -80, -53,
+ -52, -41, -59, -59, -49, -58, -56, -63,
+ -86, -79, -90, -93, -98, -103, -107, -112,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -110, -97, -91, -73, -45,
+ -40, -33, -53, -61, -49, -54, -50, -50,
+ -60, -52, -67, -74, -81, -92, -96, -100,
+ -105, -110, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999}},
+ /* 5657 Hz */
+ {{-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -113, -106, -99, -92, -77,
+ -80, -88, -97, -106, -115, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -116, -109, -102, -95, -89, -74,
+ -72, -88, -87, -95, -102, -109, -116, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -116, -109, -102, -95, -89, -75,
+ -66, -74, -77, -78, -86, -87, -90, -96,
+ -105, -115, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -115, -108, -101, -94, -88, -66,
+ -56, -61, -70, -65, -78, -72, -83, -84,
+ -93, -98, -105, -110, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -110, -105, -95, -89, -82, -57,
+ -52, -52, -59, -56, -59, -58, -69, -67,
+ -88, -82, -82, -89, -94, -100, -108, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -110, -101, -96, -90, -83, -77, -54,
+ -43, -38, -50, -48, -52, -48, -42, -42,
+ -51, -52, -53, -59, -65, -71, -78, -85,
+ -95, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999}},
+ /* 8000 Hz */
+ {{-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -120, -105, -86, -68,
+ -78, -79, -90, -100, -110, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -120, -105, -86, -66,
+ -73, -77, -88, -96, -105, -115, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -120, -105, -92, -80, -61,
+ -64, -68, -80, -87, -92, -100, -110, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -120, -104, -91, -79, -52,
+ -60, -54, -64, -69, -77, -80, -82, -84,
+ -85, -87, -88, -90, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -118, -100, -87, -77, -49,
+ -50, -44, -58, -61, -61, -67, -65, -62,
+ -62, -62, -65, -68, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -115, -98, -84, -62, -49,
+ -44, -38, -46, -49, -49, -46, -39, -37,
+ -39, -40, -42, -43, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999}},
+ /* 11314 Hz */
+ {{-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -110, -88, -74,
+ -77, -82, -82, -85, -90, -94, -99, -104,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -110, -88, -66,
+ -70, -81, -80, -81, -84, -88, -91, -93,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -110, -88, -61,
+ -63, -70, -71, -74, -77, -80, -83, -85,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -110, -86, -62,
+ -63, -62, -62, -58, -52, -50, -50, -52,
+ -54, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -118, -108, -84, -53,
+ -50, -50, -50, -55, -47, -45, -40, -40,
+ -40, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -118, -100, -73, -43,
+ -37, -42, -43, -53, -38, -37, -35, -35,
+ -38, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999}},
+ /* 16000 Hz */
+ {{-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -110, -100, -91, -84, -74,
+ -80, -80, -80, -80, -80, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -110, -100, -91, -84, -74,
+ -68, -68, -68, -68, -68, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -110, -100, -86, -78, -70,
+ -60, -45, -30, -21, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -110, -100, -87, -78, -67,
+ -48, -38, -29, -21, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -110, -100, -86, -69, -56,
+ -45, -35, -33, -29, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999},
+ {-999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -110, -100, -83, -71, -48,
+ -27, -38, -37, -34, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999,
+ -999, -999, -999, -999, -999, -999, -999, -999}}
+};
+
+#endif
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: normalized modified discrete cosine transform
+ power of two length transform only [64 <= n ]
+ last mod: $Id: mdct.c 16227 2009-07-08 06:58:46Z xiphmont $
+
+ Original algorithm adapted long ago from _The use of multirate filter
+ banks for coding of high quality digital audio_, by T. Sporer,
+ K. Brandenburg and B. Edler, collection of the European Signal
+ Processing Conference (EUSIPCO), Amsterdam, June 1992, Vol.1, pp
+ 211-214
+
+ The below code implements an algorithm that no longer looks much like
+ that presented in the paper, but the basic structure remains if you
+ dig deep enough to see it.
+
+ This module DOES NOT INCLUDE code to generate/apply the window
+ function. Everybody has their own weird favorite including me... I
+ happen to like the properties of y=sin(.5PI*sin^2(x)), but others may
+ vehemently disagree.
+
+ ********************************************************************/
+
+/* this can also be run as an integer transform by uncommenting a
+ define in mdct.h; the integerization is a first pass and although
+ it's likely stable for Vorbis, the dynamic range is constrained and
+ roundoff isn't done (so it's noisy). Consider it functional, but
+ only a starting point. There's no point on a machine with an FPU */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include "vorbis/codec.h"
+#include "mdct.h"
+#include "os.h"
+#include "misc.h"
+
+/* build lookups for trig functions; also pre-figure scaling and
+ some window function algebra. */
+
+void mdct_init(mdct_lookup *lookup,int n){
+ int *bitrev=_ogg_malloc(sizeof(*bitrev)*(n/4));
+ DATA_TYPE *T=_ogg_malloc(sizeof(*T)*(n+n/4));
+
+ int i;
+ int n2=n>>1;
+ int log2n=lookup->log2n=rint(log((float)n)/log(2.f));
+ lookup->n=n;
+ lookup->trig=T;
+ lookup->bitrev=bitrev;
+
+/* trig lookups... */
+
+ for(i=0;i<n/4;i++){
+ T[i*2]=FLOAT_CONV(cos((M_PI/n)*(4*i)));
+ T[i*2+1]=FLOAT_CONV(-sin((M_PI/n)*(4*i)));
+ T[n2+i*2]=FLOAT_CONV(cos((M_PI/(2*n))*(2*i+1)));
+ T[n2+i*2+1]=FLOAT_CONV(sin((M_PI/(2*n))*(2*i+1)));
+ }
+ for(i=0;i<n/8;i++){
+ T[n+i*2]=FLOAT_CONV(cos((M_PI/n)*(4*i+2))*.5);
+ T[n+i*2+1]=FLOAT_CONV(-sin((M_PI/n)*(4*i+2))*.5);
+ }
+
+ /* bitreverse lookup... */
+
+ {
+ int mask=(1<<(log2n-1))-1,i,j;
+ int msb=1<<(log2n-2);
+ for(i=0;i<n/8;i++){
+ int acc=0;
+ for(j=0;msb>>j;j++)
+ if((msb>>j)&i)acc|=1<<j;
+ bitrev[i*2]=((~acc)&mask)-1;
+ bitrev[i*2+1]=acc;
+
+ }
+ }
+ lookup->scale=FLOAT_CONV(4.f/n);
+}
+
+/* 8 point butterfly (in place, 4 register) */
+STIN void mdct_butterfly_8(DATA_TYPE *x){
+ REG_TYPE r0 = x[6] + x[2];
+ REG_TYPE r1 = x[6] - x[2];
+ REG_TYPE r2 = x[4] + x[0];
+ REG_TYPE r3 = x[4] - x[0];
+
+ x[6] = r0 + r2;
+ x[4] = r0 - r2;
+
+ r0 = x[5] - x[1];
+ r2 = x[7] - x[3];
+ x[0] = r1 + r0;
+ x[2] = r1 - r0;
+
+ r0 = x[5] + x[1];
+ r1 = x[7] + x[3];
+ x[3] = r2 + r3;
+ x[1] = r2 - r3;
+ x[7] = r1 + r0;
+ x[5] = r1 - r0;
+
+}
+
+/* 16 point butterfly (in place, 4 register) */
+STIN void mdct_butterfly_16(DATA_TYPE *x){
+ REG_TYPE r0 = x[1] - x[9];
+ REG_TYPE r1 = x[0] - x[8];
+
+ x[8] += x[0];
+ x[9] += x[1];
+ x[0] = MULT_NORM((r0 + r1) * cPI2_8);
+ x[1] = MULT_NORM((r0 - r1) * cPI2_8);
+
+ r0 = x[3] - x[11];
+ r1 = x[10] - x[2];
+ x[10] += x[2];
+ x[11] += x[3];
+ x[2] = r0;
+ x[3] = r1;
+
+ r0 = x[12] - x[4];
+ r1 = x[13] - x[5];
+ x[12] += x[4];
+ x[13] += x[5];
+ x[4] = MULT_NORM((r0 - r1) * cPI2_8);
+ x[5] = MULT_NORM((r0 + r1) * cPI2_8);
+
+ r0 = x[14] - x[6];
+ r1 = x[15] - x[7];
+ x[14] += x[6];
+ x[15] += x[7];
+ x[6] = r0;
+ x[7] = r1;
+
+ mdct_butterfly_8(x);
+ mdct_butterfly_8(x+8);
+}
+
+/* 32 point butterfly (in place, 4 register) */
+STIN void mdct_butterfly_32(DATA_TYPE *x){
+ REG_TYPE r0 = x[30] - x[14];
+ REG_TYPE r1 = x[31] - x[15];
+
+ x[30] += x[14];
+ x[31] += x[15];
+ x[14] = r0;
+ x[15] = r1;
+
+ r0 = x[28] - x[12];
+ r1 = x[29] - x[13];
+ x[28] += x[12];
+ x[29] += x[13];
+ x[12] = MULT_NORM( r0 * cPI1_8 - r1 * cPI3_8 );
+ x[13] = MULT_NORM( r0 * cPI3_8 + r1 * cPI1_8 );
+
+ r0 = x[26] - x[10];
+ r1 = x[27] - x[11];
+ x[26] += x[10];
+ x[27] += x[11];
+ x[10] = MULT_NORM(( r0 - r1 ) * cPI2_8);
+ x[11] = MULT_NORM(( r0 + r1 ) * cPI2_8);
+
+ r0 = x[24] - x[8];
+ r1 = x[25] - x[9];
+ x[24] += x[8];
+ x[25] += x[9];
+ x[8] = MULT_NORM( r0 * cPI3_8 - r1 * cPI1_8 );
+ x[9] = MULT_NORM( r1 * cPI3_8 + r0 * cPI1_8 );
+
+ r0 = x[22] - x[6];
+ r1 = x[7] - x[23];
+ x[22] += x[6];
+ x[23] += x[7];
+ x[6] = r1;
+ x[7] = r0;
+
+ r0 = x[4] - x[20];
+ r1 = x[5] - x[21];
+ x[20] += x[4];
+ x[21] += x[5];
+ x[4] = MULT_NORM( r1 * cPI1_8 + r0 * cPI3_8 );
+ x[5] = MULT_NORM( r1 * cPI3_8 - r0 * cPI1_8 );
+
+ r0 = x[2] - x[18];
+ r1 = x[3] - x[19];
+ x[18] += x[2];
+ x[19] += x[3];
+ x[2] = MULT_NORM(( r1 + r0 ) * cPI2_8);
+ x[3] = MULT_NORM(( r1 - r0 ) * cPI2_8);
+
+ r0 = x[0] - x[16];
+ r1 = x[1] - x[17];
+ x[16] += x[0];
+ x[17] += x[1];
+ x[0] = MULT_NORM( r1 * cPI3_8 + r0 * cPI1_8 );
+ x[1] = MULT_NORM( r1 * cPI1_8 - r0 * cPI3_8 );
+
+ mdct_butterfly_16(x);
+ mdct_butterfly_16(x+16);
+
+}
+
+/* N point first stage butterfly (in place, 2 register) */
+STIN void mdct_butterfly_first(DATA_TYPE *T,
+ DATA_TYPE *x,
+ int points){
+
+ DATA_TYPE *x1 = x + points - 8;
+ DATA_TYPE *x2 = x + (points>>1) - 8;
+ REG_TYPE r0;
+ REG_TYPE r1;
+
+ do{
+
+ r0 = x1[6] - x2[6];
+ r1 = x1[7] - x2[7];
+ x1[6] += x2[6];
+ x1[7] += x2[7];
+ x2[6] = MULT_NORM(r1 * T[1] + r0 * T[0]);
+ x2[7] = MULT_NORM(r1 * T[0] - r0 * T[1]);
+
+ r0 = x1[4] - x2[4];
+ r1 = x1[5] - x2[5];
+ x1[4] += x2[4];
+ x1[5] += x2[5];
+ x2[4] = MULT_NORM(r1 * T[5] + r0 * T[4]);
+ x2[5] = MULT_NORM(r1 * T[4] - r0 * T[5]);
+
+ r0 = x1[2] - x2[2];
+ r1 = x1[3] - x2[3];
+ x1[2] += x2[2];
+ x1[3] += x2[3];
+ x2[2] = MULT_NORM(r1 * T[9] + r0 * T[8]);
+ x2[3] = MULT_NORM(r1 * T[8] - r0 * T[9]);
+
+ r0 = x1[0] - x2[0];
+ r1 = x1[1] - x2[1];
+ x1[0] += x2[0];
+ x1[1] += x2[1];
+ x2[0] = MULT_NORM(r1 * T[13] + r0 * T[12]);
+ x2[1] = MULT_NORM(r1 * T[12] - r0 * T[13]);
+
+ x1-=8;
+ x2-=8;
+ T+=16;
+
+ }while(x2>=x);
+}
+
+/* N/stage point generic N stage butterfly (in place, 2 register) */
+STIN void mdct_butterfly_generic(DATA_TYPE *T,
+ DATA_TYPE *x,
+ int points,
+ int trigint){
+
+ DATA_TYPE *x1 = x + points - 8;
+ DATA_TYPE *x2 = x + (points>>1) - 8;
+ REG_TYPE r0;
+ REG_TYPE r1;
+
+ do{
+
+ r0 = x1[6] - x2[6];
+ r1 = x1[7] - x2[7];
+ x1[6] += x2[6];
+ x1[7] += x2[7];
+ x2[6] = MULT_NORM(r1 * T[1] + r0 * T[0]);
+ x2[7] = MULT_NORM(r1 * T[0] - r0 * T[1]);
+
+ T+=trigint;
+
+ r0 = x1[4] - x2[4];
+ r1 = x1[5] - x2[5];
+ x1[4] += x2[4];
+ x1[5] += x2[5];
+ x2[4] = MULT_NORM(r1 * T[1] + r0 * T[0]);
+ x2[5] = MULT_NORM(r1 * T[0] - r0 * T[1]);
+
+ T+=trigint;
+
+ r0 = x1[2] - x2[2];
+ r1 = x1[3] - x2[3];
+ x1[2] += x2[2];
+ x1[3] += x2[3];
+ x2[2] = MULT_NORM(r1 * T[1] + r0 * T[0]);
+ x2[3] = MULT_NORM(r1 * T[0] - r0 * T[1]);
+
+ T+=trigint;
+
+ r0 = x1[0] - x2[0];
+ r1 = x1[1] - x2[1];
+ x1[0] += x2[0];
+ x1[1] += x2[1];
+ x2[0] = MULT_NORM(r1 * T[1] + r0 * T[0]);
+ x2[1] = MULT_NORM(r1 * T[0] - r0 * T[1]);
+
+ T+=trigint;
+ x1-=8;
+ x2-=8;
+
+ }while(x2>=x);
+}
+
+STIN void mdct_butterflies(mdct_lookup *init,
+ DATA_TYPE *x,
+ int points){
+
+ DATA_TYPE *T=init->trig;
+ int stages=init->log2n-5;
+ int i,j;
+
+ if(--stages>0){
+ mdct_butterfly_first(T,x,points);
+ }
+
+ for(i=1;--stages>0;i++){
+ for(j=0;j<(1<<i);j++)
+ mdct_butterfly_generic(T,x+(points>>i)*j,points>>i,4<<i);
+ }
+
+ for(j=0;j<points;j+=32)
+ mdct_butterfly_32(x+j);
+
+}
+
+void mdct_clear(mdct_lookup *l){
+ if(l){
+ if(l->trig)_ogg_free(l->trig);
+ if(l->bitrev)_ogg_free(l->bitrev);
+ memset(l,0,sizeof(*l));
+ }
+}
+
+STIN void mdct_bitreverse(mdct_lookup *init,
+ DATA_TYPE *x){
+ int n = init->n;
+ int *bit = init->bitrev;
+ DATA_TYPE *w0 = x;
+ DATA_TYPE *w1 = x = w0+(n>>1);
+ DATA_TYPE *T = init->trig+n;
+
+ do{
+ DATA_TYPE *x0 = x+bit[0];
+ DATA_TYPE *x1 = x+bit[1];
+
+ REG_TYPE r0 = x0[1] - x1[1];
+ REG_TYPE r1 = x0[0] + x1[0];
+ REG_TYPE r2 = MULT_NORM(r1 * T[0] + r0 * T[1]);
+ REG_TYPE r3 = MULT_NORM(r1 * T[1] - r0 * T[0]);
+
+ w1 -= 4;
+
+ r0 = HALVE(x0[1] + x1[1]);
+ r1 = HALVE(x0[0] - x1[0]);
+
+ w0[0] = r0 + r2;
+ w1[2] = r0 - r2;
+ w0[1] = r1 + r3;
+ w1[3] = r3 - r1;
+
+ x0 = x+bit[2];
+ x1 = x+bit[3];
+
+ r0 = x0[1] - x1[1];
+ r1 = x0[0] + x1[0];
+ r2 = MULT_NORM(r1 * T[2] + r0 * T[3]);
+ r3 = MULT_NORM(r1 * T[3] - r0 * T[2]);
+
+ r0 = HALVE(x0[1] + x1[1]);
+ r1 = HALVE(x0[0] - x1[0]);
+
+ w0[2] = r0 + r2;
+ w1[0] = r0 - r2;
+ w0[3] = r1 + r3;
+ w1[1] = r3 - r1;
+
+ T += 4;
+ bit += 4;
+ w0 += 4;
+
+ }while(w0<w1);
+}
+
+void mdct_backward(mdct_lookup *init, DATA_TYPE *in, DATA_TYPE *out){
+ int n=init->n;
+ int n2=n>>1;
+ int n4=n>>2;
+
+ /* rotate */
+
+ DATA_TYPE *iX = in+n2-7;
+ DATA_TYPE *oX = out+n2+n4;
+ DATA_TYPE *T = init->trig+n4;
+
+ do{
+ oX -= 4;
+ oX[0] = MULT_NORM(-iX[2] * T[3] - iX[0] * T[2]);
+ oX[1] = MULT_NORM (iX[0] * T[3] - iX[2] * T[2]);
+ oX[2] = MULT_NORM(-iX[6] * T[1] - iX[4] * T[0]);
+ oX[3] = MULT_NORM (iX[4] * T[1] - iX[6] * T[0]);
+ iX -= 8;
+ T += 4;
+ }while(iX>=in);
+
+ iX = in+n2-8;
+ oX = out+n2+n4;
+ T = init->trig+n4;
+
+ do{
+ T -= 4;
+ oX[0] = MULT_NORM (iX[4] * T[3] + iX[6] * T[2]);
+ oX[1] = MULT_NORM (iX[4] * T[2] - iX[6] * T[3]);
+ oX[2] = MULT_NORM (iX[0] * T[1] + iX[2] * T[0]);
+ oX[3] = MULT_NORM (iX[0] * T[0] - iX[2] * T[1]);
+ iX -= 8;
+ oX += 4;
+ }while(iX>=in);
+
+ mdct_butterflies(init,out+n2,n2);
+ mdct_bitreverse(init,out);
+
+ /* roatate + window */
+
+ {
+ DATA_TYPE *oX1=out+n2+n4;
+ DATA_TYPE *oX2=out+n2+n4;
+ DATA_TYPE *iX =out;
+ T =init->trig+n2;
+
+ do{
+ oX1-=4;
+
+ oX1[3] = MULT_NORM (iX[0] * T[1] - iX[1] * T[0]);
+ oX2[0] = -MULT_NORM (iX[0] * T[0] + iX[1] * T[1]);
+
+ oX1[2] = MULT_NORM (iX[2] * T[3] - iX[3] * T[2]);
+ oX2[1] = -MULT_NORM (iX[2] * T[2] + iX[3] * T[3]);
+
+ oX1[1] = MULT_NORM (iX[4] * T[5] - iX[5] * T[4]);
+ oX2[2] = -MULT_NORM (iX[4] * T[4] + iX[5] * T[5]);
+
+ oX1[0] = MULT_NORM (iX[6] * T[7] - iX[7] * T[6]);
+ oX2[3] = -MULT_NORM (iX[6] * T[6] + iX[7] * T[7]);
+
+ oX2+=4;
+ iX += 8;
+ T += 8;
+ }while(iX<oX1);
+
+ iX=out+n2+n4;
+ oX1=out+n4;
+ oX2=oX1;
+
+ do{
+ oX1-=4;
+ iX-=4;
+
+ oX2[0] = -(oX1[3] = iX[3]);
+ oX2[1] = -(oX1[2] = iX[2]);
+ oX2[2] = -(oX1[1] = iX[1]);
+ oX2[3] = -(oX1[0] = iX[0]);
+
+ oX2+=4;
+ }while(oX2<iX);
+
+ iX=out+n2+n4;
+ oX1=out+n2+n4;
+ oX2=out+n2;
+ do{
+ oX1-=4;
+ oX1[0]= iX[3];
+ oX1[1]= iX[2];
+ oX1[2]= iX[1];
+ oX1[3]= iX[0];
+ iX+=4;
+ }while(oX1>oX2);
+ }
+}
+
+void mdct_forward(mdct_lookup *init, DATA_TYPE *in, DATA_TYPE *out){
+ int n=init->n;
+ int n2=n>>1;
+ int n4=n>>2;
+ int n8=n>>3;
+ DATA_TYPE *w=alloca(n*sizeof(*w)); /* forward needs working space */
+ DATA_TYPE *w2=w+n2;
+
+ /* rotate */
+
+ /* window + rotate + step 1 */
+
+ REG_TYPE r0;
+ REG_TYPE r1;
+ DATA_TYPE *x0=in+n2+n4;
+ DATA_TYPE *x1=x0+1;
+ DATA_TYPE *T=init->trig+n2;
+
+ int i=0;
+
+ for(i=0;i<n8;i+=2){
+ x0 -=4;
+ T-=2;
+ r0= x0[2] + x1[0];
+ r1= x0[0] + x1[2];
+ w2[i]= MULT_NORM(r1*T[1] + r0*T[0]);
+ w2[i+1]= MULT_NORM(r1*T[0] - r0*T[1]);
+ x1 +=4;
+ }
+
+ x1=in+1;
+
+ for(;i<n2-n8;i+=2){
+ T-=2;
+ x0 -=4;
+ r0= x0[2] - x1[0];
+ r1= x0[0] - x1[2];
+ w2[i]= MULT_NORM(r1*T[1] + r0*T[0]);
+ w2[i+1]= MULT_NORM(r1*T[0] - r0*T[1]);
+ x1 +=4;
+ }
+
+ x0=in+n;
+
+ for(;i<n2;i+=2){
+ T-=2;
+ x0 -=4;
+ r0= -x0[2] - x1[0];
+ r1= -x0[0] - x1[2];
+ w2[i]= MULT_NORM(r1*T[1] + r0*T[0]);
+ w2[i+1]= MULT_NORM(r1*T[0] - r0*T[1]);
+ x1 +=4;
+ }
+
+
+ mdct_butterflies(init,w+n2,n2);
+ mdct_bitreverse(init,w);
+
+ /* roatate + window */
+
+ T=init->trig+n2;
+ x0=out+n2;
+
+ for(i=0;i<n4;i++){
+ x0--;
+ out[i] =MULT_NORM((w[0]*T[0]+w[1]*T[1])*init->scale);
+ x0[0] =MULT_NORM((w[0]*T[1]-w[1]*T[0])*init->scale);
+ w+=2;
+ T+=2;
+ }
+}
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: modified discrete cosine transform prototypes
+ last mod: $Id: mdct.h 16227 2009-07-08 06:58:46Z xiphmont $
+
+ ********************************************************************/
+
+#ifndef _OGG_mdct_H_
+#define _OGG_mdct_H_
+
+#include "vorbis/codec.h"
+
+
+
+
+
+/*#define MDCT_INTEGERIZED <- be warned there could be some hurt left here*/
+#ifdef MDCT_INTEGERIZED
+
+#define DATA_TYPE int
+#define REG_TYPE register int
+#define TRIGBITS 14
+#define cPI3_8 6270
+#define cPI2_8 11585
+#define cPI1_8 15137
+
+#define FLOAT_CONV(x) ((int)((x)*(1<<TRIGBITS)+.5))
+#define MULT_NORM(x) ((x)>>TRIGBITS)
+#define HALVE(x) ((x)>>1)
+
+#else
+
+#define DATA_TYPE float
+#define REG_TYPE float
+#define cPI3_8 .38268343236508977175F
+#define cPI2_8 .70710678118654752441F
+#define cPI1_8 .92387953251128675613F
+
+#define FLOAT_CONV(x) (x)
+#define MULT_NORM(x) (x)
+#define HALVE(x) ((x)*.5f)
+
+#endif
+
+
+typedef struct {
+ int n;
+ int log2n;
+
+ DATA_TYPE *trig;
+ int *bitrev;
+
+ DATA_TYPE scale;
+} mdct_lookup;
+
+extern void mdct_init(mdct_lookup *lookup,int n);
+extern void mdct_clear(mdct_lookup *l);
+extern void mdct_forward(mdct_lookup *init, DATA_TYPE *in, DATA_TYPE *out);
+extern void mdct_backward(mdct_lookup *init, DATA_TYPE *in, DATA_TYPE *out);
+
+#endif
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: miscellaneous prototypes
+ last mod: $Id: misc.h 16227 2009-07-08 06:58:46Z xiphmont $
+
+ ********************************************************************/
+
+#ifndef _V_RANDOM_H_
+#define _V_RANDOM_H_
+#include "vorbis/codec.h"
+
+extern void *_vorbis_block_alloc(vorbis_block *vb,long bytes);
+extern void _vorbis_block_ripcord(vorbis_block *vb);
+
+#ifdef ANALYSIS
+extern int analysis_noisy;
+extern void _analysis_output(char *base,int i,float *v,int n,int bark,int dB,
+ ogg_int64_t off);
+extern void _analysis_output_always(char *base,int i,float *v,int n,int bark,int dB,
+ ogg_int64_t off);
+#endif
+
+#ifdef DEBUG_MALLOC
+
+#define _VDBG_GRAPHFILE "malloc.m"
+#undef _VDBG_GRAPHFILE
+extern void *_VDBG_malloc(void *ptr,long bytes,char *file,long line);
+extern void _VDBG_free(void *ptr,char *file,long line);
+
+#ifndef MISC_C
+#undef _ogg_malloc
+#undef _ogg_calloc
+#undef _ogg_realloc
+#undef _ogg_free
+
+#define _ogg_malloc(x) _VDBG_malloc(NULL,(x),__FILE__,__LINE__)
+#define _ogg_calloc(x,y) _VDBG_malloc(NULL,(x)*(y),__FILE__,__LINE__)
+#define _ogg_realloc(x,y) _VDBG_malloc((x),(y),__FILE__,__LINE__)
+#define _ogg_free(x) _VDBG_free((x),__FILE__,__LINE__)
+#endif
+#endif
+
+#endif
+
+
+
+
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: key floor settings
+ last mod: $Id: floor_all.h 17050 2010-03-26 01:34:42Z xiphmont $
+
+ ********************************************************************/
+
+#include "vorbis/codec.h"
+#include "backends.h"
+#include "books/floor/floor_books.h"
+
+static const static_codebook*const _floor_128x4_books[]={
+ &_huff_book_line_128x4_class0,
+ &_huff_book_line_128x4_0sub0,
+ &_huff_book_line_128x4_0sub1,
+ &_huff_book_line_128x4_0sub2,
+ &_huff_book_line_128x4_0sub3,
+};
+static const static_codebook*const _floor_256x4_books[]={
+ &_huff_book_line_256x4_class0,
+ &_huff_book_line_256x4_0sub0,
+ &_huff_book_line_256x4_0sub1,
+ &_huff_book_line_256x4_0sub2,
+ &_huff_book_line_256x4_0sub3,
+};
+static const static_codebook*const _floor_128x7_books[]={
+ &_huff_book_line_128x7_class0,
+ &_huff_book_line_128x7_class1,
+
+ &_huff_book_line_128x7_0sub1,
+ &_huff_book_line_128x7_0sub2,
+ &_huff_book_line_128x7_0sub3,
+ &_huff_book_line_128x7_1sub1,
+ &_huff_book_line_128x7_1sub2,
+ &_huff_book_line_128x7_1sub3,
+};
+static const static_codebook*const _floor_256x7_books[]={
+ &_huff_book_line_256x7_class0,
+ &_huff_book_line_256x7_class1,
+
+ &_huff_book_line_256x7_0sub1,
+ &_huff_book_line_256x7_0sub2,
+ &_huff_book_line_256x7_0sub3,
+ &_huff_book_line_256x7_1sub1,
+ &_huff_book_line_256x7_1sub2,
+ &_huff_book_line_256x7_1sub3,
+};
+static const static_codebook*const _floor_128x11_books[]={
+ &_huff_book_line_128x11_class1,
+ &_huff_book_line_128x11_class2,
+ &_huff_book_line_128x11_class3,
+
+ &_huff_book_line_128x11_0sub0,
+ &_huff_book_line_128x11_1sub0,
+ &_huff_book_line_128x11_1sub1,
+ &_huff_book_line_128x11_2sub1,
+ &_huff_book_line_128x11_2sub2,
+ &_huff_book_line_128x11_2sub3,
+ &_huff_book_line_128x11_3sub1,
+ &_huff_book_line_128x11_3sub2,
+ &_huff_book_line_128x11_3sub3,
+};
+static const static_codebook*const _floor_128x17_books[]={
+ &_huff_book_line_128x17_class1,
+ &_huff_book_line_128x17_class2,
+ &_huff_book_line_128x17_class3,
+
+ &_huff_book_line_128x17_0sub0,
+ &_huff_book_line_128x17_1sub0,
+ &_huff_book_line_128x17_1sub1,
+ &_huff_book_line_128x17_2sub1,
+ &_huff_book_line_128x17_2sub2,
+ &_huff_book_line_128x17_2sub3,
+ &_huff_book_line_128x17_3sub1,
+ &_huff_book_line_128x17_3sub2,
+ &_huff_book_line_128x17_3sub3,
+};
+static const static_codebook*const _floor_256x4low_books[]={
+ &_huff_book_line_256x4low_class0,
+ &_huff_book_line_256x4low_0sub0,
+ &_huff_book_line_256x4low_0sub1,
+ &_huff_book_line_256x4low_0sub2,
+ &_huff_book_line_256x4low_0sub3,
+};
+static const static_codebook*const _floor_1024x27_books[]={
+ &_huff_book_line_1024x27_class1,
+ &_huff_book_line_1024x27_class2,
+ &_huff_book_line_1024x27_class3,
+ &_huff_book_line_1024x27_class4,
+
+ &_huff_book_line_1024x27_0sub0,
+ &_huff_book_line_1024x27_1sub0,
+ &_huff_book_line_1024x27_1sub1,
+ &_huff_book_line_1024x27_2sub0,
+ &_huff_book_line_1024x27_2sub1,
+ &_huff_book_line_1024x27_3sub1,
+ &_huff_book_line_1024x27_3sub2,
+ &_huff_book_line_1024x27_3sub3,
+ &_huff_book_line_1024x27_4sub1,
+ &_huff_book_line_1024x27_4sub2,
+ &_huff_book_line_1024x27_4sub3,
+};
+static const static_codebook*const _floor_2048x27_books[]={
+ &_huff_book_line_2048x27_class1,
+ &_huff_book_line_2048x27_class2,
+ &_huff_book_line_2048x27_class3,
+ &_huff_book_line_2048x27_class4,
+
+ &_huff_book_line_2048x27_0sub0,
+ &_huff_book_line_2048x27_1sub0,
+ &_huff_book_line_2048x27_1sub1,
+ &_huff_book_line_2048x27_2sub0,
+ &_huff_book_line_2048x27_2sub1,
+ &_huff_book_line_2048x27_3sub1,
+ &_huff_book_line_2048x27_3sub2,
+ &_huff_book_line_2048x27_3sub3,
+ &_huff_book_line_2048x27_4sub1,
+ &_huff_book_line_2048x27_4sub2,
+ &_huff_book_line_2048x27_4sub3,
+};
+
+static const static_codebook*const _floor_512x17_books[]={
+ &_huff_book_line_512x17_class1,
+ &_huff_book_line_512x17_class2,
+ &_huff_book_line_512x17_class3,
+
+ &_huff_book_line_512x17_0sub0,
+ &_huff_book_line_512x17_1sub0,
+ &_huff_book_line_512x17_1sub1,
+ &_huff_book_line_512x17_2sub1,
+ &_huff_book_line_512x17_2sub2,
+ &_huff_book_line_512x17_2sub3,
+ &_huff_book_line_512x17_3sub1,
+ &_huff_book_line_512x17_3sub2,
+ &_huff_book_line_512x17_3sub3,
+};
+
+static const static_codebook*const _floor_Xx0_books[]={
+ 0
+};
+
+static const static_codebook*const *const _floor_books[11]={
+ _floor_128x4_books,
+ _floor_256x4_books,
+ _floor_128x7_books,
+ _floor_256x7_books,
+ _floor_128x11_books,
+ _floor_128x17_books,
+ _floor_256x4low_books,
+ _floor_1024x27_books,
+ _floor_2048x27_books,
+ _floor_512x17_books,
+ _floor_Xx0_books,
+};
+
+static const vorbis_info_floor1 _floor[11]={
+ /* 0: 128 x 4 */
+ {
+ 1,{0},{4},{2},{0},
+ {{1,2,3,4}},
+ 4,{0,128, 33,8,16,70},
+
+ 60,30,500, 1.,18., 128
+ },
+ /* 1: 256 x 4 */
+ {
+ 1,{0},{4},{2},{0},
+ {{1,2,3,4}},
+ 4,{0,256, 66,16,32,140},
+
+ 60,30,500, 1.,18., 256
+ },
+ /* 2: 128 x 7 */
+ {
+ 2,{0,1},{3,4},{2,2},{0,1},
+ {{-1,2,3,4},{-1,5,6,7}},
+ 4,{0,128, 14,4,58, 2,8,28,90},
+
+ 60,30,500, 1.,18., 128
+ },
+ /* 3: 256 x 7 */
+ {
+ 2,{0,1},{3,4},{2,2},{0,1},
+ {{-1,2,3,4},{-1,5,6,7}},
+ 4,{0,256, 28,8,116, 4,16,56,180},
+
+ 60,30,500, 1.,18., 256
+ },
+ /* 4: 128 x 11 */
+ {
+ 4,{0,1,2,3},{2,3,3,3},{0,1,2,2},{-1,0,1,2},
+ {{3},{4,5},{-1,6,7,8},{-1,9,10,11}},
+
+ 2,{0,128, 8,33, 4,16,70, 2,6,12, 23,46,90},
+
+ 60,30,500, 1,18., 128
+ },
+ /* 5: 128 x 17 */
+ {
+ 6,{0,1,1,2,3,3},{2,3,3,3},{0,1,2,2},{-1,0,1,2},
+ {{3},{4,5},{-1,6,7,8},{-1,9,10,11}},
+ 2,{0,128, 12,46, 4,8,16, 23,33,70, 2,6,10, 14,19,28, 39,58,90},
+
+ 60,30,500, 1,18., 128
+ },
+ /* 6: 256 x 4 (low bitrate version) */
+ {
+ 1,{0},{4},{2},{0},
+ {{1,2,3,4}},
+ 4,{0,256, 66,16,32,140},
+
+ 60,30,500, 1.,18., 256
+ },
+ /* 7: 1024 x 27 */
+ {
+ 8,{0,1,2,2,3,3,4,4},{3,4,3,4,3},{0,1,1,2,2},{-1,0,1,2,3},
+ {{4},{5,6},{7,8},{-1,9,10,11},{-1,12,13,14}},
+ 2,{0,1024, 93,23,372, 6,46,186,750, 14,33,65, 130,260,556,
+ 3,10,18,28, 39,55,79,111, 158,220,312, 464,650,850},
+
+ 60,30,500, 3,18., 1024
+ },
+ /* 8: 2048 x 27 */
+ {
+ 8,{0,1,2,2,3,3,4,4},{3,4,3,4,3},{0,1,1,2,2},{-1,0,1,2,3},
+ {{4},{5,6},{7,8},{-1,9,10,11},{-1,12,13,14}},
+ 2,{0,2048, 186,46,744, 12,92,372,1500, 28,66,130, 260,520,1112,
+ 6,20,36,56, 78,110,158,222, 316,440,624, 928,1300,1700},
+
+ 60,30,500, 3,18., 2048
+ },
+ /* 9: 512 x 17 */
+ {
+ 6,{0,1,1,2,3,3},{2,3,3,3},{0,1,2,2},{-1,0,1,2},
+ {{3},{4,5},{-1,6,7,8},{-1,9,10,11}},
+ 2,{0,512, 46,186, 16,33,65, 93,130,278,
+ 7,23,39, 55,79,110, 156,232,360},
+
+ 60,30,500, 1,18., 512
+ },
+
+ /* 10: X x 0 (LFE floor; edge posts only) */
+ {
+ 0,{0}, {0},{0},{-1},
+ {{-1}},
+ 2,{0,12},
+ 60,30,500, 1.,18., 10
+ },
+
+};
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: 11kHz settings
+ last mod: $Id: psych_11.h 16227 2009-07-08 06:58:46Z xiphmont $
+
+ ********************************************************************/
+
+static const double _psy_lowpass_11[3]={4.5,5.5,30.,};
+
+static const att3 _psy_tone_masteratt_11[3]={
+ {{ 30, 25, 12}, 0, 0}, /* 0 */
+ {{ 30, 25, 12}, 0, 0}, /* 0 */
+ {{ 20, 0, -14}, 0, 0}, /* 0 */
+};
+
+static const vp_adjblock _vp_tonemask_adj_11[3]={
+ /* adjust for mode zero */
+ /* 63 125 250 500 1 2 4 8 16 */
+ {{-20,-20,-20,-20,-20,-16,-10, 0, 0, 0, 0,10, 2, 0,99,99,99}}, /* 0 */
+ {{-20,-20,-20,-20,-20,-16,-10, 0, 0, 0, 0, 5, 0, 0,99,99,99}}, /* 1 */
+ {{-20,-20,-20,-20,-20,-16,-10, 0, 0, 0, 0, 0, 0, 0,99,99,99}}, /* 2 */
+};
+
+
+static const noise3 _psy_noisebias_11[3]={
+ /* 63 125 250 500 1k 2k 4k 8k 16k*/
+ {{{-10,-10,-10,-10, -5, -5, -5, 0, 4, 10, 10, 12, 12, 12, 99, 99, 99},
+ {-15,-15,-15,-15,-10,-10, -5, 0, 0, 4, 4, 5, 5, 10, 99, 99, 99},
+ {-30,-30,-30,-30,-30,-24,-20,-14,-10, -6, -8, -8, -6, -6, 99, 99, 99}}},
+
+ {{{-10,-10,-10,-10, -5, -5, -5, 0, 4, 10, 10, 12, 12, 12, 99, 99, 99},
+ {-15,-15,-15,-15,-10,-10, -5, -5, -5, 0, 0, 0, 0, 0, 99, 99, 99},
+ {-30,-30,-30,-30,-30,-24,-20,-14,-10, -6, -8, -8, -6, -6, 99, 99, 99}}},
+
+ {{{-15,-15,-15,-15,-15,-12,-10, -8, 0, 2, 4, 4, 5, 5, 99, 99, 99},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-12,-12,-10,-10,-10,-10, 99, 99, 99},
+ {-30,-30,-30,-30,-26,-26,-26,-26,-26,-26,-26,-26,-26,-24, 99, 99, 99}}},
+};
+
+static const double _noise_thresh_11[3]={ .3,.5,.5 };
+
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: 16kHz settings
+ last mod: $Id: psych_16.h 16227 2009-07-08 06:58:46Z xiphmont $
+
+ ********************************************************************/
+
+/* stereo mode by base quality level */
+static const adj_stereo _psy_stereo_modes_16[4]={
+ /* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 */
+ {{ 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3},
+ { 6, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4},
+ { 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 4, 4},
+ { 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99}},
+ {{ 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3},
+ { 6, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4},
+ { 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 4, 4, 4, 4, 4},
+ { 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99}},
+ {{ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3},
+ { 5, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3},
+ { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4},
+ { 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99}},
+ {{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8},
+ { 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99}},
+};
+
+static const double _psy_lowpass_16[4]={6.5,8,30.,99.};
+
+static const att3 _psy_tone_masteratt_16[4]={
+ {{ 30, 25, 12}, 0, 0}, /* 0 */
+ {{ 25, 22, 12}, 0, 0}, /* 0 */
+ {{ 20, 12, 0}, 0, 0}, /* 0 */
+ {{ 15, 0, -14}, 0, 0}, /* 0 */
+};
+
+static const vp_adjblock _vp_tonemask_adj_16[4]={
+ /* adjust for mode zero */
+ /* 63 125 250 500 1 2 4 8 16 */
+ {{-20,-20,-20,-20,-20,-16,-10, 0, 0, 0, 0,10, 0, 0, 0, 0, 0}}, /* 0 */
+ {{-20,-20,-20,-20,-20,-16,-10, 0, 0, 0, 0,10, 0, 0, 0, 0, 0}}, /* 1 */
+ {{-20,-20,-20,-20,-20,-16,-10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, /* 2 */
+ {{-30,-30,-30,-30,-30,-26,-20,-10, -5, 0, 0, 0, 0, 0, 0, 0, 0}}, /* 2 */
+};
+
+
+static const noise3 _psy_noisebias_16_short[4]={
+ /* 63 125 250 500 1k 2k 4k 8k 16k*/
+ {{{-15,-15,-15,-15,-15,-10,-10,-5, 4, 10, 10, 10, 10, 12, 12, 14, 20},
+ {-15,-15,-15,-15,-15,-10,-10, -5, 0, 0, 4, 5, 5, 6, 8, 8, 15},
+ {-30,-30,-30,-30,-30,-24,-20,-14,-10, -6, -8, -8, -6, -6, -6, -6, -6}}},
+
+ {{{-15,-15,-15,-15,-15,-10,-10,-5, 4, 6, 6, 6, 6, 8, 10, 12, 20},
+ {-15,-15,-15,-15,-15,-15,-15,-10, -5, -5, -5, 4, 5, 6, 8, 8, 15},
+ {-30,-30,-30,-30,-30,-24,-20,-14,-10,-10,-10,-10,-10,-10,-10,-10,-10}}},
+
+ {{{-15,-15,-15,-15,-15,-12,-10, -8, 0, 2, 4, 4, 5, 5, 5, 8, 12},
+ {-20,-20,-20,-20,-16,-12,-20,-14,-10,-10, -8, 0, 0, 0, 0, 2, 5},
+ {-30,-30,-30,-30,-26,-26,-26,-26,-26,-26,-26,-26,-26,-24,-20,-20,-20}}},
+
+ {{{-15,-15,-15,-15,-15,-12,-10, -8, -5, -5, -5, -5, -5, 0, 0, 0, 6},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-12,-12,-10,-10,-10,-10,-10,-10, -6},
+ {-30,-30,-30,-30,-26,-26,-26,-26,-26,-26,-26,-26,-26,-24,-20,-20,-20}}},
+};
+
+static const noise3 _psy_noisebias_16_impulse[4]={
+ /* 63 125 250 500 1k 2k 4k 8k 16k*/
+ {{{-15,-15,-15,-15,-15,-10,-10,-5, 4, 10, 10, 10, 10, 12, 12, 14, 20},
+ {-15,-15,-15,-15,-15,-10,-10, -5, 0, 0, 4, 5, 5, 6, 8, 8, 15},
+ {-30,-30,-30,-30,-30,-24,-20,-14,-10, -6, -8, -8, -6, -6, -6, -6, -6}}},
+
+ {{{-15,-15,-15,-15,-15,-10,-10,-5, 4, 4, 4, 4, 5, 5, 6, 8, 15},
+ {-15,-15,-15,-15,-15,-15,-15,-10, -5, -5, -5, 0, 0, 0, 0, 4, 10},
+ {-30,-30,-30,-30,-30,-24,-20,-14,-10,-10,-10,-10,-10,-10,-10,-10,-10}}},
+
+ {{{-15,-15,-15,-15,-15,-12,-10, -8, 0, 0, 0, 0, 0, 0, 0, 4, 10},
+ {-20,-20,-20,-20,-16,-12,-20,-14,-10,-10,-10,-10,-10,-10,-10, -7, -5},
+ {-30,-30,-30,-30,-26,-26,-26,-26,-26,-26,-26,-26,-26,-24,-20,-20,-20}}},
+
+ {{{-15,-15,-15,-15,-15,-12,-10, -8, -5, -5, -5, -5, -5, 0, 0, 0, 6},
+ {-30,-30,-30,-30,-26,-22,-20,-18,-18,-18,-20,-20,-20,-20,-20,-20,-16},
+ {-30,-30,-30,-30,-26,-26,-26,-26,-26,-26,-26,-26,-26,-24,-20,-20,-20}}},
+};
+
+static const noise3 _psy_noisebias_16[4]={
+ /* 63 125 250 500 1k 2k 4k 8k 16k*/
+ {{{-10,-10,-10,-10, -5, -5, -5, 0, 4, 6, 8, 8, 10, 10, 10, 14, 20},
+ {-10,-10,-10,-10,-10, -5, -2, -2, 0, 0, 0, 4, 5, 6, 8, 8, 15},
+ {-30,-30,-30,-30,-30,-24,-20,-14,-10, -6, -8, -8, -6, -6, -6, -6, -6}}},
+
+ {{{-10,-10,-10,-10, -5, -5, -5, 0, 4, 6, 6, 6, 6, 8, 10, 12, 20},
+ {-15,-15,-15,-15,-15,-10, -5, -5, 0, 0, 0, 4, 5, 6, 8, 8, 15},
+ {-30,-30,-30,-30,-30,-24,-20,-14,-10, -6, -8, -8, -6, -6, -6, -6, -6}}},
+
+ {{{-15,-15,-15,-15,-15,-12,-10, -8, 0, 2, 4, 4, 5, 5, 5, 8, 12},
+ {-20,-20,-20,-20,-16,-12,-20,-10, -5, -5, 0, 0, 0, 0, 0, 2, 5},
+ {-30,-30,-30,-30,-26,-26,-26,-26,-26,-26,-26,-26,-26,-24,-20,-20,-20}}},
+
+ {{{-15,-15,-15,-15,-15,-12,-10, -8, -5, -5, -5, -5, -5, 0, 0, 0, 6},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-12,-12,-10,-10,-10,-10,-10,-10, -6},
+ {-30,-30,-30,-30,-26,-26,-26,-26,-26,-26,-26,-26,-26,-24,-20,-20,-20}}},
+};
+
+static const noiseguard _psy_noiseguards_16[4]={
+ {10,10,-1},
+ {10,10,-1},
+ {20,20,-1},
+ {20,20,-1},
+};
+
+static const double _noise_thresh_16[4]={ .3,.5,.5,.5 };
+
+static const int _noise_start_16[3]={ 256,256,9999 };
+static const int _noise_part_16[4]={ 8,8,8,8 };
+
+static const int _psy_ath_floater_16[4]={
+ -100,-100,-100,-105,
+};
+
+static const int _psy_ath_abs_16[4]={
+ -130,-130,-130,-140,
+};
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: key psychoacoustic settings for 44.1/48kHz
+ last mod: $Id: psych_44.h 16962 2010-03-11 07:30:34Z xiphmont $
+
+ ********************************************************************/
+
+
+/* preecho trigger settings *****************************************/
+
+static const vorbis_info_psy_global _psy_global_44[5]={
+
+ {8, /* lines per eighth octave */
+ {20.f,14.f,12.f,12.f,12.f,12.f,12.f},
+ {-60.f,-30.f,-40.f,-40.f,-40.f,-40.f,-40.f}, 2,-75.f,
+ -6.f,
+ {99.},{{99.},{99.}},{0},{0},{{0.},{0.}}
+ },
+ {8, /* lines per eighth octave */
+ {14.f,10.f,10.f,10.f,10.f,10.f,10.f},
+ {-40.f,-30.f,-25.f,-25.f,-25.f,-25.f,-25.f}, 2,-80.f,
+ -6.f,
+ {99.},{{99.},{99.}},{0},{0},{{0.},{0.}}
+ },
+ {8, /* lines per eighth octave */
+ {12.f,10.f,10.f,10.f,10.f,10.f,10.f},
+ {-20.f,-20.f,-15.f,-15.f,-15.f,-15.f,-15.f}, 0,-80.f,
+ -6.f,
+ {99.},{{99.},{99.}},{0},{0},{{0.},{0.}}
+ },
+ {8, /* lines per eighth octave */
+ {10.f,8.f,8.f,8.f,8.f,8.f,8.f},
+ {-20.f,-15.f,-12.f,-12.f,-12.f,-12.f,-12.f}, 0,-80.f,
+ -6.f,
+ {99.},{{99.},{99.}},{0},{0},{{0.},{0.}}
+ },
+ {8, /* lines per eighth octave */
+ {10.f,6.f,6.f,6.f,6.f,6.f,6.f},
+ {-15.f,-15.f,-12.f,-12.f,-12.f,-12.f,-12.f}, 0,-85.f,
+ -6.f,
+ {99.},{{99.},{99.}},{0},{0},{{0.},{0.}}
+ },
+};
+
+/* noise compander lookups * low, mid, high quality ****************/
+static const compandblock _psy_compand_44[6]={
+ /* sub-mode Z short */
+ {{
+ 0, 1, 2, 3, 4, 5, 6, 7, /* 7dB */
+ 8, 9,10,11,12,13,14, 15, /* 15dB */
+ 16,17,18,19,20,21,22, 23, /* 23dB */
+ 24,25,26,27,28,29,30, 31, /* 31dB */
+ 32,33,34,35,36,37,38, 39, /* 39dB */
+ }},
+ /* mode_Z nominal short */
+ {{
+ 0, 1, 2, 3, 4, 5, 6, 6, /* 7dB */
+ 7, 7, 7, 7, 6, 6, 6, 7, /* 15dB */
+ 7, 8, 9,10,11,12,13, 14, /* 23dB */
+ 15,16,17,17,17,18,18, 19, /* 31dB */
+ 19,19,20,21,22,23,24, 25, /* 39dB */
+ }},
+ /* mode A short */
+ {{
+ 0, 1, 2, 3, 4, 5, 5, 5, /* 7dB */
+ 6, 6, 6, 5, 4, 4, 4, 4, /* 15dB */
+ 4, 4, 5, 5, 5, 6, 6, 6, /* 23dB */
+ 7, 7, 7, 8, 8, 8, 9, 10, /* 31dB */
+ 11,12,13,14,15,16,17, 18, /* 39dB */
+ }},
+ /* sub-mode Z long */
+ {{
+ 0, 1, 2, 3, 4, 5, 6, 7, /* 7dB */
+ 8, 9,10,11,12,13,14, 15, /* 15dB */
+ 16,17,18,19,20,21,22, 23, /* 23dB */
+ 24,25,26,27,28,29,30, 31, /* 31dB */
+ 32,33,34,35,36,37,38, 39, /* 39dB */
+ }},
+ /* mode_Z nominal long */
+ {{
+ 0, 1, 2, 3, 4, 5, 6, 7, /* 7dB */
+ 8, 9,10,11,12,12,13, 13, /* 15dB */
+ 13,14,14,14,15,15,15, 15, /* 23dB */
+ 16,16,17,17,17,18,18, 19, /* 31dB */
+ 19,19,20,21,22,23,24, 25, /* 39dB */
+ }},
+ /* mode A long */
+ {{
+ 0, 1, 2, 3, 4, 5, 6, 7, /* 7dB */
+ 8, 8, 7, 6, 5, 4, 4, 4, /* 15dB */
+ 4, 4, 5, 5, 5, 6, 6, 6, /* 23dB */
+ 7, 7, 7, 8, 8, 8, 9, 10, /* 31dB */
+ 11,12,13,14,15,16,17, 18, /* 39dB */
+ }}
+};
+
+/* tonal masking curve level adjustments *************************/
+
+static const vp_adjblock _vp_tonemask_adj_longblock[12]={
+
+ /* 63 125 250 500 1 2 4 8 16 */
+
+ {{ -3, -8,-13,-15,-10,-10,-10,-10,-10,-10,-10, 0, 0, 0, 0, 0, 0}}, /* -1 */
+
+/* {{-15,-15,-15,-15,-10, -8, -4, -2, 0, 0, 0, 10, 0, 0, 0, 0, 0}}, 0 */
+ {{ -4,-10,-14,-16,-15,-14,-13,-12,-12,-12,-11, -1, -1, -1, -1, -1, 0}}, /* 0 */
+
+/* {{-15,-15,-15,-15,-15,-12,-10, -8, 0, 0, 0, 5, 0, 0, 0, 0, 0}}, 1 */
+ {{ -6,-12,-14,-16,-15,-15,-14,-13,-13,-12,-12, -2, -2, -1, -1, -1, 0}}, /* 1 */
+
+/* {{-15,-15,-15,-15,-15,-12,-10, -8, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, 2 */
+ {{-12,-13,-14,-16,-16,-16,-15,-14,-13,-12,-12, -6, -3, -1, -1, -1, 0}}, /* 2 */
+
+/* {{-15,-15,-15,-15,-15,-12,-10, -8, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, 3 */
+ {{-15,-15,-15,-16,-16,-16,-16,-14,-13,-13,-13,-10, -4, -2, -1, -1, 0}}, /* 3 */
+
+/* {{-15,-15,-15,-15,-15,-12,-10, -8, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, *//* 4 */
+ {{-16,-16,-16,-16,-16,-16,-16,-15,-14,-14,-13,-11, -7 -3, -1, -1 , 0}}, /* 4 */
+
+/* {{-15,-15,-15,-15,-15,-12,-10, -8, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, 5 */
+ {{-16,-16,-16,-16,-16,-16,-16,-15,-14,-14,-13,-11, -7 -3, -1, -1 , 0}}, /* 5 */
+
+/* {{-15,-15,-15,-15,-15,-12,-10, -8, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, 6 */
+ {{-16,-16,-16,-16,-16,-16,-16,-15,-14,-14,-14,-12, -8, -4, -2, -2, 0}}, /* 6 */
+
+/* {{-15,-15,-15,-15,-15,-12,-10, -8, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, 7 */
+ {{-16,-16,-16,-16,-16,-16,-16,-15,-14,-14,-14,-12, -9, -4, -2, -2, 0}}, /* 7 */
+
+/* {{-15,-15,-15,-15,-15,-12,-10, -8, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, 8 */
+ {{-16,-16,-16,-16,-16,-16,-16,-15,-14,-14,-14,-12, -9, -4, -2, -2, 0}}, /* 8 */
+
+/* {{-15,-15,-15,-15,-15,-12,-10, -8, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, 9 */
+ {{-16,-16,-16,-16,-16,-16,-16,-15,-14,-14,-14,-12, -9, -4, -2, -2, 0}}, /* 9 */
+
+/* {{-15,-15,-15,-15,-15,-12,-10, -8, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, 10 */
+ {{-16,-16,-16,-16,-16,-16,-16,-15,-14,-14,-14,-12, -9, -4, -2, -2, 0}}, /* 10 */
+};
+
+static const vp_adjblock _vp_tonemask_adj_otherblock[12]={
+ /* 63 125 250 500 1 2 4 8 16 */
+
+ {{ -3, -8,-13,-15,-10,-10, -9, -9, -9, -9, -9, 1, 1, 1, 1, 1, 1}}, /* -1 */
+
+/* {{-20,-20,-20,-20,-14,-12,-10, -8, -4, 0, 0, 10, 0, 0, 0, 0, 0}}, 0 */
+ {{ -4,-10,-14,-16,-14,-13,-12,-12,-11,-11,-10, 0, 0, 0, 0, 0, 0}}, /* 0 */
+
+/* {{-20,-20,-20,-20,-20,-18,-16,-14,-10, 0, 0, 5, 0, 0, 0, 0, 0}}, 1 */
+ {{ -6,-12,-14,-16,-15,-15,-14,-13,-13,-12,-12, -2, -2, -1, 0, 0, 0}}, /* 1 */
+
+/* {{-20,-20,-20,-20,-20,-18,-16,-14,-10, 0, 0, 0, 0, 0, 0, 0, 0}}, 2 */
+ {{-12,-13,-14,-16,-16,-16,-15,-14,-13,-12,-12, -5, -2, -1, 0, 0, 0}}, /* 2 */
+
+/* {{-20,-20,-20,-20,-20,-18,-16,-14,-10, 0, 0, 0, 0, 0, 0, 0, 0}}, 3 */
+ {{-15,-15,-15,-16,-16,-16,-16,-14,-13,-13,-13,-10, -4, -2, 0, 0, 0}}, /* 3 */
+
+/* {{-20,-20,-20,-20,-20,-18,-16,-14,-10, 0, 0, 0, 0, 0, 0, 0, 0}}, 4 */
+ {{-16,-16,-16,-16,-16,-16,-16,-15,-14,-14,-13,-11, -7 -3, -1, -1 , 0}}, /* 4 */
+
+/* {{-20,-20,-20,-20,-20,-18,-16,-14,-10, 0, 0, 0, 0, 0, 0, 0, 0}}, 5 */
+ {{-16,-16,-16,-16,-16,-16,-16,-15,-14,-14,-13,-11, -7 -3, -1, -1 , 0}}, /* 5 */
+
+/* {{-20,-20,-20,-20,-20,-18,-16,-14,-10, 0, 0, 0, 0, 0, 0, 0, 0}}, 6 */
+ {{-16,-16,-16,-16,-16,-16,-16,-15,-14,-14,-14,-12, -8, -4, -2, -2, 0}}, /* 6 */
+
+/* {{-20,-20,-20,-20,-20,-18,-16,-14,-10, 0, 0, 0, 0, 0, 0, 0, 0}}, 7 */
+ {{-16,-16,-16,-16,-16,-16,-16,-15,-14,-14,-14,-12, -9, -4, -2, -2, 0}}, /* 7 */
+
+/* {{-20,-20,-20,-20,-20,-18,-16,-14,-10, 0, 0, 0, 0, 0, 0, 0, 0}}, 8 */
+ {{-16,-16,-16,-16,-16,-16,-16,-15,-14,-14,-14,-12, -9, -4, -2, -2, 0}}, /* 8 */
+
+/* {{-20,-20,-20,-20,-20,-18,-16,-14,-10, 0, 0, 0, 0, 0, 0, 0, 0}}, 9 */
+ {{-16,-16,-16,-16,-16,-16,-16,-15,-14,-14,-14,-12, -9, -4, -2, -2, 0}}, /* 9 */
+
+/* {{-20,-20,-20,-20,-20,-18,-16,-14,-10, 0, 0, 0, 0, 0, 0, 0, 0}}, 10 */
+ {{-16,-16,-16,-16,-16,-16,-16,-15,-14,-14,-14,-12, -9, -4, -2, -2, 0}}, /* 10 */
+};
+
+/* noise bias (transition block) */
+static const noise3 _psy_noisebias_trans[12]={
+ /* 63 125 250 500 1k 2k 4k 8k 16k*/
+ /* -1 */
+ {{{-10,-10,-10,-10,-10, -4, 0, 0, 4, 8, 8, 8, 8, 10, 12, 14, 20},
+ {-30,-30,-30,-30,-26,-20,-16, -8, -6, -6, -2, 2, 2, 3, 6, 6, 15},
+ {-30,-30,-30,-30,-30,-24,-20,-14,-10, -6, -8, -8, -6, -6, -6, -4, -2}}},
+ /* 0
+ {{{-15,-15,-15,-15,-15,-12,-10, -8, 0, 2, 4, 4, 5, 5, 5, 8, 10},
+ {-30,-30,-30,-30,-26,-22,-20,-14, -8, -4, 0, 0, 0, 0, 2, 4, 10},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10, -6, -6, -6, -6, -4, -4, -4, -2}}},*/
+ {{{-15,-15,-15,-15,-15,-12, -6, -4, 0, 2, 4, 4, 5, 5, 5, 8, 10},
+ {-30,-30,-30,-30,-26,-22,-20,-14, -8, -4, 0, 0, 0, 0, 2, 3, 6},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10, -6, -6, -6, -6, -4, -4, -4, -2}}},
+ /* 1
+ {{{-15,-15,-15,-15,-15,-12,-10, -8, 0, 2, 4, 4, 5, 5, 5, 8, 10},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10, -4, -2, -2, -2, -2, 0, 2, 8},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10, -8, -8, -8, -8, -6, -6, -6, -4}}},*/
+ {{{-15,-15,-15,-15,-15,-12,-10, -8, 0, 2, 4, 4, 5, 5, 5, 8, 10},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10, -4, -2, -2, -2, -2, 0, 1, 4},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10, -8, -8, -8, -8, -6, -6, -6, -4}}},
+ /* 2
+ {{{-15,-15,-15,-15,-15,-12,-10, -8, 0, 2, 2, 2, 4, 4, 5, 6, 10},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10, -4, -2, -2, -2, -2, 0, 2, 6},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10,-10,-10,-10,-10, -8, -8, -8, -4}}}, */
+ {{{-15,-15,-15,-15,-15,-12,-10, -8, 0, 2, 2, 2, 4, 4, 5, 6, 10},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10, -4, -3, -3, -3, -2, -1, 0, 3},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10,-10,-10,-10,-10, -8, -8, -7, -4}}},
+ /* 3
+ {{{-15,-15,-15,-15,-15,-12,-10, -8, 0, 2, 2, 2, 4, 4, 4, 5, 8},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10, -4, -3, -3, -3, -3, -1, 1, 6},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10,-10,-10,-10,-10, -8, -8, -8, -4}}},*/
+ {{{-15,-15,-15,-15,-15,-12,-10, -8, 0, 2, 2, 2, 4, 4, 4, 5, 8},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10, -4, -3, -3, -3, -3, -2, 0, 2},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10,-10,-10,-10,-10, -8, -8, -8, -4}}},
+ /* 4
+ {{{-20,-20,-20,-20,-20,-18,-14, -8, -1, 1, 1, 1, 2, 3, 3, 4, 7},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10, -4, -3, -3, -3, -3, -1, 1, 5},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10,-10,-10,-10,-10, -8, -8, -8, -4}}},*/
+ {{{-20,-20,-20,-20,-20,-18,-14, -8, -1, 1, 1, 1, 2, 3, 3, 4, 7},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10, -4, -3, -3, -3, -3, -2, -1, 1},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10,-10,-10,-10,-10, -8, -8, -8, -4}}},
+ /* 5
+ {{{-24,-24,-24,-24,-20,-18,-14, -8, -1, 1, 1, 1, 2, 3, 3, 4, 7},
+ {-32,-32,-32,-32,-28,-24,-22,-16,-12, -6, -4, -4, -4, -4, -2, -1, 2},
+ {-34,-34,-34,-34,-30,-24,-24,-18,-14,-12,-12,-12,-12,-10,-10, -9, -5}}}, */
+ {{{-24,-24,-24,-24,-20,-18,-14, -8, -1, 1, 1, 1, 2, 3, 3, 4, 7},
+ {-32,-32,-32,-32,-28,-24,-22,-16,-12, -6, -4, -4, -4, -4, -3, -1, 0},
+ {-34,-34,-34,-34,-30,-24,-24,-18,-14,-12,-12,-12,-12,-10,-10, -9, -5}}},
+ /* 6
+ {{{-24,-24,-24,-24,-20,-18,-14, -8, -1, 1, 1, 1, 2, 3, 3, 4, 7},
+ {-32,-32,-32,-32,-28,-24,-24,-18,-14, -8, -6, -6, -6, -6, -4, -2, 1},
+ {-34,-34,-34,-34,-30,-26,-24,-18,-17,-15,-15,-15,-15,-13,-13,-12, -8}}},*/
+ {{{-24,-24,-24,-24,-20,-18,-14, -8, -1, 1, 1, 1, 2, 3, 3, 4, 7},
+ {-32,-32,-32,-32,-28,-24,-24,-18,-14, -8, -6, -6, -6, -6, -5, -2, 0},
+ {-34,-34,-34,-34,-30,-26,-26,-24,-22,-19,-19,-19,-19,-18,-17,-16,-12}}},
+ /* 7
+ {{{-24,-24,-24,-24,-20,-18,-14, -8, -1, 1, 1, 1, 2, 3, 3, 4, 7},
+ {-32,-32,-32,-32,-28,-24,-24,-18,-14,-12,-10, -8, -8, -8, -6, -4, 0},
+ {-34,-34,-34,-34,-30,-26,-26,-24,-22,-19,-19,-19,-19,-18,-17,-16,-12}}},*/
+ {{{-24,-24,-24,-24,-20,-18,-14, -8, -1, 1, 1, 1, 2, 3, 3, 4, 7},
+ {-32,-32,-32,-32,-28,-24,-24,-24,-18,-14,-12,-10,-10,-10, -8, -6, -2},
+ {-34,-34,-34,-34,-30,-26,-26,-26,-24,-24,-24,-24,-24,-24,-24,-20,-16}}},
+ /* 8
+ {{{-24,-24,-24,-24,-22,-20,-15,-10, -8, -2, 0, 0, 0, 1, 2, 3, 7},
+ {-36,-36,-36,-36,-30,-30,-30,-24,-18,-14,-12,-10,-10,-10, -8, -6, -2},
+ {-36,-36,-36,-36,-34,-30,-28,-26,-24,-24,-24,-24,-24,-24,-24,-20,-16}}},*/
+ {{{-24,-24,-24,-24,-22,-20,-15,-10, -8, -2, 0, 0, 0, 1, 2, 3, 7},
+ {-36,-36,-36,-36,-30,-30,-30,-24,-20,-16,-16,-16,-16,-14,-12,-10, -7},
+ {-36,-36,-36,-36,-34,-30,-28,-26,-24,-30,-30,-30,-30,-30,-30,-24,-20}}},
+ /* 9
+ {{{-28,-28,-28,-28,-28,-28,-28,-20,-14, -8, -4, -4, -4, -4, -4, -2, 2},
+ {-36,-36,-36,-36,-34,-32,-32,-28,-20,-16,-16,-16,-16,-14,-12,-10, -7},
+ {-40,-40,-40,-40,-40,-40,-40,-32,-30,-30,-30,-30,-30,-30,-30,-24,-20}}},*/
+ {{{-28,-28,-28,-28,-28,-28,-28,-20,-14, -8, -4, -4, -4, -4, -4, -2, 2},
+ {-38,-38,-38,-38,-36,-34,-34,-30,-24,-20,-20,-20,-20,-18,-16,-12,-10},
+ {-40,-40,-40,-40,-40,-40,-40,-38,-35,-35,-35,-35,-35,-35,-35,-35,-30}}},
+ /* 10 */
+ {{{-30,-30,-30,-30,-30,-30,-30,-28,-20,-14,-14,-14,-14,-14,-14,-12,-10},
+ {-40,-40,-40,-40,-40,-40,-40,-40,-35,-30,-30,-30,-30,-30,-30,-30,-20},
+ {-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40}}},
+};
+
+/* noise bias (long block) */
+static const noise3 _psy_noisebias_long[12]={
+ /*63 125 250 500 1k 2k 4k 8k 16k*/
+ /* -1 */
+ {{{-10,-10,-10,-10,-10, -4, 0, 0, 0, 6, 6, 6, 6, 10, 10, 12, 20},
+ {-20,-20,-20,-20,-20,-20,-10, -2, 0, 0, 0, 0, 0, 2, 4, 6, 15},
+ {-20,-20,-20,-20,-20,-20,-20,-10, -6, -6, -6, -6, -6, -4, -4, -4, -2}}},
+
+ /* 0 */
+ /* {{{-10,-10,-10,-10,-10,-10, -8, 2, 2, 2, 4, 4, 5, 5, 5, 8, 10},
+ {-20,-20,-20,-20,-20,-20,-20,-14, -6, 0, 0, 0, 0, 0, 2, 4, 10},
+ {-20,-20,-20,-20,-20,-20,-20,-14, -8, -6, -6, -6, -6, -4, -4, -4, -2}}},*/
+ {{{-10,-10,-10,-10,-10,-10, -8, 2, 2, 2, 4, 4, 5, 5, 5, 8, 10},
+ {-20,-20,-20,-20,-20,-20,-20,-14, -6, 0, 0, 0, 0, 0, 2, 3, 6},
+ {-20,-20,-20,-20,-20,-20,-20,-14, -8, -6, -6, -6, -6, -4, -4, -4, -2}}},
+ /* 1 */
+ /* {{{-10,-10,-10,-10,-10,-10, -8, -4, 0, 2, 4, 4, 5, 5, 5, 8, 10},
+ {-20,-20,-20,-20,-20,-20,-20,-14,-10, -4, -2, -2, -2, -2, 0, 2, 8},
+ {-20,-20,-20,-20,-20,-20,-20,-14,-10, -8, -8, -8, -8, -6, -6, -6, -4}}},*/
+ {{{-10,-10,-10,-10,-10,-10, -8, -4, 0, 2, 4, 4, 5, 5, 5, 8, 10},
+ {-20,-20,-20,-20,-20,-20,-20,-14,-10, -4, -2, -2, -2, -2, 0, 1, 4},
+ {-20,-20,-20,-20,-20,-20,-20,-14,-10, -8, -8, -8, -8, -6, -6, -6, -4}}},
+ /* 2 */
+ /* {{{-10,-10,-10,-10,-10,-10,-10, -8, 0, 2, 2, 2, 4, 4, 5, 6, 10},
+ {-20,-20,-20,-20,-20,-20,-20,-14,-10, -4, -2, -2, -2, -2, 0, 2, 6},
+ {-20,-20,-20,-20,-20,-20,-20,-14,-10,-10,-10,-10,-10, -8, -8, -8, -4}}},*/
+ {{{-10,-10,-10,-10,-10,-10,-10, -8, 0, 2, 2, 2, 4, 4, 5, 6, 10},
+ {-20,-20,-20,-20,-20,-20,-20,-14,-10, -4, -3, -3, -3, -2, -1, 0, 3},
+ {-20,-20,-20,-20,-20,-20,-20,-14,-10,-10,-10,-10,-10, -8, -8, -8, -4}}},
+ /* 3 */
+ /* {{{-10,-10,-10,-10,-10,-10,-10, -8, 0, 2, 2, 2, 4, 4, 4, 5, 8},
+ {-20,-20,-20,-20,-20,-20,-20,-14,-10, -4, -3, -3, -3, -3, -1, 1, 6},
+ {-20,-20,-20,-20,-20,-20,-20,-14,-10,-10,-10,-10,-10, -8, -8, -8, -4}}},*/
+ {{{-10,-10,-10,-10,-10,-10,-10, -8, 0, 2, 2, 2, 4, 4, 4, 5, 8},
+ {-20,-20,-20,-20,-20,-20,-20,-14,-10, -4, -3, -3, -3, -3, -2, 0, 2},
+ {-20,-20,-20,-20,-20,-20,-20,-14,-10,-10,-10,-10,-10, -8, -8, -8, -5}}},
+ /* 4 */
+ /* {{{-15,-15,-15,-15,-15,-15,-15,-10, -4, 1, 1, 1, 2, 3, 3, 4, 7},
+ {-20,-20,-20,-20,-20,-20,-20,-14,-10, -4, -3, -3, -3, -3, -1, 1, 5},
+ {-20,-20,-20,-20,-20,-20,-20,-14,-10,-10,-10,-10,-10, -8, -8, -8, -4}}},*/
+ {{{-15,-15,-15,-15,-15,-15,-15,-10, -4, 1, 1, 1, 2, 3, 3, 4, 7},
+ {-20,-20,-20,-20,-20,-20,-20,-14,-10, -4, -3, -3, -3, -3, -2, -1, 1},
+ {-20,-20,-20,-20,-20,-20,-20,-14,-10,-10,-10,-10,-10, -8, -8, -8, -7}}},
+ /* 5 */
+ /* {{{-15,-15,-15,-15,-15,-15,-15,-10, -4, 1, 1, 1, 2, 3, 3, 4, 7},
+ {-22,-22,-22,-22,-22,-22,-22,-16,-12, -6, -4, -4, -4, -4, -2, -1, 2},
+ {-24,-24,-24,-24,-24,-24,-24,-18,-14,-12,-12,-12,-12,-10,-10, -9, -5}}},*/
+ {{{-15,-15,-15,-15,-15,-15,-15,-10, -4, 1, 1, 1, 2, 3, 3, 4, 7},
+ {-22,-22,-22,-22,-22,-22,-22,-16,-12, -6, -4, -4, -4, -4, -3, -1, 0},
+ {-24,-24,-24,-24,-24,-24,-24,-18,-14,-12,-12,-12,-12,-10,-10, -9, -8}}},
+ /* 6 */
+ /* {{{-15,-15,-15,-15,-15,-15,-15,-10, -4, 1, 1, 1, 2, 3, 3, 4, 7},
+ {-24,-24,-24,-24,-24,-24,-24,-18,-14, -8, -6, -6, -6, -6, -4, -2, 1},
+ {-26,-26,-26,-26,-26,-26,-26,-18,-16,-15,-15,-15,-15,-13,-13,-12, -8}}},*/
+ {{{-15,-15,-15,-15,-15,-15,-15,-10, -4, 1, 1, 1, 2, 3, 3, 4, 7},
+ {-24,-24,-24,-24,-24,-24,-24,-18,-14, -8, -6, -6, -6, -6, -5, -2, 0},
+ {-26,-26,-26,-26,-26,-26,-26,-18,-16,-15,-15,-15,-15,-13,-13,-12,-10}}},
+ /* 7 */
+ {{{-15,-15,-15,-15,-15,-15,-15,-10, -4, 1, 1, 1, 2, 3, 3, 4, 7},
+ {-24,-24,-24,-24,-24,-24,-24,-18,-14,-10, -8, -8, -8, -8, -6, -4, 0},
+ {-26,-26,-26,-26,-26,-26,-26,-22,-20,-19,-19,-19,-19,-18,-17,-16,-12}}},
+ /* 8 */
+ {{{-15,-15,-15,-15,-15,-15,-15,-10, -4, 0, 0, 0, 0, 1, 2, 3, 7},
+ {-26,-26,-26,-26,-26,-26,-26,-20,-16,-12,-10,-10,-10,-10, -8, -6, -2},
+ {-28,-28,-28,-28,-28,-28,-28,-26,-24,-24,-24,-24,-24,-24,-24,-20,-16}}},
+ /* 9 */
+ {{{-22,-22,-22,-22,-22,-22,-22,-18,-14, -8, -4, -4, -4, -4, -4, -2, 2},
+ {-26,-26,-26,-26,-26,-26,-26,-22,-18,-16,-16,-16,-16,-14,-12,-10, -7},
+ {-30,-30,-30,-30,-30,-30,-30,-30,-30,-30,-30,-30,-30,-30,-30,-24,-20}}},
+ /* 10 */
+ {{{-24,-24,-24,-24,-24,-24,-24,-24,-24,-18,-14,-14,-14,-14,-14,-12,-10},
+ {-30,-30,-30,-30,-30,-30,-30,-30,-30,-30,-30,-30,-30,-30,-30,-30,-20},
+ {-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40}}},
+};
+
+/* noise bias (impulse block) */
+static const noise3 _psy_noisebias_impulse[12]={
+ /* 63 125 250 500 1k 2k 4k 8k 16k*/
+ /* -1 */
+ {{{-10,-10,-10,-10,-10, -4, 0, 0, 4, 8, 8, 8, 8, 10, 12, 14, 20},
+ {-30,-30,-30,-30,-26,-20,-16, -8, -6, -6, -2, 2, 2, 3, 6, 6, 15},
+ {-30,-30,-30,-30,-30,-24,-20,-14,-10, -6, -8, -8, -6, -6, -6, -4, -2}}},
+
+ /* 0 */
+ /* {{{-10,-10,-10,-10,-10, -4, 0, 0, 4, 4, 8, 8, 8, 10, 12, 14, 20},
+ {-30,-30,-30,-30,-26,-22,-20,-14, -6, -2, 0, 0, 0, 0, 2, 4, 10},
+ {-30,-30,-30,-30,-30,-24,-20,-14,-10, -6, -8, -8, -6, -6, -6, -4, -2}}},*/
+ {{{-10,-10,-10,-10,-10, -4, 0, 0, 4, 4, 8, 8, 8, 10, 12, 14, 20},
+ {-30,-30,-30,-30,-26,-22,-20,-14, -6, -2, 0, 0, 0, 0, 2, 3, 6},
+ {-30,-30,-30,-30,-30,-24,-20,-14,-10, -6, -8, -8, -6, -6, -6, -4, -2}}},
+ /* 1 */
+ {{{-12,-12,-12,-12,-12, -8, -6, -4, 0, 4, 4, 4, 4, 10, 12, 14, 20},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10, -6, -4, -4, -2, -2, -2, -2, 2},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10, -8,-10,-10, -8, -8, -8, -6, -4}}},
+ /* 2 */
+ {{{-14,-14,-14,-14,-14,-10, -8, -6, -2, 2, 2, 2, 2, 8, 10, 10, 16},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10, -6, -6, -6, -4, -4, -4, -2, 0},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10,-10,-10,-10,-10,-10,-10, -8, -4}}},
+ /* 3 */
+ {{{-14,-14,-14,-14,-14,-10, -8, -6, -2, 2, 2, 2, 2, 6, 8, 8, 14},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10, -6, -6, -6, -4, -4, -4, -2, 0},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10,-10,-10,-10,-10,-10,-10, -8, -4}}},
+ /* 4 */
+ {{{-16,-16,-16,-16,-16,-12,-10, -6, -2, 0, 0, 0, 0, 4, 6, 6, 12},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10, -6, -6, -6, -4, -4, -4, -2, 0},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10,-10,-10,-10,-10,-10,-10, -8, -4}}},
+ /* 5 */
+ {{{-20,-20,-20,-20,-20,-18,-14,-10, -4, 0, 0, 0, 0, 4, 4, 6, 11},
+ {-32,-32,-32,-32,-28,-24,-22,-16,-10, -6, -8, -8, -6, -6, -6, -4, -2},
+ {-34,-34,-34,-34,-30,-26,-24,-18,-14,-12,-12,-12,-12,-12,-10, -9, -5}}},
+ /* 6
+ {{{-20,-20,-20,-20,-20,-18,-14,-10, -4, 0, 0, 0, 0, 4, 4, 6, 11},
+ {-34,-34,-34,-34,-30,-30,-24,-20,-12,-12,-14,-14,-10, -9, -8, -6, -4},
+ {-34,-34,-34,-34,-34,-30,-26,-20,-16,-15,-15,-15,-15,-15,-13,-12, -8}}},*/
+ {{{-20,-20,-20,-20,-20,-18,-14,-10, -4, 0, 0, 0, 0, 4, 4, 6, 11},
+ {-34,-34,-34,-34,-30,-30,-30,-24,-16,-16,-16,-16,-16,-16,-14,-14,-12},
+ {-36,-36,-36,-36,-36,-34,-28,-24,-20,-20,-20,-20,-20,-20,-20,-18,-16}}},
+ /* 7 */
+ /* {{{-22,-22,-22,-22,-22,-20,-14,-10, -6, 0, 0, 0, 0, 4, 4, 6, 11},
+ {-34,-34,-34,-34,-30,-30,-24,-20,-14,-14,-16,-16,-14,-12,-10,-10,-10},
+ {-34,-34,-34,-34,-32,-32,-30,-24,-20,-19,-19,-19,-19,-19,-17,-16,-12}}},*/
+ {{{-22,-22,-22,-22,-22,-20,-14,-10, -6, 0, 0, 0, 0, 4, 4, 6, 11},
+ {-34,-34,-34,-34,-30,-30,-30,-30,-26,-26,-26,-26,-26,-26,-26,-24,-22},
+ {-40,-40,-40,-40,-40,-40,-40,-32,-30,-30,-30,-30,-30,-30,-30,-30,-24}}},
+ /* 8 */
+ /* {{{-24,-24,-24,-24,-24,-22,-14,-10, -6, -1, -1, -1, -1, 3, 3, 5, 10},
+ {-34,-34,-34,-34,-30,-30,-30,-24,-20,-20,-20,-20,-20,-18,-16,-16,-14},
+ {-36,-36,-36,-36,-36,-34,-28,-24,-24,-24,-24,-24,-24,-24,-24,-20,-16}}},*/
+ {{{-24,-24,-24,-24,-24,-22,-14,-10, -6, -1, -1, -1, -1, 3, 3, 5, 10},
+ {-34,-34,-34,-34,-34,-32,-32,-30,-26,-26,-26,-26,-26,-26,-26,-26,-24},
+ {-40,-40,-40,-40,-40,-40,-40,-32,-30,-30,-30,-30,-30,-30,-30,-30,-24}}},
+ /* 9 */
+ /* {{{-28,-28,-28,-28,-28,-28,-28,-20,-14, -8, -4, -4, -4, -4, -4, -2, 2},
+ {-36,-36,-36,-36,-34,-32,-32,-30,-26,-26,-26,-26,-26,-22,-20,-20,-18},
+ {-40,-40,-40,-40,-40,-40,-40,-32,-30,-30,-30,-30,-30,-30,-30,-24,-20}}},*/
+ {{{-28,-28,-28,-28,-28,-28,-28,-20,-14, -8, -4, -4, -4, -4, -4, -2, 2},
+ {-36,-36,-36,-36,-34,-32,-32,-30,-26,-26,-26,-26,-26,-26,-26,-26,-26},
+ {-40,-40,-40,-40,-40,-40,-40,-32,-30,-30,-30,-30,-30,-30,-30,-24,-20}}},
+ /* 10 */
+ {{{-30,-30,-30,-30,-30,-26,-24,-24,-24,-20,-16,-16,-16,-16,-16,-14,-12},
+ {-40,-40,-40,-40,-40,-40,-40,-40,-35,-30,-30,-30,-30,-30,-30,-30,-26},
+ {-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40}}},
+};
+
+/* noise bias (padding block) */
+static const noise3 _psy_noisebias_padding[12]={
+ /* 63 125 250 500 1k 2k 4k 8k 16k*/
+
+ /* -1 */
+ {{{-10,-10,-10,-10,-10, -4, 0, 0, 4, 8, 8, 8, 8, 10, 12, 14, 20},
+ {-30,-30,-30,-30,-26,-20,-16, -8, -6, -6, -2, 2, 2, 3, 6, 6, 15},
+ {-30,-30,-30,-30,-30,-24,-20,-14,-10, -6, -8, -8, -6, -6, -6, -4, -2}}},
+
+ /* 0 */
+ {{{-10,-10,-10,-10,-10, -4, 0, 0, 4, 8, 8, 8, 8, 10, 12, 14, 20},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10, -4, -2, 2, 3, 6, 6, 8, 10},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10, -4, -4, -4, -4, -4, -2, 0, 2}}},
+ /* 1 */
+ {{{-12,-12,-12,-12,-12, -8, -6, -4, 0, 4, 4, 4, 4, 10, 12, 14, 20},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10, -4, 0, 0, 0, 2, 2, 4, 8},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10, -6, -6, -6, -6, -6, -4, -2, 0}}},
+ /* 2 */
+ /* {{{-14,-14,-14,-14,-14,-10, -8, -6, -2, 2, 2, 2, 2, 8, 10, 10, 16},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10, -4, 0, 0, 0, 2, 2, 4, 8},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10, -8, -8, -8, -8, -8, -6, -4, -2}}},*/
+ {{{-14,-14,-14,-14,-14,-10, -8, -6, -2, 2, 2, 2, 2, 8, 10, 10, 16},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10, -6, -1, -1, -1, 0, 0, 2, 6},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10, -8, -8, -8, -8, -8, -6, -4, -2}}},
+ /* 3 */
+ {{{-14,-14,-14,-14,-14,-10, -8, -6, -2, 2, 2, 2, 2, 6, 8, 8, 14},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10, -6, -1, -1, -1, 0, 0, 2, 6},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10, -8, -8, -8, -8, -8, -6, -4, -2}}},
+ /* 4 */
+ {{{-16,-16,-16,-16,-16,-12,-10, -6, -2, 0, 0, 0, 0, 4, 6, 6, 12},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10, -6, -1, -1, -1, -1, 0, 2, 6},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-10, -8, -8, -8, -8, -8, -6, -4, -2}}},
+ /* 5 */
+ {{{-20,-20,-20,-20,-20,-18,-14,-10, -4, 0, 0, 0, 0, 4, 6, 6, 12},
+ {-32,-32,-32,-32,-28,-24,-22,-16,-12, -6, -3, -3, -3, -3, -2, 0, 4},
+ {-34,-34,-34,-34,-30,-26,-24,-18,-14,-10,-10,-10,-10,-10, -8, -5, -3}}},
+ /* 6 */
+ {{{-20,-20,-20,-20,-20,-18,-14,-10, -4, 0, 0, 0, 0, 4, 6, 6, 12},
+ {-34,-34,-34,-34,-30,-30,-24,-20,-14, -8, -4, -4, -4, -4, -3, -1, 4},
+ {-34,-34,-34,-34,-34,-30,-26,-20,-16,-13,-13,-13,-13,-13,-11, -8, -6}}},
+ /* 7 */
+ {{{-20,-20,-20,-20,-20,-18,-14,-10, -4, 0, 0, 0, 0, 4, 6, 6, 12},
+ {-34,-34,-34,-34,-30,-30,-30,-24,-16,-10, -8, -6, -6, -6, -5, -3, 1},
+ {-34,-34,-34,-34,-32,-32,-28,-22,-18,-16,-16,-16,-16,-16,-14,-12,-10}}},
+ /* 8 */
+ {{{-22,-22,-22,-22,-22,-20,-14,-10, -4, 0, 0, 0, 0, 3, 5, 5, 11},
+ {-34,-34,-34,-34,-30,-30,-30,-24,-16,-12,-10, -8, -8, -8, -7, -5, -2},
+ {-36,-36,-36,-36,-36,-34,-28,-22,-20,-20,-20,-20,-20,-20,-20,-16,-14}}},
+ /* 9 */
+ {{{-28,-28,-28,-28,-28,-28,-28,-20,-14, -8, -2, -2, -2, -2, 0, 2, 6},
+ {-36,-36,-36,-36,-34,-32,-32,-24,-16,-12,-12,-12,-12,-12,-10, -8, -5},
+ {-40,-40,-40,-40,-40,-40,-40,-32,-26,-24,-24,-24,-24,-24,-24,-20,-18}}},
+ /* 10 */
+ {{{-30,-30,-30,-30,-30,-26,-24,-24,-24,-20,-12,-12,-12,-12,-12,-10, -8},
+ {-40,-40,-40,-40,-40,-40,-40,-40,-35,-30,-25,-25,-25,-25,-25,-25,-15},
+ {-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40}}},
+};
+
+
+static const noiseguard _psy_noiseguards_44[4]={
+ {3,3,15},
+ {3,3,15},
+ {10,10,100},
+ {10,10,100},
+};
+
+static const int _psy_tone_suppress[12]={
+ -20,-20,-20,-20,-20,-24,-30,-40,-40,-45,-45,-45,
+};
+static const int _psy_tone_0dB[12]={
+ 90,90,95,95,95,95,105,105,105,105,105,105,
+};
+static const int _psy_noise_suppress[12]={
+ -20,-20,-24,-24,-24,-24,-30,-40,-40,-45,-45,-45,
+};
+
+static const vorbis_info_psy _psy_info_template={
+ /* blockflag */
+ -1,
+ /* ath_adjatt, ath_maxatt */
+ -140.,-140.,
+ /* tonemask att boost/decay,suppr,curves */
+ {0.f,0.f,0.f}, 0.,0., -40.f, {0.},
+
+ /*noisemaskp,supp, low/high window, low/hi guard, minimum */
+ 1, -0.f, .5f, .5f, 0,0,0,
+ /* noiseoffset*3, noisecompand, max_curve_dB */
+ {{-1},{-1},{-1}},{-1},105.f,
+ /* noise normalization - noise_p, start, partition, thresh. */
+ 0,-1,-1,0.,
+};
+
+/* ath ****************/
+
+static const int _psy_ath_floater[12]={
+ -100,-100,-100,-100,-100,-100,-105,-105,-105,-105,-110,-120,
+};
+static const int _psy_ath_abs[12]={
+ -130,-130,-130,-130,-140,-140,-140,-140,-140,-140,-140,-150,
+};
+
+/* stereo setup. These don't map directly to quality level, there's
+ an additional indirection as several of the below may be used in a
+ single bitmanaged stream
+
+****************/
+
+/* various stereo possibilities */
+
+/* stereo mode by base quality level */
+static const adj_stereo _psy_stereo_modes_44[12]={
+ /* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 -1 */
+ {{ 4, 4, 4, 4, 4, 4, 4, 3, 2, 2, 1, 0, 0, 0, 0},
+ { 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 5, 4, 3},
+ { 1, 2, 3, 4, 4, 4, 4, 4, 4, 5, 6, 7, 8, 8, 8},
+ { 12,12.5, 13,13.5, 14,14.5, 15, 99, 99, 99, 99, 99, 99, 99, 99}},
+
+/* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 0 */
+ {{ 4, 4, 4, 4, 4, 4, 4, 3, 2, 1, 0, 0, 0, 0, 0},
+ { 8, 8, 8, 8, 6, 6, 5, 5, 5, 5, 5, 5, 5, 4, 3},
+ { 1, 2, 3, 4, 4, 5, 6, 6, 6, 6, 6, 8, 8, 8, 8},
+ { 12,12.5, 13,13.5, 14,14.5, 15, 99, 99, 99, 99, 99, 99, 99, 99}},
+
+
+ /* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 1 */
+ {{ 3, 3, 3, 3, 3, 3, 3, 3, 2, 1, 0, 0, 0, 0, 0},
+ { 8, 8, 8, 8, 6, 6, 5, 5, 5, 5, 5, 5, 5, 4, 3},
+ { 1, 2, 3, 4, 4, 5, 6, 6, 6, 6, 6, 8, 8, 8, 8},
+ { 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99}},
+
+
+ /* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 2 */
+ {{ 3, 3, 3, 3, 3, 3, 3, 2, 1, 1, 0, 0, 0, 0, 0},
+ { 8, 8, 6, 6, 5, 5, 4, 4, 4, 4, 4, 4, 3, 2, 1},
+ { 3, 4, 4, 5, 5, 6, 6, 6, 6, 6, 6, 8, 8, 8, 8},
+ { 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99}},
+ /* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 3 */
+ {{ 2, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0},
+ { 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 2, 1},
+ { 4, 4, 5, 6, 6, 6, 6, 6, 8, 8, 10, 10, 10, 10, 10},
+ { 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99}},
+ /* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 4 */
+ {{ 2, 2, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 2, 1, 0},
+ { 6, 6, 6, 8, 8, 8, 8, 8, 8, 8, 10, 10, 10, 10, 10},
+ { 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99}},
+ /* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 5 */
+ {{ 2, 2, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0},
+ { 6, 7, 8, 8, 8, 10, 10, 12, 12, 12, 12, 12, 12, 12, 12},
+ { 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99}},
+ /* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 6 */
+ {{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 3, 3, 3, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 8, 8, 8, 10, 10, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12},
+ { 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99}},
+ /* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 7 */
+ {{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 3, 3, 3, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 8, 8, 10, 10, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12},
+ { 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99}},
+ /* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 8 */
+ {{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 8, 10, 10, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12},
+ { 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99}},
+ /* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 9 */
+ {{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4},
+ { 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99}},
+ /* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 10 */
+ {{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4},
+ { 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99}},
+};
+
+/* tone master attenuation by base quality mode and bitrate tweak */
+static const att3 _psy_tone_masteratt_44[12]={
+ {{ 35, 21, 9}, 0, 0}, /* -1 */
+ {{ 30, 20, 8}, -2, 1.25}, /* 0 */
+ /* {{ 25, 14, 4}, 0, 0}, *//* 1 */
+ {{ 25, 12, 2}, 0, 0}, /* 1 */
+ /* {{ 20, 10, -2}, 0, 0}, *//* 2 */
+ {{ 20, 9, -3}, 0, 0}, /* 2 */
+ {{ 20, 9, -4}, 0, 0}, /* 3 */
+ {{ 20, 9, -4}, 0, 0}, /* 4 */
+ {{ 20, 6, -6}, 0, 0}, /* 5 */
+ {{ 20, 3, -10}, 0, 0}, /* 6 */
+ {{ 18, 1, -14}, 0, 0}, /* 7 */
+ {{ 18, 0, -16}, 0, 0}, /* 8 */
+ {{ 18, -2, -16}, 0, 0}, /* 9 */
+ {{ 12, -2, -20}, 0, 0}, /* 10 */
+};
+
+/* lowpass by mode **************/
+static const double _psy_lowpass_44[12]={
+ /* 15.1,15.8,16.5,17.9,20.5,48.,999.,999.,999.,999.,999. */
+ 13.9,15.1,15.8,16.5,17.2,18.9,20.1,48.,999.,999.,999.,999.
+};
+
+/* noise normalization **********/
+
+static const int _noise_start_short_44[11]={
+ /* 16,16,16,16,32,32,9999,9999,9999,9999 */
+ 32,16,16,16,32,9999,9999,9999,9999,9999,9999
+};
+static const int _noise_start_long_44[11]={
+ /* 128,128,128,256,512,512,9999,9999,9999,9999 */
+ 256,128,128,256,512,9999,9999,9999,9999,9999,9999
+};
+
+static const int _noise_part_short_44[11]={
+ 8,8,8,8,8,8,8,8,8,8,8
+};
+static const int _noise_part_long_44[11]={
+ 32,32,32,32,32,32,32,32,32,32,32
+};
+
+static const double _noise_thresh_44[11]={
+ /* .2,.2,.3,.4,.5,.5,9999.,9999.,9999.,9999., */
+ .2,.2,.2,.4,.6,9999.,9999.,9999.,9999.,9999.,9999.,
+};
+
+static const double _noise_thresh_5only[2]={
+ .5,.5,
+};
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: 8kHz psychoacoustic settings
+ last mod: $Id: psych_8.h 16227 2009-07-08 06:58:46Z xiphmont $
+
+ ********************************************************************/
+
+static const att3 _psy_tone_masteratt_8[3]={
+ {{ 32, 25, 12}, 0, 0}, /* 0 */
+ {{ 30, 25, 12}, 0, 0}, /* 0 */
+ {{ 20, 0, -14}, 0, 0}, /* 0 */
+};
+
+static const vp_adjblock _vp_tonemask_adj_8[3]={
+ /* adjust for mode zero */
+ /* 63 125 250 500 1 2 4 8 16 */
+ {{-15,-15,-15,-15,-10,-10, -6, 0, 0, 0, 0,10, 0, 0,99,99,99}}, /* 1 */
+ {{-15,-15,-15,-15,-10,-10, -6, 0, 0, 0, 0,10, 0, 0,99,99,99}}, /* 1 */
+ {{-15,-15,-15,-15,-10,-10, -6, 0, 0, 0, 0, 0, 0, 0,99,99,99}}, /* 1 */
+};
+
+
+static const noise3 _psy_noisebias_8[3]={
+ /* 63 125 250 500 1k 2k 4k 8k 16k*/
+ {{{-10,-10,-10,-10, -5, -5, -5, 0, 4, 8, 8, 8, 10, 10, 99, 99, 99},
+ {-10,-10,-10,-10, -5, -5, -5, 0, 0, 4, 4, 4, 4, 4, 99, 99, 99},
+ {-30,-30,-30,-30,-30,-24,-20,-14,-10, -6, -8, -8, -6, -6, 99, 99, 99}}},
+
+ {{{-10,-10,-10,-10, -5, -5, -5, 0, 4, 8, 8, 8, 10, 10, 99, 99, 99},
+ {-10,-10,-10,-10,-10,-10, -5, -5, -5, 0, 0, 0, 0, 0, 99, 99, 99},
+ {-30,-30,-30,-30,-30,-24,-20,-14,-10, -6, -8, -8, -6, -6, 99, 99, 99}}},
+
+ {{{-15,-15,-15,-15,-15,-12,-10, -8, 0, 2, 4, 4, 5, 5, 99, 99, 99},
+ {-30,-30,-30,-30,-26,-22,-20,-14,-12,-12,-10,-10,-10,-10, 99, 99, 99},
+ {-30,-30,-30,-30,-26,-26,-26,-26,-26,-26,-26,-26,-26,-24, 99, 99, 99}}},
+};
+
+/* stereo mode by base quality level */
+static const adj_stereo _psy_stereo_modes_8[3]={
+ /* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 */
+ {{ 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3},
+ { 6, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4},
+ { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
+ { 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99}},
+ {{ 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3},
+ { 6, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4},
+ { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
+ { 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99}},
+ {{ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3},
+ { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4},
+ { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
+ { 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99}},
+};
+
+static const noiseguard _psy_noiseguards_8[2]={
+ {10,10,-1},
+ {10,10,-1},
+};
+
+static const compandblock _psy_compand_8[2]={
+ {{
+ 0, 1, 2, 3, 4, 5, 6, 7, /* 7dB */
+ 8, 8, 9, 9,10,10,11, 11, /* 15dB */
+ 12,12,13,13,14,14,15, 15, /* 23dB */
+ 16,16,17,17,17,18,18, 19, /* 31dB */
+ 19,19,20,21,22,23,24, 25, /* 39dB */
+ }},
+ {{
+ 0, 1, 2, 3, 4, 5, 6, 6, /* 7dB */
+ 7, 7, 6, 6, 5, 5, 4, 4, /* 15dB */
+ 3, 3, 3, 4, 5, 6, 7, 8, /* 23dB */
+ 9,10,11,12,13,14,15, 16, /* 31dB */
+ 17,18,19,20,21,22,23, 24, /* 39dB */
+ }},
+};
+
+static const double _psy_lowpass_8[3]={3.,4.,4.};
+static const int _noise_start_8[2]={
+ 64,64,
+};
+static const int _noise_part_8[2]={
+ 8,8,
+};
+
+static const int _psy_ath_floater_8[3]={
+ -100,-100,-105,
+};
+
+static const int _psy_ath_abs_8[3]={
+ -130,-130,-140,
+};
--- /dev/null
+/********************************************************************
+ * *
+ * This FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: toplevel residue templates 16/22kHz
+ last mod: $Id: residue_16.h 16962 2010-03-11 07:30:34Z xiphmont $
+
+ ********************************************************************/
+
+/***** residue backends *********************************************/
+
+static const static_bookblock _resbook_16s_0={
+ {
+ {0},
+ {0,0,&_16c0_s_p1_0},
+ {0},
+ {0,0,&_16c0_s_p3_0},
+ {0,0,&_16c0_s_p4_0},
+ {0,0,&_16c0_s_p5_0},
+ {0,0,&_16c0_s_p6_0},
+ {&_16c0_s_p7_0,&_16c0_s_p7_1},
+ {&_16c0_s_p8_0,&_16c0_s_p8_1},
+ {&_16c0_s_p9_0,&_16c0_s_p9_1,&_16c0_s_p9_2}
+ }
+};
+static const static_bookblock _resbook_16s_1={
+ {
+ {0},
+ {0,0,&_16c1_s_p1_0},
+ {0},
+ {0,0,&_16c1_s_p3_0},
+ {0,0,&_16c1_s_p4_0},
+ {0,0,&_16c1_s_p5_0},
+ {0,0,&_16c1_s_p6_0},
+ {&_16c1_s_p7_0,&_16c1_s_p7_1},
+ {&_16c1_s_p8_0,&_16c1_s_p8_1},
+ {&_16c1_s_p9_0,&_16c1_s_p9_1,&_16c1_s_p9_2}
+ }
+};
+static const static_bookblock _resbook_16s_2={
+ {
+ {0},
+ {0,0,&_16c2_s_p1_0},
+ {0,0,&_16c2_s_p2_0},
+ {0,0,&_16c2_s_p3_0},
+ {0,0,&_16c2_s_p4_0},
+ {&_16c2_s_p5_0,&_16c2_s_p5_1},
+ {&_16c2_s_p6_0,&_16c2_s_p6_1},
+ {&_16c2_s_p7_0,&_16c2_s_p7_1},
+ {&_16c2_s_p8_0,&_16c2_s_p8_1},
+ {&_16c2_s_p9_0,&_16c2_s_p9_1,&_16c2_s_p9_2}
+ }
+};
+
+static const vorbis_residue_template _res_16s_0[]={
+ {2,0,32, &_residue_44_mid,
+ &_huff_book__16c0_s_single,&_huff_book__16c0_s_single,
+ &_resbook_16s_0,&_resbook_16s_0},
+};
+static const vorbis_residue_template _res_16s_1[]={
+ {2,0,32, &_residue_44_mid,
+ &_huff_book__16c1_s_short,&_huff_book__16c1_s_short,
+ &_resbook_16s_1,&_resbook_16s_1},
+
+ {2,0,32, &_residue_44_mid,
+ &_huff_book__16c1_s_long,&_huff_book__16c1_s_long,
+ &_resbook_16s_1,&_resbook_16s_1}
+};
+static const vorbis_residue_template _res_16s_2[]={
+ {2,0,32, &_residue_44_high,
+ &_huff_book__16c2_s_short,&_huff_book__16c2_s_short,
+ &_resbook_16s_2,&_resbook_16s_2},
+
+ {2,0,32, &_residue_44_high,
+ &_huff_book__16c2_s_long,&_huff_book__16c2_s_long,
+ &_resbook_16s_2,&_resbook_16s_2}
+};
+
+static const vorbis_mapping_template _mapres_template_16_stereo[3]={
+ { _map_nominal, _res_16s_0 }, /* 0 */
+ { _map_nominal, _res_16s_1 }, /* 1 */
+ { _map_nominal, _res_16s_2 }, /* 2 */
+};
+
+static const static_bookblock _resbook_16u_0={
+ {
+ {0},
+ {0,0,&_16u0__p1_0},
+ {0,0,&_16u0__p2_0},
+ {0,0,&_16u0__p3_0},
+ {0,0,&_16u0__p4_0},
+ {0,0,&_16u0__p5_0},
+ {&_16u0__p6_0,&_16u0__p6_1},
+ {&_16u0__p7_0,&_16u0__p7_1,&_16u0__p7_2}
+ }
+};
+static const static_bookblock _resbook_16u_1={
+ {
+ {0},
+ {0,0,&_16u1__p1_0},
+ {0,0,&_16u1__p2_0},
+ {0,0,&_16u1__p3_0},
+ {0,0,&_16u1__p4_0},
+ {0,0,&_16u1__p5_0},
+ {0,0,&_16u1__p6_0},
+ {&_16u1__p7_0,&_16u1__p7_1},
+ {&_16u1__p8_0,&_16u1__p8_1},
+ {&_16u1__p9_0,&_16u1__p9_1,&_16u1__p9_2}
+ }
+};
+static const static_bookblock _resbook_16u_2={
+ {
+ {0},
+ {0,0,&_16u2_p1_0},
+ {0,0,&_16u2_p2_0},
+ {0,0,&_16u2_p3_0},
+ {0,0,&_16u2_p4_0},
+ {&_16u2_p5_0,&_16u2_p5_1},
+ {&_16u2_p6_0,&_16u2_p6_1},
+ {&_16u2_p7_0,&_16u2_p7_1},
+ {&_16u2_p8_0,&_16u2_p8_1},
+ {&_16u2_p9_0,&_16u2_p9_1,&_16u2_p9_2}
+ }
+};
+
+static const vorbis_residue_template _res_16u_0[]={
+ {1,0,32, &_residue_44_low_un,
+ &_huff_book__16u0__single,&_huff_book__16u0__single,
+ &_resbook_16u_0,&_resbook_16u_0},
+};
+static const vorbis_residue_template _res_16u_1[]={
+ {1,0,32, &_residue_44_mid_un,
+ &_huff_book__16u1__short,&_huff_book__16u1__short,
+ &_resbook_16u_1,&_resbook_16u_1},
+
+ {1,0,32, &_residue_44_mid_un,
+ &_huff_book__16u1__long,&_huff_book__16u1__long,
+ &_resbook_16u_1,&_resbook_16u_1}
+};
+static const vorbis_residue_template _res_16u_2[]={
+ {1,0,32, &_residue_44_hi_un,
+ &_huff_book__16u2__short,&_huff_book__16u2__short,
+ &_resbook_16u_2,&_resbook_16u_2},
+
+ {1,0,32, &_residue_44_hi_un,
+ &_huff_book__16u2__long,&_huff_book__16u2__long,
+ &_resbook_16u_2,&_resbook_16u_2}
+};
+
+
+static const vorbis_mapping_template _mapres_template_16_uncoupled[3]={
+ { _map_nominal_u, _res_16u_0 }, /* 0 */
+ { _map_nominal_u, _res_16u_1 }, /* 1 */
+ { _map_nominal_u, _res_16u_2 }, /* 2 */
+};
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: toplevel residue templates for 32/44.1/48kHz
+ last mod: $Id: residue_44.h 16962 2010-03-11 07:30:34Z xiphmont $
+
+ ********************************************************************/
+
+#include "vorbis/codec.h"
+#include "backends.h"
+#include "books/coupled/res_books_stereo.h"
+
+/***** residue backends *********************************************/
+
+static const vorbis_info_residue0 _residue_44_low={
+ 0,-1, -1, 9,-1,-1,
+ /* 0 1 2 3 4 5 6 7 */
+ {0},
+ {-1},
+ { 0, 1, 2, 2, 4, 8, 16, 32},
+ { 0, 0, 0,999, 4, 8, 16, 32},
+};
+
+static const vorbis_info_residue0 _residue_44_mid={
+ 0,-1, -1, 10,-1,-1,
+ /* 0 1 2 3 4 5 6 7 8 */
+ {0},
+ {-1},
+ { 0, 1, 1, 2, 2, 4, 8, 16, 32},
+ { 0, 0,999, 0,999, 4, 8, 16, 32},
+};
+
+static const vorbis_info_residue0 _residue_44_high={
+ 0,-1, -1, 10,-1,-1,
+ /* 0 1 2 3 4 5 6 7 8 */
+ {0},
+ {-1},
+ { 0, 1, 2, 4, 8, 16, 32, 71,157},
+ { 0, 1, 2, 3, 4, 8, 16, 71,157},
+};
+
+static const static_bookblock _resbook_44s_n1={
+ {
+ {0},{0,0,&_44cn1_s_p1_0},{0,0,&_44cn1_s_p2_0},
+ {0,0,&_44cn1_s_p3_0},{0,0,&_44cn1_s_p4_0},{0,0,&_44cn1_s_p5_0},
+ {&_44cn1_s_p6_0,&_44cn1_s_p6_1},{&_44cn1_s_p7_0,&_44cn1_s_p7_1},
+ {&_44cn1_s_p8_0,&_44cn1_s_p8_1,&_44cn1_s_p8_2}
+ }
+};
+static const static_bookblock _resbook_44sm_n1={
+ {
+ {0},{0,0,&_44cn1_sm_p1_0},{0,0,&_44cn1_sm_p2_0},
+ {0,0,&_44cn1_sm_p3_0},{0,0,&_44cn1_sm_p4_0},{0,0,&_44cn1_sm_p5_0},
+ {&_44cn1_sm_p6_0,&_44cn1_sm_p6_1},{&_44cn1_sm_p7_0,&_44cn1_sm_p7_1},
+ {&_44cn1_sm_p8_0,&_44cn1_sm_p8_1,&_44cn1_sm_p8_2}
+ }
+};
+
+static const static_bookblock _resbook_44s_0={
+ {
+ {0},{0,0,&_44c0_s_p1_0},{0,0,&_44c0_s_p2_0},
+ {0,0,&_44c0_s_p3_0},{0,0,&_44c0_s_p4_0},{0,0,&_44c0_s_p5_0},
+ {&_44c0_s_p6_0,&_44c0_s_p6_1},{&_44c0_s_p7_0,&_44c0_s_p7_1},
+ {&_44c0_s_p8_0,&_44c0_s_p8_1,&_44c0_s_p8_2}
+ }
+};
+static const static_bookblock _resbook_44sm_0={
+ {
+ {0},{0,0,&_44c0_sm_p1_0},{0,0,&_44c0_sm_p2_0},
+ {0,0,&_44c0_sm_p3_0},{0,0,&_44c0_sm_p4_0},{0,0,&_44c0_sm_p5_0},
+ {&_44c0_sm_p6_0,&_44c0_sm_p6_1},{&_44c0_sm_p7_0,&_44c0_sm_p7_1},
+ {&_44c0_sm_p8_0,&_44c0_sm_p8_1,&_44c0_sm_p8_2}
+ }
+};
+
+static const static_bookblock _resbook_44s_1={
+ {
+ {0},{0,0,&_44c1_s_p1_0},{0,0,&_44c1_s_p2_0},
+ {0,0,&_44c1_s_p3_0},{0,0,&_44c1_s_p4_0},{0,0,&_44c1_s_p5_0},
+ {&_44c1_s_p6_0,&_44c1_s_p6_1},{&_44c1_s_p7_0,&_44c1_s_p7_1},
+ {&_44c1_s_p8_0,&_44c1_s_p8_1,&_44c1_s_p8_2}
+ }
+};
+static const static_bookblock _resbook_44sm_1={
+ {
+ {0},{0,0,&_44c1_sm_p1_0},{0,0,&_44c1_sm_p2_0},
+ {0,0,&_44c1_sm_p3_0},{0,0,&_44c1_sm_p4_0},{0,0,&_44c1_sm_p5_0},
+ {&_44c1_sm_p6_0,&_44c1_sm_p6_1},{&_44c1_sm_p7_0,&_44c1_sm_p7_1},
+ {&_44c1_sm_p8_0,&_44c1_sm_p8_1,&_44c1_sm_p8_2}
+ }
+};
+
+static const static_bookblock _resbook_44s_2={
+ {
+ {0},{0,0,&_44c2_s_p1_0},{0,0,&_44c2_s_p2_0},{0,0,&_44c2_s_p3_0},
+ {0,0,&_44c2_s_p4_0},{0,0,&_44c2_s_p5_0},{0,0,&_44c2_s_p6_0},
+ {&_44c2_s_p7_0,&_44c2_s_p7_1},{&_44c2_s_p8_0,&_44c2_s_p8_1},
+ {&_44c2_s_p9_0,&_44c2_s_p9_1,&_44c2_s_p9_2}
+ }
+};
+static const static_bookblock _resbook_44s_3={
+ {
+ {0},{0,0,&_44c3_s_p1_0},{0,0,&_44c3_s_p2_0},{0,0,&_44c3_s_p3_0},
+ {0,0,&_44c3_s_p4_0},{0,0,&_44c3_s_p5_0},{0,0,&_44c3_s_p6_0},
+ {&_44c3_s_p7_0,&_44c3_s_p7_1},{&_44c3_s_p8_0,&_44c3_s_p8_1},
+ {&_44c3_s_p9_0,&_44c3_s_p9_1,&_44c3_s_p9_2}
+ }
+};
+static const static_bookblock _resbook_44s_4={
+ {
+ {0},{0,0,&_44c4_s_p1_0},{0,0,&_44c4_s_p2_0},{0,0,&_44c4_s_p3_0},
+ {0,0,&_44c4_s_p4_0},{0,0,&_44c4_s_p5_0},{0,0,&_44c4_s_p6_0},
+ {&_44c4_s_p7_0,&_44c4_s_p7_1},{&_44c4_s_p8_0,&_44c4_s_p8_1},
+ {&_44c4_s_p9_0,&_44c4_s_p9_1,&_44c4_s_p9_2}
+ }
+};
+static const static_bookblock _resbook_44s_5={
+ {
+ {0},{0,0,&_44c5_s_p1_0},{0,0,&_44c5_s_p2_0},{0,0,&_44c5_s_p3_0},
+ {0,0,&_44c5_s_p4_0},{0,0,&_44c5_s_p5_0},{0,0,&_44c5_s_p6_0},
+ {&_44c5_s_p7_0,&_44c5_s_p7_1},{&_44c5_s_p8_0,&_44c5_s_p8_1},
+ {&_44c5_s_p9_0,&_44c5_s_p9_1,&_44c5_s_p9_2}
+ }
+};
+static const static_bookblock _resbook_44s_6={
+ {
+ {0},{0,0,&_44c6_s_p1_0},{0,0,&_44c6_s_p2_0},{0,0,&_44c6_s_p3_0},
+ {0,0,&_44c6_s_p4_0},
+ {&_44c6_s_p5_0,&_44c6_s_p5_1},
+ {&_44c6_s_p6_0,&_44c6_s_p6_1},
+ {&_44c6_s_p7_0,&_44c6_s_p7_1},
+ {&_44c6_s_p8_0,&_44c6_s_p8_1},
+ {&_44c6_s_p9_0,&_44c6_s_p9_1,&_44c6_s_p9_2}
+ }
+};
+static const static_bookblock _resbook_44s_7={
+ {
+ {0},{0,0,&_44c7_s_p1_0},{0,0,&_44c7_s_p2_0},{0,0,&_44c7_s_p3_0},
+ {0,0,&_44c7_s_p4_0},
+ {&_44c7_s_p5_0,&_44c7_s_p5_1},
+ {&_44c7_s_p6_0,&_44c7_s_p6_1},
+ {&_44c7_s_p7_0,&_44c7_s_p7_1},
+ {&_44c7_s_p8_0,&_44c7_s_p8_1},
+ {&_44c7_s_p9_0,&_44c7_s_p9_1,&_44c7_s_p9_2}
+ }
+};
+static const static_bookblock _resbook_44s_8={
+ {
+ {0},{0,0,&_44c8_s_p1_0},{0,0,&_44c8_s_p2_0},{0,0,&_44c8_s_p3_0},
+ {0,0,&_44c8_s_p4_0},
+ {&_44c8_s_p5_0,&_44c8_s_p5_1},
+ {&_44c8_s_p6_0,&_44c8_s_p6_1},
+ {&_44c8_s_p7_0,&_44c8_s_p7_1},
+ {&_44c8_s_p8_0,&_44c8_s_p8_1},
+ {&_44c8_s_p9_0,&_44c8_s_p9_1,&_44c8_s_p9_2}
+ }
+};
+static const static_bookblock _resbook_44s_9={
+ {
+ {0},{0,0,&_44c9_s_p1_0},{0,0,&_44c9_s_p2_0},{0,0,&_44c9_s_p3_0},
+ {0,0,&_44c9_s_p4_0},
+ {&_44c9_s_p5_0,&_44c9_s_p5_1},
+ {&_44c9_s_p6_0,&_44c9_s_p6_1},
+ {&_44c9_s_p7_0,&_44c9_s_p7_1},
+ {&_44c9_s_p8_0,&_44c9_s_p8_1},
+ {&_44c9_s_p9_0,&_44c9_s_p9_1,&_44c9_s_p9_2}
+ }
+};
+
+static const vorbis_residue_template _res_44s_n1[]={
+ {2,0,32, &_residue_44_low,
+ &_huff_book__44cn1_s_short,&_huff_book__44cn1_sm_short,
+ &_resbook_44s_n1,&_resbook_44sm_n1},
+
+ {2,0,32, &_residue_44_low,
+ &_huff_book__44cn1_s_long,&_huff_book__44cn1_sm_long,
+ &_resbook_44s_n1,&_resbook_44sm_n1}
+};
+static const vorbis_residue_template _res_44s_0[]={
+ {2,0,16, &_residue_44_low,
+ &_huff_book__44c0_s_short,&_huff_book__44c0_sm_short,
+ &_resbook_44s_0,&_resbook_44sm_0},
+
+ {2,0,32, &_residue_44_low,
+ &_huff_book__44c0_s_long,&_huff_book__44c0_sm_long,
+ &_resbook_44s_0,&_resbook_44sm_0}
+};
+static const vorbis_residue_template _res_44s_1[]={
+ {2,0,16, &_residue_44_low,
+ &_huff_book__44c1_s_short,&_huff_book__44c1_sm_short,
+ &_resbook_44s_1,&_resbook_44sm_1},
+
+ {2,0,32, &_residue_44_low,
+ &_huff_book__44c1_s_long,&_huff_book__44c1_sm_long,
+ &_resbook_44s_1,&_resbook_44sm_1}
+};
+
+static const vorbis_residue_template _res_44s_2[]={
+ {2,0,16, &_residue_44_mid,
+ &_huff_book__44c2_s_short,&_huff_book__44c2_s_short,
+ &_resbook_44s_2,&_resbook_44s_2},
+
+ {2,0,32, &_residue_44_mid,
+ &_huff_book__44c2_s_long,&_huff_book__44c2_s_long,
+ &_resbook_44s_2,&_resbook_44s_2}
+};
+static const vorbis_residue_template _res_44s_3[]={
+ {2,0,16, &_residue_44_mid,
+ &_huff_book__44c3_s_short,&_huff_book__44c3_s_short,
+ &_resbook_44s_3,&_resbook_44s_3},
+
+ {2,0,32, &_residue_44_mid,
+ &_huff_book__44c3_s_long,&_huff_book__44c3_s_long,
+ &_resbook_44s_3,&_resbook_44s_3}
+};
+static const vorbis_residue_template _res_44s_4[]={
+ {2,0,16, &_residue_44_mid,
+ &_huff_book__44c4_s_short,&_huff_book__44c4_s_short,
+ &_resbook_44s_4,&_resbook_44s_4},
+
+ {2,0,32, &_residue_44_mid,
+ &_huff_book__44c4_s_long,&_huff_book__44c4_s_long,
+ &_resbook_44s_4,&_resbook_44s_4}
+};
+static const vorbis_residue_template _res_44s_5[]={
+ {2,0,16, &_residue_44_mid,
+ &_huff_book__44c5_s_short,&_huff_book__44c5_s_short,
+ &_resbook_44s_5,&_resbook_44s_5},
+
+ {2,0,32, &_residue_44_mid,
+ &_huff_book__44c5_s_long,&_huff_book__44c5_s_long,
+ &_resbook_44s_5,&_resbook_44s_5}
+};
+static const vorbis_residue_template _res_44s_6[]={
+ {2,0,16, &_residue_44_high,
+ &_huff_book__44c6_s_short,&_huff_book__44c6_s_short,
+ &_resbook_44s_6,&_resbook_44s_6},
+
+ {2,0,32, &_residue_44_high,
+ &_huff_book__44c6_s_long,&_huff_book__44c6_s_long,
+ &_resbook_44s_6,&_resbook_44s_6}
+};
+static const vorbis_residue_template _res_44s_7[]={
+ {2,0,16, &_residue_44_high,
+ &_huff_book__44c7_s_short,&_huff_book__44c7_s_short,
+ &_resbook_44s_7,&_resbook_44s_7},
+
+ {2,0,32, &_residue_44_high,
+ &_huff_book__44c7_s_long,&_huff_book__44c7_s_long,
+ &_resbook_44s_7,&_resbook_44s_7}
+};
+static const vorbis_residue_template _res_44s_8[]={
+ {2,0,16, &_residue_44_high,
+ &_huff_book__44c8_s_short,&_huff_book__44c8_s_short,
+ &_resbook_44s_8,&_resbook_44s_8},
+
+ {2,0,32, &_residue_44_high,
+ &_huff_book__44c8_s_long,&_huff_book__44c8_s_long,
+ &_resbook_44s_8,&_resbook_44s_8}
+};
+static const vorbis_residue_template _res_44s_9[]={
+ {2,0,16, &_residue_44_high,
+ &_huff_book__44c9_s_short,&_huff_book__44c9_s_short,
+ &_resbook_44s_9,&_resbook_44s_9},
+
+ {2,0,32, &_residue_44_high,
+ &_huff_book__44c9_s_long,&_huff_book__44c9_s_long,
+ &_resbook_44s_9,&_resbook_44s_9}
+};
+
+static const vorbis_mapping_template _mapres_template_44_stereo[]={
+ { _map_nominal, _res_44s_n1 }, /* -1 */
+ { _map_nominal, _res_44s_0 }, /* 0 */
+ { _map_nominal, _res_44s_1 }, /* 1 */
+ { _map_nominal, _res_44s_2 }, /* 2 */
+ { _map_nominal, _res_44s_3 }, /* 3 */
+ { _map_nominal, _res_44s_4 }, /* 4 */
+ { _map_nominal, _res_44s_5 }, /* 5 */
+ { _map_nominal, _res_44s_6 }, /* 6 */
+ { _map_nominal, _res_44s_7 }, /* 7 */
+ { _map_nominal, _res_44s_8 }, /* 8 */
+ { _map_nominal, _res_44s_9 }, /* 9 */
+};
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2010 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: toplevel residue templates for 32/44.1/48kHz uncoupled
+ last mod: $Id$
+
+ ********************************************************************/
+
+#include "vorbis/codec.h"
+#include "backends.h"
+
+#include "books/coupled/res_books_51.h"
+
+/***** residue backends *********************************************/
+
+static const vorbis_info_residue0 _residue_44p_lo={
+ 0,-1, -1, 7,-1,-1,
+ /* 0 1 2 3 4 5 6 7 8 */
+ {0},
+ {-1},
+ { 0, 1, 2, 7, 17, 31},
+ { 0, 0, 99, 7, 17, 31},
+};
+
+static const vorbis_info_residue0 _residue_44p={
+ 0,-1, -1, 8,-1,-1,
+ /* 0 1 2 3 4 5 6 7 8 */
+ {0},
+ {-1},
+ { 0, 1, 1, 2, 7, 17, 31},
+ { 0, 0, 99, 99, 7, 17, 31},
+};
+
+static const vorbis_info_residue0 _residue_44p_hi={
+ 0,-1, -1, 8,-1,-1,
+ /* 0 1 2 3 4 5 6 7 8 */
+ {0},
+ {-1},
+ { 0, 1, 2, 4, 7, 17, 31},
+ { 0, 1, 2, 4, 7, 17, 31},
+};
+
+static const vorbis_info_residue0 _residue_44p_lfe={
+ 0,-1, -1, 2,-1,-1,
+ /* 0 1 2 3 4 5 6 7 8 */
+ {0},
+ {-1},
+ { 32},
+ { -1}
+};
+
+static const static_bookblock _resbook_44p_n1={
+ {
+ {0},
+ {0,&_44pn1_p1_0},
+
+ {&_44pn1_p2_0,&_44pn1_p2_1,0},
+ {&_44pn1_p3_0,&_44pn1_p3_1,0},
+ {&_44pn1_p4_0,&_44pn1_p4_1,0},
+
+ {&_44pn1_p5_0,&_44pn1_p5_1,&_44pn1_p4_1},
+ {&_44pn1_p6_0,&_44pn1_p6_1,&_44pn1_p6_2},
+ }
+};
+
+static const static_bookblock _resbook_44p_0={
+ {
+ {0},
+ {0,&_44p0_p1_0},
+
+ {&_44p0_p2_0,&_44p0_p2_1,0},
+ {&_44p0_p3_0,&_44p0_p3_1,0},
+ {&_44p0_p4_0,&_44p0_p4_1,0},
+
+ {&_44p0_p5_0,&_44p0_p5_1,&_44p0_p4_1},
+ {&_44p0_p6_0,&_44p0_p6_1,&_44p0_p6_2},
+ }
+};
+
+static const static_bookblock _resbook_44p_1={
+ {
+ {0},
+ {0,&_44p1_p1_0},
+
+ {&_44p1_p2_0,&_44p1_p2_1,0},
+ {&_44p1_p3_0,&_44p1_p3_1,0},
+ {&_44p1_p4_0,&_44p1_p4_1,0},
+
+ {&_44p1_p5_0,&_44p1_p5_1,&_44p1_p4_1},
+ {&_44p1_p6_0,&_44p1_p6_1,&_44p1_p6_2},
+ }
+};
+
+static const static_bookblock _resbook_44p_2={
+ {
+ {0},
+ {0,0,&_44p2_p1_0},
+ {0,&_44p2_p2_0,0},
+
+ {&_44p2_p3_0,&_44p2_p3_1,0},
+ {&_44p2_p4_0,&_44p2_p4_1,0},
+ {&_44p2_p5_0,&_44p2_p5_1,0},
+
+ {&_44p2_p6_0,&_44p2_p6_1,&_44p2_p5_1},
+ {&_44p2_p7_0,&_44p2_p7_1,&_44p2_p7_2,&_44p2_p7_3}
+ }
+};
+static const static_bookblock _resbook_44p_3={
+ {
+ {0},
+ {0,0,&_44p3_p1_0},
+ {0,&_44p3_p2_0,0},
+
+ {&_44p3_p3_0,&_44p3_p3_1,0},
+ {&_44p3_p4_0,&_44p3_p4_1,0},
+ {&_44p3_p5_0,&_44p3_p5_1,0},
+
+ {&_44p3_p6_0,&_44p3_p6_1,&_44p3_p5_1},
+ {&_44p3_p7_0,&_44p3_p7_1,&_44p3_p7_2,&_44p3_p7_3}
+ }
+};
+static const static_bookblock _resbook_44p_4={
+ {
+ {0},
+ {0,0,&_44p4_p1_0},
+ {0,&_44p4_p2_0,0},
+
+ {&_44p4_p3_0,&_44p4_p3_1,0},
+ {&_44p4_p4_0,&_44p4_p4_1,0},
+ {&_44p4_p5_0,&_44p4_p5_1,0},
+
+ {&_44p4_p6_0,&_44p4_p6_1,&_44p4_p5_1},
+ {&_44p4_p7_0,&_44p4_p7_1,&_44p4_p7_2,&_44p4_p7_3}
+ }
+};
+static const static_bookblock _resbook_44p_5={
+ {
+ {0},
+ {0,0,&_44p5_p1_0},
+ {0,&_44p5_p2_0,0},
+
+ {&_44p5_p3_0,&_44p5_p3_1,0},
+ {&_44p5_p4_0,&_44p5_p4_1,0},
+ {&_44p5_p5_0,&_44p5_p5_1,0},
+
+ {&_44p5_p6_0,&_44p5_p6_1,&_44p5_p5_1},
+ {&_44p5_p7_0,&_44p5_p7_1,&_44p5_p7_2,&_44p5_p7_3}
+ }
+};
+static const static_bookblock _resbook_44p_6={
+ {
+ {0},
+ {0,0,&_44p6_p1_0},
+ {0,&_44p6_p2_0,0},
+
+ {&_44p6_p3_0,&_44p6_p3_1,0},
+ {&_44p6_p4_0,&_44p6_p4_1,0},
+ {&_44p6_p5_0,&_44p6_p5_1,0},
+
+ {&_44p6_p6_0,&_44p6_p6_1,&_44p6_p5_1},
+ {&_44p6_p7_0,&_44p6_p7_1,&_44p6_p7_2,&_44p6_p7_3}
+ }
+};
+static const static_bookblock _resbook_44p_7={
+ {
+ {0},
+ {0,0,&_44p7_p1_0},
+ {0,&_44p7_p2_0,0},
+
+ {&_44p7_p3_0,&_44p7_p3_1,0},
+ {&_44p7_p4_0,&_44p7_p4_1,0},
+ {&_44p7_p5_0,&_44p7_p5_1,0},
+
+ {&_44p7_p6_0,&_44p7_p6_1,&_44p7_p5_1},
+ {&_44p7_p7_0,&_44p7_p7_1,&_44p7_p7_2,&_44p7_p7_3}
+ }
+};
+static const static_bookblock _resbook_44p_8={
+ {
+ {0},
+ {0,0,&_44p8_p1_0},
+ {0,&_44p8_p2_0,0},
+
+ {&_44p8_p3_0,&_44p8_p3_1,0},
+ {&_44p8_p4_0,&_44p8_p4_1,0},
+ {&_44p8_p5_0,&_44p8_p5_1,0},
+
+ {&_44p8_p6_0,&_44p8_p6_1,&_44p8_p5_1},
+ {&_44p8_p7_0,&_44p8_p7_1,&_44p8_p7_2,&_44p8_p7_3}
+ }
+};
+static const static_bookblock _resbook_44p_9={
+ {
+ {0},
+ {0,0,&_44p9_p1_0},
+ {0,&_44p9_p2_0,0},
+
+ {&_44p9_p3_0,&_44p9_p3_1,0},
+ {&_44p9_p4_0,&_44p9_p4_1,0},
+ {&_44p9_p5_0,&_44p9_p5_1,0},
+
+ {&_44p9_p6_0,&_44p9_p6_1,&_44p9_p5_1},
+ {&_44p9_p7_0,&_44p9_p7_1,&_44p9_p7_2,&_44p9_p7_3}
+ }
+};
+
+static const static_bookblock _resbook_44p_ln1={
+ {
+ {&_44pn1_l0_0,&_44pn1_l0_1,0},
+ {&_44pn1_l1_0,&_44pn1_p6_1,&_44pn1_p6_2},
+ }
+};
+static const static_bookblock _resbook_44p_l0={
+ {
+ {&_44p0_l0_0,&_44p0_l0_1,0},
+ {&_44p0_l1_0,&_44p0_p6_1,&_44p0_p6_2},
+ }
+};
+static const static_bookblock _resbook_44p_l1={
+ {
+ {&_44p1_l0_0,&_44p1_l0_1,0},
+ {&_44p1_l1_0,&_44p1_p6_1,&_44p1_p6_2},
+ }
+};
+static const static_bookblock _resbook_44p_l2={
+ {
+ {&_44p2_l0_0,&_44p2_l0_1,0},
+ {&_44p2_l1_0,&_44p2_p7_2,&_44p2_p7_3},
+ }
+};
+static const static_bookblock _resbook_44p_l3={
+ {
+ {&_44p3_l0_0,&_44p3_l0_1,0},
+ {&_44p3_l1_0,&_44p3_p7_2,&_44p3_p7_3},
+ }
+};
+static const static_bookblock _resbook_44p_l4={
+ {
+ {&_44p4_l0_0,&_44p4_l0_1,0},
+ {&_44p4_l1_0,&_44p4_p7_2,&_44p4_p7_3},
+ }
+};
+static const static_bookblock _resbook_44p_l5={
+ {
+ {&_44p5_l0_0,&_44p5_l0_1,0},
+ {&_44p5_l1_0,&_44p5_p7_2,&_44p5_p7_3},
+ }
+};
+static const static_bookblock _resbook_44p_l6={
+ {
+ {&_44p6_l0_0,&_44p6_l0_1,0},
+ {&_44p6_l1_0,&_44p6_p7_2,&_44p6_p7_3},
+ }
+};
+static const static_bookblock _resbook_44p_l7={
+ {
+ {&_44p7_l0_0,&_44p7_l0_1,0},
+ {&_44p7_l1_0,&_44p7_p7_2,&_44p7_p7_3},
+ }
+};
+static const static_bookblock _resbook_44p_l8={
+ {
+ {&_44p8_l0_0,&_44p8_l0_1,0},
+ {&_44p8_l1_0,&_44p8_p7_2,&_44p8_p7_3},
+ }
+};
+static const static_bookblock _resbook_44p_l9={
+ {
+ {&_44p9_l0_0,&_44p9_l0_1,0},
+ {&_44p9_l1_0,&_44p9_p7_2,&_44p9_p7_3},
+ }
+};
+
+
+static const vorbis_info_mapping0 _map_nominal_51[2]={
+ {2, {0,0,0,0,0,1}, {0,2}, {0,2}, 4,{0,3,0,0},{2,4,1,3}},
+ {2, {0,0,0,0,0,1}, {1,2}, {1,2}, 4,{0,3,0,0},{2,4,1,3}}
+};
+static const vorbis_info_mapping0 _map_nominal_51u[2]={
+ {2, {0,0,0,0,0,1}, {0,2}, {0,2}, 0,{0},{0}},
+ {2, {0,0,0,0,0,1}, {1,2}, {1,2}, 0,{0},{0}}
+};
+
+static const vorbis_residue_template _res_44p51_n1[]={
+ {2,0,30, &_residue_44p_lo,
+ &_huff_book__44pn1_short,&_huff_book__44pn1_short,
+ &_resbook_44p_n1,&_resbook_44p_n1},
+
+ {2,0,30, &_residue_44p_lo,
+ &_huff_book__44pn1_long,&_huff_book__44pn1_long,
+ &_resbook_44p_n1,&_resbook_44p_n1},
+
+ {1,2,6, &_residue_44p_lfe,
+ &_huff_book__44pn1_lfe,&_huff_book__44pn1_lfe,
+ &_resbook_44p_ln1,&_resbook_44p_ln1}
+};
+static const vorbis_residue_template _res_44p51_0[]={
+ {2,0,15, &_residue_44p_lo,
+ &_huff_book__44p0_short,&_huff_book__44p0_short,
+ &_resbook_44p_0,&_resbook_44p_0},
+
+ {2,0,30, &_residue_44p_lo,
+ &_huff_book__44p0_long,&_huff_book__44p0_long,
+ &_resbook_44p_0,&_resbook_44p_0},
+
+ {1,2,6, &_residue_44p_lfe,
+ &_huff_book__44p0_lfe,&_huff_book__44p0_lfe,
+ &_resbook_44p_l0,&_resbook_44p_l0}
+};
+static const vorbis_residue_template _res_44p51_1[]={
+ {2,0,15, &_residue_44p_lo,
+ &_huff_book__44p1_short,&_huff_book__44p1_short,
+ &_resbook_44p_1,&_resbook_44p_1},
+
+ {2,0,30, &_residue_44p_lo,
+ &_huff_book__44p1_long,&_huff_book__44p1_long,
+ &_resbook_44p_1,&_resbook_44p_1},
+
+ {1,2,6, &_residue_44p_lfe,
+ &_huff_book__44p1_lfe,&_huff_book__44p1_lfe,
+ &_resbook_44p_l1,&_resbook_44p_l1}
+};
+static const vorbis_residue_template _res_44p51_2[]={
+ {2,0,15, &_residue_44p,
+ &_huff_book__44p2_short,&_huff_book__44p2_short,
+ &_resbook_44p_2,&_resbook_44p_2},
+
+ {2,0,30, &_residue_44p,
+ &_huff_book__44p2_long,&_huff_book__44p2_long,
+ &_resbook_44p_2,&_resbook_44p_2},
+
+ {1,2,6, &_residue_44p_lfe,
+ &_huff_book__44p2_lfe,&_huff_book__44p2_lfe,
+ &_resbook_44p_l2,&_resbook_44p_l2}
+};
+static const vorbis_residue_template _res_44p51_3[]={
+ {2,0,15, &_residue_44p,
+ &_huff_book__44p3_short,&_huff_book__44p3_short,
+ &_resbook_44p_3,&_resbook_44p_3},
+
+ {2,0,30, &_residue_44p,
+ &_huff_book__44p3_long,&_huff_book__44p3_long,
+ &_resbook_44p_3,&_resbook_44p_3},
+
+ {1,2,6, &_residue_44p_lfe,
+ &_huff_book__44p3_lfe,&_huff_book__44p3_lfe,
+ &_resbook_44p_l3,&_resbook_44p_l3}
+};
+static const vorbis_residue_template _res_44p51_4[]={
+ {2,0,15, &_residue_44p,
+ &_huff_book__44p4_short,&_huff_book__44p4_short,
+ &_resbook_44p_4,&_resbook_44p_4},
+
+ {2,0,30, &_residue_44p,
+ &_huff_book__44p4_long,&_huff_book__44p4_long,
+ &_resbook_44p_4,&_resbook_44p_4},
+
+ {1,2,6, &_residue_44p_lfe,
+ &_huff_book__44p4_lfe,&_huff_book__44p4_lfe,
+ &_resbook_44p_l4,&_resbook_44p_l4}
+};
+static const vorbis_residue_template _res_44p51_5[]={
+ {2,0,15, &_residue_44p_hi,
+ &_huff_book__44p5_short,&_huff_book__44p5_short,
+ &_resbook_44p_5,&_resbook_44p_5},
+
+ {2,0,30, &_residue_44p_hi,
+ &_huff_book__44p5_long,&_huff_book__44p5_long,
+ &_resbook_44p_5,&_resbook_44p_5},
+
+ {1,2,6, &_residue_44p_lfe,
+ &_huff_book__44p5_lfe,&_huff_book__44p5_lfe,
+ &_resbook_44p_l5,&_resbook_44p_l5}
+};
+static const vorbis_residue_template _res_44p51_6[]={
+ {2,0,15, &_residue_44p_hi,
+ &_huff_book__44p6_short,&_huff_book__44p6_short,
+ &_resbook_44p_6,&_resbook_44p_6},
+
+ {2,0,30, &_residue_44p_hi,
+ &_huff_book__44p6_long,&_huff_book__44p6_long,
+ &_resbook_44p_6,&_resbook_44p_6},
+
+ {1,2,6, &_residue_44p_lfe,
+ &_huff_book__44p6_lfe,&_huff_book__44p6_lfe,
+ &_resbook_44p_l6,&_resbook_44p_l6}
+};
+
+
+static const vorbis_residue_template _res_44p51_7[]={
+ {2,0,15, &_residue_44p_hi,
+ &_huff_book__44p7_short,&_huff_book__44p7_short,
+ &_resbook_44p_7,&_resbook_44p_7},
+
+ {2,0,30, &_residue_44p_hi,
+ &_huff_book__44p7_long,&_huff_book__44p7_long,
+ &_resbook_44p_7,&_resbook_44p_7},
+
+ {1,2,6, &_residue_44p_lfe,
+ &_huff_book__44p6_lfe,&_huff_book__44p6_lfe,
+ &_resbook_44p_l6,&_resbook_44p_l6}
+};
+static const vorbis_residue_template _res_44p51_8[]={
+ {2,0,15, &_residue_44p_hi,
+ &_huff_book__44p8_short,&_huff_book__44p8_short,
+ &_resbook_44p_8,&_resbook_44p_8},
+
+ {2,0,30, &_residue_44p_hi,
+ &_huff_book__44p8_long,&_huff_book__44p8_long,
+ &_resbook_44p_8,&_resbook_44p_8},
+
+ {1,2,6, &_residue_44p_lfe,
+ &_huff_book__44p6_lfe,&_huff_book__44p6_lfe,
+ &_resbook_44p_l6,&_resbook_44p_l6}
+};
+static const vorbis_residue_template _res_44p51_9[]={
+ {2,0,15, &_residue_44p_hi,
+ &_huff_book__44p9_short,&_huff_book__44p9_short,
+ &_resbook_44p_9,&_resbook_44p_9},
+
+ {2,0,30, &_residue_44p_hi,
+ &_huff_book__44p9_long,&_huff_book__44p9_long,
+ &_resbook_44p_9,&_resbook_44p_9},
+
+ {1,2,6, &_residue_44p_lfe,
+ &_huff_book__44p6_lfe,&_huff_book__44p6_lfe,
+ &_resbook_44p_l6,&_resbook_44p_l6}
+};
+
+static const vorbis_mapping_template _mapres_template_44_51[]={
+ { _map_nominal_51, _res_44p51_n1 }, /* -1 */
+ { _map_nominal_51, _res_44p51_0 }, /* 0 */
+ { _map_nominal_51, _res_44p51_1 }, /* 1 */
+ { _map_nominal_51, _res_44p51_2 }, /* 2 */
+ { _map_nominal_51, _res_44p51_3 }, /* 3 */
+ { _map_nominal_51, _res_44p51_4 }, /* 4 */
+ { _map_nominal_51u, _res_44p51_5 }, /* 5 */
+ { _map_nominal_51u, _res_44p51_6 }, /* 6 */
+ { _map_nominal_51u, _res_44p51_7 }, /* 7 */
+ { _map_nominal_51u, _res_44p51_8 }, /* 8 */
+ { _map_nominal_51u, _res_44p51_9 }, /* 9 */
+};
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2007 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: toplevel residue templates for 32/44.1/48kHz uncoupled
+ last mod: $Id: residue_44u.h 16962 2010-03-11 07:30:34Z xiphmont $
+
+ ********************************************************************/
+
+#include "vorbis/codec.h"
+#include "backends.h"
+#include "books/uncoupled/res_books_uncoupled.h"
+
+/***** residue backends *********************************************/
+
+
+static const vorbis_info_residue0 _residue_44_low_un={
+ 0,-1, -1, 8,-1,-1,
+ {0},
+ {-1},
+ { 0, 1, 1, 2, 2, 4, 28},
+ { -1, 25, -1, 45, -1, -1, -1}
+};
+
+static const vorbis_info_residue0 _residue_44_mid_un={
+ 0,-1, -1, 10,-1,-1,
+ /* 0 1 2 3 4 5 6 7 8 9 */
+ {0},
+ {-1},
+ { 0, 1, 1, 2, 2, 4, 4, 16, 60},
+ { -1, 30, -1, 50, -1, 80, -1, -1, -1}
+};
+
+static const vorbis_info_residue0 _residue_44_hi_un={
+ 0,-1, -1, 10,-1,-1,
+ /* 0 1 2 3 4 5 6 7 8 9 */
+ {0},
+ {-1},
+ { 0, 1, 2, 4, 8, 16, 32, 71,157},
+ { -1, -1, -1, -1, -1, -1, -1, -1, -1}
+};
+
+/* mapping conventions:
+ only one submap (this would change for efficient 5.1 support for example)*/
+/* Four psychoacoustic profiles are used, one for each blocktype */
+static const vorbis_info_mapping0 _map_nominal_u[2]={
+ {1, {0,0,0,0,0,0}, {0}, {0}, 0,{0},{0}},
+ {1, {0,0,0,0,0,0}, {1}, {1}, 0,{0},{0}}
+};
+
+static const static_bookblock _resbook_44u_n1={
+ {
+ {0},
+ {0,0,&_44un1__p1_0},
+ {0,0,&_44un1__p2_0},
+ {0,0,&_44un1__p3_0},
+ {0,0,&_44un1__p4_0},
+ {0,0,&_44un1__p5_0},
+ {&_44un1__p6_0,&_44un1__p6_1},
+ {&_44un1__p7_0,&_44un1__p7_1,&_44un1__p7_2}
+ }
+};
+static const static_bookblock _resbook_44u_0={
+ {
+ {0},
+ {0,0,&_44u0__p1_0},
+ {0,0,&_44u0__p2_0},
+ {0,0,&_44u0__p3_0},
+ {0,0,&_44u0__p4_0},
+ {0,0,&_44u0__p5_0},
+ {&_44u0__p6_0,&_44u0__p6_1},
+ {&_44u0__p7_0,&_44u0__p7_1,&_44u0__p7_2}
+ }
+};
+static const static_bookblock _resbook_44u_1={
+ {
+ {0},
+ {0,0,&_44u1__p1_0},
+ {0,0,&_44u1__p2_0},
+ {0,0,&_44u1__p3_0},
+ {0,0,&_44u1__p4_0},
+ {0,0,&_44u1__p5_0},
+ {&_44u1__p6_0,&_44u1__p6_1},
+ {&_44u1__p7_0,&_44u1__p7_1,&_44u1__p7_2}
+ }
+};
+static const static_bookblock _resbook_44u_2={
+ {
+ {0},
+ {0,0,&_44u2__p1_0},
+ {0,0,&_44u2__p2_0},
+ {0,0,&_44u2__p3_0},
+ {0,0,&_44u2__p4_0},
+ {0,0,&_44u2__p5_0},
+ {&_44u2__p6_0,&_44u2__p6_1},
+ {&_44u2__p7_0,&_44u2__p7_1,&_44u2__p7_2}
+ }
+};
+static const static_bookblock _resbook_44u_3={
+ {
+ {0},
+ {0,0,&_44u3__p1_0},
+ {0,0,&_44u3__p2_0},
+ {0,0,&_44u3__p3_0},
+ {0,0,&_44u3__p4_0},
+ {0,0,&_44u3__p5_0},
+ {&_44u3__p6_0,&_44u3__p6_1},
+ {&_44u3__p7_0,&_44u3__p7_1,&_44u3__p7_2}
+ }
+};
+static const static_bookblock _resbook_44u_4={
+ {
+ {0},
+ {0,0,&_44u4__p1_0},
+ {0,0,&_44u4__p2_0},
+ {0,0,&_44u4__p3_0},
+ {0,0,&_44u4__p4_0},
+ {0,0,&_44u4__p5_0},
+ {&_44u4__p6_0,&_44u4__p6_1},
+ {&_44u4__p7_0,&_44u4__p7_1,&_44u4__p7_2}
+ }
+};
+static const static_bookblock _resbook_44u_5={
+ {
+ {0},
+ {0,0,&_44u5__p1_0},
+ {0,0,&_44u5__p2_0},
+ {0,0,&_44u5__p3_0},
+ {0,0,&_44u5__p4_0},
+ {0,0,&_44u5__p5_0},
+ {0,0,&_44u5__p6_0},
+ {&_44u5__p7_0,&_44u5__p7_1},
+ {&_44u5__p8_0,&_44u5__p8_1},
+ {&_44u5__p9_0,&_44u5__p9_1,&_44u5__p9_2}
+ }
+};
+static const static_bookblock _resbook_44u_6={
+ {
+ {0},
+ {0,0,&_44u6__p1_0},
+ {0,0,&_44u6__p2_0},
+ {0,0,&_44u6__p3_0},
+ {0,0,&_44u6__p4_0},
+ {0,0,&_44u6__p5_0},
+ {0,0,&_44u6__p6_0},
+ {&_44u6__p7_0,&_44u6__p7_1},
+ {&_44u6__p8_0,&_44u6__p8_1},
+ {&_44u6__p9_0,&_44u6__p9_1,&_44u6__p9_2}
+ }
+};
+static const static_bookblock _resbook_44u_7={
+ {
+ {0},
+ {0,0,&_44u7__p1_0},
+ {0,0,&_44u7__p2_0},
+ {0,0,&_44u7__p3_0},
+ {0,0,&_44u7__p4_0},
+ {0,0,&_44u7__p5_0},
+ {0,0,&_44u7__p6_0},
+ {&_44u7__p7_0,&_44u7__p7_1},
+ {&_44u7__p8_0,&_44u7__p8_1},
+ {&_44u7__p9_0,&_44u7__p9_1,&_44u7__p9_2}
+ }
+};
+static const static_bookblock _resbook_44u_8={
+ {
+ {0},
+ {0,0,&_44u8_p1_0},
+ {0,0,&_44u8_p2_0},
+ {0,0,&_44u8_p3_0},
+ {0,0,&_44u8_p4_0},
+ {&_44u8_p5_0,&_44u8_p5_1},
+ {&_44u8_p6_0,&_44u8_p6_1},
+ {&_44u8_p7_0,&_44u8_p7_1},
+ {&_44u8_p8_0,&_44u8_p8_1},
+ {&_44u8_p9_0,&_44u8_p9_1,&_44u8_p9_2}
+ }
+};
+static const static_bookblock _resbook_44u_9={
+ {
+ {0},
+ {0,0,&_44u9_p1_0},
+ {0,0,&_44u9_p2_0},
+ {0,0,&_44u9_p3_0},
+ {0,0,&_44u9_p4_0},
+ {&_44u9_p5_0,&_44u9_p5_1},
+ {&_44u9_p6_0,&_44u9_p6_1},
+ {&_44u9_p7_0,&_44u9_p7_1},
+ {&_44u9_p8_0,&_44u9_p8_1},
+ {&_44u9_p9_0,&_44u9_p9_1,&_44u9_p9_2}
+ }
+};
+
+static const vorbis_residue_template _res_44u_n1[]={
+ {1,0,32, &_residue_44_low_un,
+ &_huff_book__44un1__short,&_huff_book__44un1__short,
+ &_resbook_44u_n1,&_resbook_44u_n1},
+
+ {1,0,32, &_residue_44_low_un,
+ &_huff_book__44un1__long,&_huff_book__44un1__long,
+ &_resbook_44u_n1,&_resbook_44u_n1}
+};
+static const vorbis_residue_template _res_44u_0[]={
+ {1,0,16, &_residue_44_low_un,
+ &_huff_book__44u0__short,&_huff_book__44u0__short,
+ &_resbook_44u_0,&_resbook_44u_0},
+
+ {1,0,32, &_residue_44_low_un,
+ &_huff_book__44u0__long,&_huff_book__44u0__long,
+ &_resbook_44u_0,&_resbook_44u_0}
+};
+static const vorbis_residue_template _res_44u_1[]={
+ {1,0,16, &_residue_44_low_un,
+ &_huff_book__44u1__short,&_huff_book__44u1__short,
+ &_resbook_44u_1,&_resbook_44u_1},
+
+ {1,0,32, &_residue_44_low_un,
+ &_huff_book__44u1__long,&_huff_book__44u1__long,
+ &_resbook_44u_1,&_resbook_44u_1}
+};
+static const vorbis_residue_template _res_44u_2[]={
+ {1,0,16, &_residue_44_low_un,
+ &_huff_book__44u2__short,&_huff_book__44u2__short,
+ &_resbook_44u_2,&_resbook_44u_2},
+
+ {1,0,32, &_residue_44_low_un,
+ &_huff_book__44u2__long,&_huff_book__44u2__long,
+ &_resbook_44u_2,&_resbook_44u_2}
+};
+static const vorbis_residue_template _res_44u_3[]={
+ {1,0,16, &_residue_44_low_un,
+ &_huff_book__44u3__short,&_huff_book__44u3__short,
+ &_resbook_44u_3,&_resbook_44u_3},
+
+ {1,0,32, &_residue_44_low_un,
+ &_huff_book__44u3__long,&_huff_book__44u3__long,
+ &_resbook_44u_3,&_resbook_44u_3}
+};
+static const vorbis_residue_template _res_44u_4[]={
+ {1,0,16, &_residue_44_low_un,
+ &_huff_book__44u4__short,&_huff_book__44u4__short,
+ &_resbook_44u_4,&_resbook_44u_4},
+
+ {1,0,32, &_residue_44_low_un,
+ &_huff_book__44u4__long,&_huff_book__44u4__long,
+ &_resbook_44u_4,&_resbook_44u_4}
+};
+
+static const vorbis_residue_template _res_44u_5[]={
+ {1,0,16, &_residue_44_mid_un,
+ &_huff_book__44u5__short,&_huff_book__44u5__short,
+ &_resbook_44u_5,&_resbook_44u_5},
+
+ {1,0,32, &_residue_44_mid_un,
+ &_huff_book__44u5__long,&_huff_book__44u5__long,
+ &_resbook_44u_5,&_resbook_44u_5}
+};
+
+static const vorbis_residue_template _res_44u_6[]={
+ {1,0,16, &_residue_44_mid_un,
+ &_huff_book__44u6__short,&_huff_book__44u6__short,
+ &_resbook_44u_6,&_resbook_44u_6},
+
+ {1,0,32, &_residue_44_mid_un,
+ &_huff_book__44u6__long,&_huff_book__44u6__long,
+ &_resbook_44u_6,&_resbook_44u_6}
+};
+
+static const vorbis_residue_template _res_44u_7[]={
+ {1,0,16, &_residue_44_mid_un,
+ &_huff_book__44u7__short,&_huff_book__44u7__short,
+ &_resbook_44u_7,&_resbook_44u_7},
+
+ {1,0,32, &_residue_44_mid_un,
+ &_huff_book__44u7__long,&_huff_book__44u7__long,
+ &_resbook_44u_7,&_resbook_44u_7}
+};
+
+static const vorbis_residue_template _res_44u_8[]={
+ {1,0,16, &_residue_44_hi_un,
+ &_huff_book__44u8__short,&_huff_book__44u8__short,
+ &_resbook_44u_8,&_resbook_44u_8},
+
+ {1,0,32, &_residue_44_hi_un,
+ &_huff_book__44u8__long,&_huff_book__44u8__long,
+ &_resbook_44u_8,&_resbook_44u_8}
+};
+static const vorbis_residue_template _res_44u_9[]={
+ {1,0,16, &_residue_44_hi_un,
+ &_huff_book__44u9__short,&_huff_book__44u9__short,
+ &_resbook_44u_9,&_resbook_44u_9},
+
+ {1,0,32, &_residue_44_hi_un,
+ &_huff_book__44u9__long,&_huff_book__44u9__long,
+ &_resbook_44u_9,&_resbook_44u_9}
+};
+
+static const vorbis_mapping_template _mapres_template_44_uncoupled[]={
+ { _map_nominal_u, _res_44u_n1 }, /* -1 */
+ { _map_nominal_u, _res_44u_0 }, /* 0 */
+ { _map_nominal_u, _res_44u_1 }, /* 1 */
+ { _map_nominal_u, _res_44u_2 }, /* 2 */
+ { _map_nominal_u, _res_44u_3 }, /* 3 */
+ { _map_nominal_u, _res_44u_4 }, /* 4 */
+ { _map_nominal_u, _res_44u_5 }, /* 5 */
+ { _map_nominal_u, _res_44u_6 }, /* 6 */
+ { _map_nominal_u, _res_44u_7 }, /* 7 */
+ { _map_nominal_u, _res_44u_8 }, /* 8 */
+ { _map_nominal_u, _res_44u_9 }, /* 9 */
+};
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2007 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: toplevel residue templates 8/11kHz
+ last mod: $Id: residue_8.h 16962 2010-03-11 07:30:34Z xiphmont $
+
+ ********************************************************************/
+
+#include "vorbis/codec.h"
+#include "backends.h"
+
+/***** residue backends *********************************************/
+
+static const static_bookblock _resbook_8s_0={
+ {
+ {0},
+ {0,0,&_8c0_s_p1_0},
+ {0},
+ {0,0,&_8c0_s_p3_0},
+ {0,0,&_8c0_s_p4_0},
+ {0,0,&_8c0_s_p5_0},
+ {0,0,&_8c0_s_p6_0},
+ {&_8c0_s_p7_0,&_8c0_s_p7_1},
+ {&_8c0_s_p8_0,&_8c0_s_p8_1},
+ {&_8c0_s_p9_0,&_8c0_s_p9_1,&_8c0_s_p9_2}
+ }
+};
+static const static_bookblock _resbook_8s_1={
+ {
+ {0},
+ {0,0,&_8c1_s_p1_0},
+ {0},
+ {0,0,&_8c1_s_p3_0},
+ {0,0,&_8c1_s_p4_0},
+ {0,0,&_8c1_s_p5_0},
+ {0,0,&_8c1_s_p6_0},
+ {&_8c1_s_p7_0,&_8c1_s_p7_1},
+ {&_8c1_s_p8_0,&_8c1_s_p8_1},
+ {&_8c1_s_p9_0,&_8c1_s_p9_1,&_8c1_s_p9_2}
+ }
+};
+
+static const vorbis_residue_template _res_8s_0[]={
+ {2,0,32, &_residue_44_mid,
+ &_huff_book__8c0_s_single,&_huff_book__8c0_s_single,
+ &_resbook_8s_0,&_resbook_8s_0},
+};
+static const vorbis_residue_template _res_8s_1[]={
+ {2,0,32, &_residue_44_mid,
+ &_huff_book__8c1_s_single,&_huff_book__8c1_s_single,
+ &_resbook_8s_1,&_resbook_8s_1},
+};
+
+static const vorbis_mapping_template _mapres_template_8_stereo[2]={
+ { _map_nominal, _res_8s_0 }, /* 0 */
+ { _map_nominal, _res_8s_1 }, /* 1 */
+};
+
+static const static_bookblock _resbook_8u_0={
+ {
+ {0},
+ {0,0,&_8u0__p1_0},
+ {0,0,&_8u0__p2_0},
+ {0,0,&_8u0__p3_0},
+ {0,0,&_8u0__p4_0},
+ {0,0,&_8u0__p5_0},
+ {&_8u0__p6_0,&_8u0__p6_1},
+ {&_8u0__p7_0,&_8u0__p7_1,&_8u0__p7_2}
+ }
+};
+static const static_bookblock _resbook_8u_1={
+ {
+ {0},
+ {0,0,&_8u1__p1_0},
+ {0,0,&_8u1__p2_0},
+ {0,0,&_8u1__p3_0},
+ {0,0,&_8u1__p4_0},
+ {0,0,&_8u1__p5_0},
+ {0,0,&_8u1__p6_0},
+ {&_8u1__p7_0,&_8u1__p7_1},
+ {&_8u1__p8_0,&_8u1__p8_1},
+ {&_8u1__p9_0,&_8u1__p9_1,&_8u1__p9_2}
+ }
+};
+
+static const vorbis_residue_template _res_8u_0[]={
+ {1,0,32, &_residue_44_low_un,
+ &_huff_book__8u0__single,&_huff_book__8u0__single,
+ &_resbook_8u_0,&_resbook_8u_0},
+};
+static const vorbis_residue_template _res_8u_1[]={
+ {1,0,32, &_residue_44_mid_un,
+ &_huff_book__8u1__single,&_huff_book__8u1__single,
+ &_resbook_8u_1,&_resbook_8u_1},
+};
+
+static const vorbis_mapping_template _mapres_template_8_uncoupled[2]={
+ { _map_nominal_u, _res_8u_0 }, /* 0 */
+ { _map_nominal_u, _res_8u_1 }, /* 1 */
+};
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: 11kHz settings
+ last mod: $Id: setup_11.h 16894 2010-02-12 20:32:12Z xiphmont $
+
+ ********************************************************************/
+
+#include "psych_11.h"
+
+static const int blocksize_11[2]={
+ 512,512
+};
+
+static const int _floor_mapping_11a[]={
+ 6,6
+};
+static const int *_floor_mapping_11[]={
+ _floor_mapping_11a
+};
+
+static const double rate_mapping_11[3]={
+ 8000.,13000.,44000.,
+};
+
+static const double rate_mapping_11_uncoupled[3]={
+ 12000.,20000.,50000.,
+};
+
+static const double quality_mapping_11[3]={
+ -.1,.0,1.
+};
+
+static const ve_setup_data_template ve_setup_11_stereo={
+ 2,
+ rate_mapping_11,
+ quality_mapping_11,
+ 2,
+ 9000,
+ 15000,
+
+ blocksize_11,
+ blocksize_11,
+
+ _psy_tone_masteratt_11,
+ _psy_tone_0dB,
+ _psy_tone_suppress,
+
+ _vp_tonemask_adj_11,
+ NULL,
+ _vp_tonemask_adj_11,
+
+ _psy_noiseguards_8,
+ _psy_noisebias_11,
+ _psy_noisebias_11,
+ NULL,
+ NULL,
+ _psy_noise_suppress,
+
+ _psy_compand_8,
+ _psy_compand_8_mapping,
+ NULL,
+
+ {_noise_start_8,_noise_start_8},
+ {_noise_part_8,_noise_part_8},
+ _noise_thresh_11,
+
+ _psy_ath_floater_8,
+ _psy_ath_abs_8,
+
+ _psy_lowpass_11,
+
+ _psy_global_44,
+ _global_mapping_8,
+ _psy_stereo_modes_8,
+
+ _floor_books,
+ _floor,
+ 1,
+ _floor_mapping_11,
+
+ _mapres_template_8_stereo
+};
+
+static const ve_setup_data_template ve_setup_11_uncoupled={
+ 2,
+ rate_mapping_11_uncoupled,
+ quality_mapping_11,
+ -1,
+ 9000,
+ 15000,
+
+ blocksize_11,
+ blocksize_11,
+
+ _psy_tone_masteratt_11,
+ _psy_tone_0dB,
+ _psy_tone_suppress,
+
+ _vp_tonemask_adj_11,
+ NULL,
+ _vp_tonemask_adj_11,
+
+ _psy_noiseguards_8,
+ _psy_noisebias_11,
+ _psy_noisebias_11,
+ NULL,
+ NULL,
+ _psy_noise_suppress,
+
+ _psy_compand_8,
+ _psy_compand_8_mapping,
+ NULL,
+
+ {_noise_start_8,_noise_start_8},
+ {_noise_part_8,_noise_part_8},
+ _noise_thresh_11,
+
+ _psy_ath_floater_8,
+ _psy_ath_abs_8,
+
+ _psy_lowpass_11,
+
+ _psy_global_44,
+ _global_mapping_8,
+ _psy_stereo_modes_8,
+
+ _floor_books,
+ _floor,
+ 1,
+ _floor_mapping_11,
+
+ _mapres_template_8_uncoupled
+};
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: 16kHz settings
+ last mod: $Id: setup_16.h 16894 2010-02-12 20:32:12Z xiphmont $
+
+ ********************************************************************/
+
+#include "psych_16.h"
+#include "residue_16.h"
+
+static const int blocksize_16_short[3]={
+ 1024,512,512
+};
+static const int blocksize_16_long[3]={
+ 1024,1024,1024
+};
+
+static const int _floor_mapping_16a[]={
+ 9,3,3
+};
+static const int _floor_mapping_16b[]={
+ 9,9,9
+};
+static const int *_floor_mapping_16[]={
+ _floor_mapping_16a,
+ _floor_mapping_16b
+};
+
+static const double rate_mapping_16[4]={
+ 12000.,20000.,44000.,86000.
+};
+
+static const double rate_mapping_16_uncoupled[4]={
+ 16000.,28000.,64000.,100000.
+};
+
+static const double _global_mapping_16[4]={ 1., 2., 3., 4. };
+
+static const double quality_mapping_16[4]={ -.1,.05,.5,1. };
+
+static const double _psy_compand_16_mapping[4]={ 0., .8, 1., 1.};
+
+static const ve_setup_data_template ve_setup_16_stereo={
+ 3,
+ rate_mapping_16,
+ quality_mapping_16,
+ 2,
+ 15000,
+ 19000,
+
+ blocksize_16_short,
+ blocksize_16_long,
+
+ _psy_tone_masteratt_16,
+ _psy_tone_0dB,
+ _psy_tone_suppress,
+
+ _vp_tonemask_adj_16,
+ _vp_tonemask_adj_16,
+ _vp_tonemask_adj_16,
+
+ _psy_noiseguards_16,
+ _psy_noisebias_16_impulse,
+ _psy_noisebias_16_short,
+ _psy_noisebias_16_short,
+ _psy_noisebias_16,
+ _psy_noise_suppress,
+
+ _psy_compand_8,
+ _psy_compand_16_mapping,
+ _psy_compand_16_mapping,
+
+ {_noise_start_16,_noise_start_16},
+ { _noise_part_16, _noise_part_16},
+ _noise_thresh_16,
+
+ _psy_ath_floater_16,
+ _psy_ath_abs_16,
+
+ _psy_lowpass_16,
+
+ _psy_global_44,
+ _global_mapping_16,
+ _psy_stereo_modes_16,
+
+ _floor_books,
+ _floor,
+ 2,
+ _floor_mapping_16,
+
+ _mapres_template_16_stereo
+};
+
+static const ve_setup_data_template ve_setup_16_uncoupled={
+ 3,
+ rate_mapping_16_uncoupled,
+ quality_mapping_16,
+ -1,
+ 15000,
+ 19000,
+
+ blocksize_16_short,
+ blocksize_16_long,
+
+ _psy_tone_masteratt_16,
+ _psy_tone_0dB,
+ _psy_tone_suppress,
+
+ _vp_tonemask_adj_16,
+ _vp_tonemask_adj_16,
+ _vp_tonemask_adj_16,
+
+ _psy_noiseguards_16,
+ _psy_noisebias_16_impulse,
+ _psy_noisebias_16_short,
+ _psy_noisebias_16_short,
+ _psy_noisebias_16,
+ _psy_noise_suppress,
+
+ _psy_compand_8,
+ _psy_compand_16_mapping,
+ _psy_compand_16_mapping,
+
+ {_noise_start_16,_noise_start_16},
+ { _noise_part_16, _noise_part_16},
+ _noise_thresh_16,
+
+ _psy_ath_floater_16,
+ _psy_ath_abs_16,
+
+ _psy_lowpass_16,
+
+ _psy_global_44,
+ _global_mapping_16,
+ _psy_stereo_modes_16,
+
+ _floor_books,
+ _floor,
+ 2,
+ _floor_mapping_16,
+
+ _mapres_template_16_uncoupled
+};
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: 22kHz settings
+ last mod: $Id: setup_22.h 17026 2010-03-25 05:00:27Z xiphmont $
+
+ ********************************************************************/
+
+static const double rate_mapping_22[4]={
+ 15000.,20000.,44000.,86000.
+};
+
+static const double rate_mapping_22_uncoupled[4]={
+ 16000.,28000.,50000.,90000.
+};
+
+static const double _psy_lowpass_22[4]={9.5,11.,30.,99.};
+
+static const ve_setup_data_template ve_setup_22_stereo={
+ 3,
+ rate_mapping_22,
+ quality_mapping_16,
+ 2,
+ 19000,
+ 26000,
+
+ blocksize_16_short,
+ blocksize_16_long,
+
+ _psy_tone_masteratt_16,
+ _psy_tone_0dB,
+ _psy_tone_suppress,
+
+ _vp_tonemask_adj_16,
+ _vp_tonemask_adj_16,
+ _vp_tonemask_adj_16,
+
+ _psy_noiseguards_16,
+ _psy_noisebias_16_impulse,
+ _psy_noisebias_16_short,
+ _psy_noisebias_16_short,
+ _psy_noisebias_16,
+ _psy_noise_suppress,
+
+ _psy_compand_8,
+ _psy_compand_16_mapping,
+ _psy_compand_16_mapping,
+
+ {_noise_start_16,_noise_start_16},
+ { _noise_part_16, _noise_part_16},
+ _noise_thresh_16,
+
+ _psy_ath_floater_16,
+ _psy_ath_abs_16,
+
+ _psy_lowpass_22,
+
+ _psy_global_44,
+ _global_mapping_16,
+ _psy_stereo_modes_16,
+
+ _floor_books,
+ _floor,
+ 2,
+ _floor_mapping_16,
+
+ _mapres_template_16_stereo
+};
+
+static const ve_setup_data_template ve_setup_22_uncoupled={
+ 3,
+ rate_mapping_22_uncoupled,
+ quality_mapping_16,
+ -1,
+ 19000,
+ 26000,
+
+ blocksize_16_short,
+ blocksize_16_long,
+
+ _psy_tone_masteratt_16,
+ _psy_tone_0dB,
+ _psy_tone_suppress,
+
+ _vp_tonemask_adj_16,
+ _vp_tonemask_adj_16,
+ _vp_tonemask_adj_16,
+
+ _psy_noiseguards_16,
+ _psy_noisebias_16_impulse,
+ _psy_noisebias_16_short,
+ _psy_noisebias_16_short,
+ _psy_noisebias_16,
+ _psy_noise_suppress,
+
+ _psy_compand_8,
+ _psy_compand_16_mapping,
+ _psy_compand_16_mapping,
+
+ {_noise_start_16,_noise_start_16},
+ { _noise_part_16, _noise_part_16},
+ _noise_thresh_16,
+
+ _psy_ath_floater_16,
+ _psy_ath_abs_16,
+
+ _psy_lowpass_22,
+
+ _psy_global_44,
+ _global_mapping_16,
+ _psy_stereo_modes_16,
+
+ _floor_books,
+ _floor,
+ 2,
+ _floor_mapping_16,
+
+ _mapres_template_16_uncoupled
+};
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: toplevel settings for 32kHz
+ last mod: $Id: setup_32.h 16894 2010-02-12 20:32:12Z xiphmont $
+
+ ********************************************************************/
+
+static const double rate_mapping_32[12]={
+ 18000.,28000.,35000.,45000.,56000.,60000.,
+ 75000.,90000.,100000.,115000.,150000.,190000.,
+};
+
+static const double rate_mapping_32_un[12]={
+ 30000.,42000.,52000.,64000.,72000.,78000.,
+ 86000.,92000.,110000.,120000.,140000.,190000.,
+};
+
+static const double _psy_lowpass_32[12]={
+ 12.3,13.,13.,14.,15.,99.,99.,99.,99.,99.,99.,99.
+};
+
+static const ve_setup_data_template ve_setup_32_stereo={
+ 11,
+ rate_mapping_32,
+ quality_mapping_44,
+ 2,
+ 26000,
+ 40000,
+
+ blocksize_short_44,
+ blocksize_long_44,
+
+ _psy_tone_masteratt_44,
+ _psy_tone_0dB,
+ _psy_tone_suppress,
+
+ _vp_tonemask_adj_otherblock,
+ _vp_tonemask_adj_longblock,
+ _vp_tonemask_adj_otherblock,
+
+ _psy_noiseguards_44,
+ _psy_noisebias_impulse,
+ _psy_noisebias_padding,
+ _psy_noisebias_trans,
+ _psy_noisebias_long,
+ _psy_noise_suppress,
+
+ _psy_compand_44,
+ _psy_compand_short_mapping,
+ _psy_compand_long_mapping,
+
+ {_noise_start_short_44,_noise_start_long_44},
+ {_noise_part_short_44,_noise_part_long_44},
+ _noise_thresh_44,
+
+ _psy_ath_floater,
+ _psy_ath_abs,
+
+ _psy_lowpass_32,
+
+ _psy_global_44,
+ _global_mapping_44,
+ _psy_stereo_modes_44,
+
+ _floor_books,
+ _floor,
+ 2,
+ _floor_mapping_44,
+
+ _mapres_template_44_stereo
+};
+
+static const ve_setup_data_template ve_setup_32_uncoupled={
+ 11,
+ rate_mapping_32_un,
+ quality_mapping_44,
+ -1,
+ 26000,
+ 40000,
+
+ blocksize_short_44,
+ blocksize_long_44,
+
+ _psy_tone_masteratt_44,
+ _psy_tone_0dB,
+ _psy_tone_suppress,
+
+ _vp_tonemask_adj_otherblock,
+ _vp_tonemask_adj_longblock,
+ _vp_tonemask_adj_otherblock,
+
+ _psy_noiseguards_44,
+ _psy_noisebias_impulse,
+ _psy_noisebias_padding,
+ _psy_noisebias_trans,
+ _psy_noisebias_long,
+ _psy_noise_suppress,
+
+ _psy_compand_44,
+ _psy_compand_short_mapping,
+ _psy_compand_long_mapping,
+
+ {_noise_start_short_44,_noise_start_long_44},
+ {_noise_part_short_44,_noise_part_long_44},
+ _noise_thresh_44,
+
+ _psy_ath_floater,
+ _psy_ath_abs,
+
+ _psy_lowpass_32,
+
+ _psy_global_44,
+ _global_mapping_44,
+ NULL,
+
+ _floor_books,
+ _floor,
+ 2,
+ _floor_mapping_44,
+
+ _mapres_template_44_uncoupled
+};
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: toplevel settings for 44.1/48kHz
+ last mod: $Id: setup_44.h 16962 2010-03-11 07:30:34Z xiphmont $
+
+ ********************************************************************/
+
+#include "modes/floor_all.h"
+#include "modes/residue_44.h"
+#include "modes/psych_44.h"
+
+static const double rate_mapping_44_stereo[12]={
+ 22500.,32000.,40000.,48000.,56000.,64000.,
+ 80000.,96000.,112000.,128000.,160000.,250001.
+};
+
+static const double quality_mapping_44[12]={
+ -.1,.0,.1,.2,.3,.4,.5,.6,.7,.8,.9,1.0
+};
+
+static const int blocksize_short_44[11]={
+ 512,256,256,256,256,256,256,256,256,256,256
+};
+static const int blocksize_long_44[11]={
+ 4096,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048
+};
+
+static const double _psy_compand_short_mapping[12]={
+ 0.5, 1., 1., 1.3, 1.6, 2., 2., 2., 2., 2., 2., 2.
+};
+static const double _psy_compand_long_mapping[12]={
+ 3.5, 4., 4., 4.3, 4.6, 5., 5., 5., 5., 5., 5., 5.
+};
+
+static const double _global_mapping_44[12]={
+ /* 1., 1., 1.5, 2., 2., 2.5, 2.7, 3.0, 3.5, 4., 4. */
+ 0., 1., 1., 1.5, 2., 2., 2.5, 2.7, 3.0, 3.7, 4., 4.
+};
+
+static const int _floor_mapping_44a[11]={
+ 1,0,0,2,2,4,5,5,5,5,5
+};
+
+static const int _floor_mapping_44b[11]={
+ 8,7,7,7,7,7,7,7,7,7,7
+};
+
+static const int _floor_mapping_44c[11]={
+ 10,10,10,10,10,10,10,10,10,10,10
+};
+
+static const int *_floor_mapping_44[]={
+ _floor_mapping_44a,
+ _floor_mapping_44b,
+ _floor_mapping_44c,
+};
+
+static const ve_setup_data_template ve_setup_44_stereo={
+ 11,
+ rate_mapping_44_stereo,
+ quality_mapping_44,
+ 2,
+ 40000,
+ 50000,
+
+ blocksize_short_44,
+ blocksize_long_44,
+
+ _psy_tone_masteratt_44,
+ _psy_tone_0dB,
+ _psy_tone_suppress,
+
+ _vp_tonemask_adj_otherblock,
+ _vp_tonemask_adj_longblock,
+ _vp_tonemask_adj_otherblock,
+
+ _psy_noiseguards_44,
+ _psy_noisebias_impulse,
+ _psy_noisebias_padding,
+ _psy_noisebias_trans,
+ _psy_noisebias_long,
+ _psy_noise_suppress,
+
+ _psy_compand_44,
+ _psy_compand_short_mapping,
+ _psy_compand_long_mapping,
+
+ {_noise_start_short_44,_noise_start_long_44},
+ {_noise_part_short_44,_noise_part_long_44},
+ _noise_thresh_44,
+
+ _psy_ath_floater,
+ _psy_ath_abs,
+
+ _psy_lowpass_44,
+
+ _psy_global_44,
+ _global_mapping_44,
+ _psy_stereo_modes_44,
+
+ _floor_books,
+ _floor,
+ 2,
+ _floor_mapping_44,
+
+ _mapres_template_44_stereo
+};
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2010 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: toplevel settings for 44.1/48kHz 5.1 surround modes
+ last mod: $Id$
+
+ ********************************************************************/
+
+#include "modes/residue_44p51.h"
+
+static const double rate_mapping_44p51[12]={
+ 14000.,20000.,28000.,38000.,46000.,54000.,
+ 75000.,96000.,120000.,140000.,180000.,240001.
+};
+
+static const ve_setup_data_template ve_setup_44_51={
+ 11,
+ rate_mapping_44p51,
+ quality_mapping_44,
+ 6,
+ 40000,
+ 70000,
+
+ blocksize_short_44,
+ blocksize_long_44,
+
+ _psy_tone_masteratt_44,
+ _psy_tone_0dB,
+ _psy_tone_suppress,
+
+ _vp_tonemask_adj_otherblock,
+ _vp_tonemask_adj_longblock,
+ _vp_tonemask_adj_otherblock,
+
+ _psy_noiseguards_44,
+ _psy_noisebias_impulse,
+ _psy_noisebias_padding,
+ _psy_noisebias_trans,
+ _psy_noisebias_long,
+ _psy_noise_suppress,
+
+ _psy_compand_44,
+ _psy_compand_short_mapping,
+ _psy_compand_long_mapping,
+
+ {_noise_start_short_44,_noise_start_long_44},
+ {_noise_part_short_44,_noise_part_long_44},
+ _noise_thresh_44,
+
+ _psy_ath_floater,
+ _psy_ath_abs,
+
+ _psy_lowpass_44,
+
+ _psy_global_44,
+ _global_mapping_44,
+ _psy_stereo_modes_44,
+
+ _floor_books,
+ _floor,
+ 3,
+ _floor_mapping_44,
+
+ _mapres_template_44_51
+};
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: toplevel settings for 44.1/48kHz uncoupled modes
+ last mod: $Id: setup_44u.h 16962 2010-03-11 07:30:34Z xiphmont $
+
+ ********************************************************************/
+
+#include "modes/residue_44u.h"
+
+static const double rate_mapping_44_un[12]={
+ 32000.,48000.,60000.,70000.,80000.,86000.,
+ 96000.,110000.,120000.,140000.,160000.,240001.
+};
+
+static const ve_setup_data_template ve_setup_44_uncoupled={
+ 11,
+ rate_mapping_44_un,
+ quality_mapping_44,
+ -1,
+ 40000,
+ 50000,
+
+ blocksize_short_44,
+ blocksize_long_44,
+
+ _psy_tone_masteratt_44,
+ _psy_tone_0dB,
+ _psy_tone_suppress,
+
+ _vp_tonemask_adj_otherblock,
+ _vp_tonemask_adj_longblock,
+ _vp_tonemask_adj_otherblock,
+
+ _psy_noiseguards_44,
+ _psy_noisebias_impulse,
+ _psy_noisebias_padding,
+ _psy_noisebias_trans,
+ _psy_noisebias_long,
+ _psy_noise_suppress,
+
+ _psy_compand_44,
+ _psy_compand_short_mapping,
+ _psy_compand_long_mapping,
+
+ {_noise_start_short_44,_noise_start_long_44},
+ {_noise_part_short_44,_noise_part_long_44},
+ _noise_thresh_44,
+
+ _psy_ath_floater,
+ _psy_ath_abs,
+
+ _psy_lowpass_44,
+
+ _psy_global_44,
+ _global_mapping_44,
+ _psy_stereo_modes_44,
+
+ _floor_books,
+ _floor,
+ 2,
+ _floor_mapping_44,
+
+ _mapres_template_44_uncoupled
+};
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: 8kHz settings
+ last mod: $Id: setup_8.h 16894 2010-02-12 20:32:12Z xiphmont $
+
+ ********************************************************************/
+
+#include "psych_8.h"
+#include "residue_8.h"
+
+static const int blocksize_8[2]={
+ 512,512
+};
+
+static const int _floor_mapping_8a[]={
+ 6,6
+};
+
+static const int *_floor_mapping_8[]={
+ _floor_mapping_8a
+};
+
+static const double rate_mapping_8[3]={
+ 6000.,9000.,32000.,
+};
+
+static const double rate_mapping_8_uncoupled[3]={
+ 8000.,14000.,42000.,
+};
+
+static const double quality_mapping_8[3]={
+ -.1,.0,1.
+};
+
+static const double _psy_compand_8_mapping[3]={ 0., 1., 1.};
+
+static const double _global_mapping_8[3]={ 1., 2., 3. };
+
+static const ve_setup_data_template ve_setup_8_stereo={
+ 2,
+ rate_mapping_8,
+ quality_mapping_8,
+ 2,
+ 8000,
+ 9000,
+
+ blocksize_8,
+ blocksize_8,
+
+ _psy_tone_masteratt_8,
+ _psy_tone_0dB,
+ _psy_tone_suppress,
+
+ _vp_tonemask_adj_8,
+ NULL,
+ _vp_tonemask_adj_8,
+
+ _psy_noiseguards_8,
+ _psy_noisebias_8,
+ _psy_noisebias_8,
+ NULL,
+ NULL,
+ _psy_noise_suppress,
+
+ _psy_compand_8,
+ _psy_compand_8_mapping,
+ NULL,
+
+ {_noise_start_8,_noise_start_8},
+ {_noise_part_8,_noise_part_8},
+ _noise_thresh_5only,
+
+ _psy_ath_floater_8,
+ _psy_ath_abs_8,
+
+ _psy_lowpass_8,
+
+ _psy_global_44,
+ _global_mapping_8,
+ _psy_stereo_modes_8,
+
+ _floor_books,
+ _floor,
+ 1,
+ _floor_mapping_8,
+
+ _mapres_template_8_stereo
+};
+
+static const ve_setup_data_template ve_setup_8_uncoupled={
+ 2,
+ rate_mapping_8_uncoupled,
+ quality_mapping_8,
+ -1,
+ 8000,
+ 9000,
+
+ blocksize_8,
+ blocksize_8,
+
+ _psy_tone_masteratt_8,
+ _psy_tone_0dB,
+ _psy_tone_suppress,
+
+ _vp_tonemask_adj_8,
+ NULL,
+ _vp_tonemask_adj_8,
+
+ _psy_noiseguards_8,
+ _psy_noisebias_8,
+ _psy_noisebias_8,
+ NULL,
+ NULL,
+ _psy_noise_suppress,
+
+ _psy_compand_8,
+ _psy_compand_8_mapping,
+ NULL,
+
+ {_noise_start_8,_noise_start_8},
+ {_noise_part_8,_noise_part_8},
+ _noise_thresh_5only,
+
+ _psy_ath_floater_8,
+ _psy_ath_abs_8,
+
+ _psy_lowpass_8,
+
+ _psy_global_44,
+ _global_mapping_8,
+ _psy_stereo_modes_8,
+
+ _floor_books,
+ _floor,
+ 1,
+ _floor_mapping_8,
+
+ _mapres_template_8_uncoupled
+};
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: catch-all toplevel settings for q modes only
+ last mod: $Id: setup_X.h 16894 2010-02-12 20:32:12Z xiphmont $
+
+ ********************************************************************/
+
+static const double rate_mapping_X[12]={
+ -1.,-1.,-1.,-1.,-1.,-1.,
+ -1.,-1.,-1.,-1.,-1.,-1.
+};
+
+static const ve_setup_data_template ve_setup_X_stereo={
+ 11,
+ rate_mapping_X,
+ quality_mapping_44,
+ 2,
+ 50000,
+ 200000,
+
+ blocksize_short_44,
+ blocksize_long_44,
+
+ _psy_tone_masteratt_44,
+ _psy_tone_0dB,
+ _psy_tone_suppress,
+
+ _vp_tonemask_adj_otherblock,
+ _vp_tonemask_adj_longblock,
+ _vp_tonemask_adj_otherblock,
+
+ _psy_noiseguards_44,
+ _psy_noisebias_impulse,
+ _psy_noisebias_padding,
+ _psy_noisebias_trans,
+ _psy_noisebias_long,
+ _psy_noise_suppress,
+
+ _psy_compand_44,
+ _psy_compand_short_mapping,
+ _psy_compand_long_mapping,
+
+ {_noise_start_short_44,_noise_start_long_44},
+ {_noise_part_short_44,_noise_part_long_44},
+ _noise_thresh_44,
+
+ _psy_ath_floater,
+ _psy_ath_abs,
+
+ _psy_lowpass_44,
+
+ _psy_global_44,
+ _global_mapping_44,
+ _psy_stereo_modes_44,
+
+ _floor_books,
+ _floor,
+ 2,
+ _floor_mapping_44,
+
+ _mapres_template_44_stereo
+};
+
+static const ve_setup_data_template ve_setup_X_uncoupled={
+ 11,
+ rate_mapping_X,
+ quality_mapping_44,
+ -1,
+ 50000,
+ 200000,
+
+ blocksize_short_44,
+ blocksize_long_44,
+
+ _psy_tone_masteratt_44,
+ _psy_tone_0dB,
+ _psy_tone_suppress,
+
+ _vp_tonemask_adj_otherblock,
+ _vp_tonemask_adj_longblock,
+ _vp_tonemask_adj_otherblock,
+
+ _psy_noiseguards_44,
+ _psy_noisebias_impulse,
+ _psy_noisebias_padding,
+ _psy_noisebias_trans,
+ _psy_noisebias_long,
+ _psy_noise_suppress,
+
+ _psy_compand_44,
+ _psy_compand_short_mapping,
+ _psy_compand_long_mapping,
+
+ {_noise_start_short_44,_noise_start_long_44},
+ {_noise_part_short_44,_noise_part_long_44},
+ _noise_thresh_44,
+
+ _psy_ath_floater,
+ _psy_ath_abs,
+
+ _psy_lowpass_44,
+
+ _psy_global_44,
+ _global_mapping_44,
+ NULL,
+
+ _floor_books,
+ _floor,
+ 2,
+ _floor_mapping_44,
+
+ _mapres_template_44_uncoupled
+};
+
+static const ve_setup_data_template ve_setup_XX_stereo={
+ 2,
+ rate_mapping_X,
+ quality_mapping_8,
+ 2,
+ 0,
+ 8000,
+
+ blocksize_8,
+ blocksize_8,
+
+ _psy_tone_masteratt_8,
+ _psy_tone_0dB,
+ _psy_tone_suppress,
+
+ _vp_tonemask_adj_8,
+ NULL,
+ _vp_tonemask_adj_8,
+
+ _psy_noiseguards_8,
+ _psy_noisebias_8,
+ _psy_noisebias_8,
+ NULL,
+ NULL,
+ _psy_noise_suppress,
+
+ _psy_compand_8,
+ _psy_compand_8_mapping,
+ NULL,
+
+ {_noise_start_8,_noise_start_8},
+ {_noise_part_8,_noise_part_8},
+ _noise_thresh_5only,
+
+ _psy_ath_floater_8,
+ _psy_ath_abs_8,
+
+ _psy_lowpass_8,
+
+ _psy_global_44,
+ _global_mapping_8,
+ _psy_stereo_modes_8,
+
+ _floor_books,
+ _floor,
+ 1,
+ _floor_mapping_8,
+
+ _mapres_template_8_stereo
+};
+
+static const ve_setup_data_template ve_setup_XX_uncoupled={
+ 2,
+ rate_mapping_X,
+ quality_mapping_8,
+ -1,
+ 0,
+ 8000,
+
+ blocksize_8,
+ blocksize_8,
+
+ _psy_tone_masteratt_8,
+ _psy_tone_0dB,
+ _psy_tone_suppress,
+
+ _vp_tonemask_adj_8,
+ NULL,
+ _vp_tonemask_adj_8,
+
+ _psy_noiseguards_8,
+ _psy_noisebias_8,
+ _psy_noisebias_8,
+ NULL,
+ NULL,
+ _psy_noise_suppress,
+
+ _psy_compand_8,
+ _psy_compand_8_mapping,
+ NULL,
+
+ {_noise_start_8,_noise_start_8},
+ {_noise_part_8,_noise_part_8},
+ _noise_thresh_5only,
+
+ _psy_ath_floater_8,
+ _psy_ath_abs_8,
+
+ _psy_lowpass_8,
+
+ _psy_global_44,
+ _global_mapping_8,
+ _psy_stereo_modes_8,
+
+ _floor_books,
+ _floor,
+ 1,
+ _floor_mapping_8,
+
+ _mapres_template_8_uncoupled
+};
--- /dev/null
+#ifndef _OS_H
+#define _OS_H
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: #ifdef jail to whip a few platforms into the UNIX ideal.
+ last mod: $Id: os.h 16227 2009-07-08 06:58:46Z xiphmont $
+
+ ********************************************************************/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <math.h>
+#include <ogg/os_types.h>
+
+#include "misc.h"
+
+#ifndef _V_IFDEFJAIL_H_
+# define _V_IFDEFJAIL_H_
+
+# ifdef __GNUC__
+# define STIN static __inline__
+# elif _WIN32
+# define STIN static __inline
+# else
+# define STIN static
+# endif
+
+#ifdef DJGPP
+# define rint(x) (floor((x)+0.5f))
+#endif
+
+#ifndef M_PI
+# define M_PI (3.1415926536f)
+#endif
+
+#if defined(_WIN32) && !defined(__SYMBIAN32__)
+# include <malloc.h>
+# define rint(x) (floor((x)+0.5f))
+# define NO_FLOAT_MATH_LIB
+# define FAST_HYPOT(a, b) sqrt((a)*(a) + (b)*(b))
+#endif
+
+#if defined(__SYMBIAN32__) && defined(__WINS__)
+void *_alloca(size_t size);
+# define alloca _alloca
+#endif
+
+#ifndef FAST_HYPOT
+# define FAST_HYPOT hypot
+#endif
+
+#endif
+
+#ifdef HAVE_ALLOCA_H
+# include <alloca.h>
+#endif
+
+#ifdef USE_MEMORY_H
+# include <memory.h>
+#endif
+
+#ifndef min
+# define min(x,y) ((x)>(y)?(y):(x))
+#endif
+
+#ifndef max
+# define max(x,y) ((x)<(y)?(y):(x))
+#endif
+
+
+/* Special i386 GCC implementation */
+#if defined(__i386__) && defined(__GNUC__) && !defined(__BEOS__)
+# define VORBIS_FPU_CONTROL
+/* both GCC and MSVC are kinda stupid about rounding/casting to int.
+ Because of encapsulation constraints (GCC can't see inside the asm
+ block and so we end up doing stupid things like a store/load that
+ is collectively a noop), we do it this way */
+
+/* we must set up the fpu before this works!! */
+
+typedef ogg_int16_t vorbis_fpu_control;
+
+static inline void vorbis_fpu_setround(vorbis_fpu_control *fpu){
+ ogg_int16_t ret;
+ ogg_int16_t temp;
+ __asm__ __volatile__("fnstcw %0\n\t"
+ "movw %0,%%dx\n\t"
+ "andw $62463,%%dx\n\t"
+ "movw %%dx,%1\n\t"
+ "fldcw %1\n\t":"=m"(ret):"m"(temp): "dx");
+ *fpu=ret;
+}
+
+static inline void vorbis_fpu_restore(vorbis_fpu_control fpu){
+ __asm__ __volatile__("fldcw %0":: "m"(fpu));
+}
+
+/* assumes the FPU is in round mode! */
+static inline int vorbis_ftoi(double f){ /* yes, double! Otherwise,
+ we get extra fst/fld to
+ truncate precision */
+ int i;
+ __asm__("fistl %0": "=m"(i) : "t"(f));
+ return(i);
+}
+#endif /* Special i386 GCC implementation */
+
+
+/* MSVC inline assembly. 32 bit only; inline ASM isn't implemented in the
+ * 64 bit compiler */
+#if defined(_MSC_VER) && !defined(_WIN64) && !defined(_WIN32_WCE)
+# define VORBIS_FPU_CONTROL
+
+typedef ogg_int16_t vorbis_fpu_control;
+
+static __inline int vorbis_ftoi(double f){
+ int i;
+ __asm{
+ fld f
+ fistp i
+ }
+ return i;
+}
+
+static __inline void vorbis_fpu_setround(vorbis_fpu_control *fpu){
+}
+
+static __inline void vorbis_fpu_restore(vorbis_fpu_control fpu){
+}
+
+#endif /* Special MSVC 32 bit implementation */
+
+
+/* Optimized code path for x86_64 builds. Uses SSE2 intrinsics. This can be
+ done safely because all x86_64 CPUs supports SSE2. */
+#if (defined(_MSC_VER) && defined(_WIN64)) || (defined(__GNUC__) && defined (__x86_64__))
+# define VORBIS_FPU_CONTROL
+
+typedef ogg_int16_t vorbis_fpu_control;
+
+#include <emmintrin.h>
+static __inline int vorbis_ftoi(double f){
+ return _mm_cvtsd_si32(_mm_load_sd(&f));
+}
+
+static __inline void vorbis_fpu_setround(vorbis_fpu_control *fpu){
+}
+
+static __inline void vorbis_fpu_restore(vorbis_fpu_control fpu){
+}
+
+#endif /* Special MSVC x64 implementation */
+
+
+/* If no special implementation was found for the current compiler / platform,
+ use the default implementation here: */
+#ifndef VORBIS_FPU_CONTROL
+
+typedef int vorbis_fpu_control;
+
+static int vorbis_ftoi(double f){
+ /* Note: MSVC and GCC (at least on some systems) round towards zero, thus,
+ the floor() call is required to ensure correct roudning of
+ negative numbers */
+ return (int)floor(f+.5);
+}
+
+/* We don't have special code for this compiler/arch, so do it the slow way */
+# define vorbis_fpu_setround(vorbis_fpu_control) {}
+# define vorbis_fpu_restore(vorbis_fpu_control) {}
+
+#endif /* default implementation */
+
+#endif /* _OS_H */
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2010 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: psychoacoustics not including preecho
+ last mod: $Id: psy.c 18077 2011-09-02 02:49:00Z giles $
+
+ ********************************************************************/
+
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+#include "vorbis/codec.h"
+#include "codec_internal.h"
+
+#include "masking.h"
+#include "psy.h"
+#include "os.h"
+#include "lpc.h"
+#include "smallft.h"
+#include "scales.h"
+#include "misc.h"
+
+#define NEGINF -9999.f
+static const double stereo_threshholds[]={0.0, .5, 1.0, 1.5, 2.5, 4.5, 8.5, 16.5, 9e10};
+static const double stereo_threshholds_limited[]={0.0, .5, 1.0, 1.5, 2.0, 2.5, 4.5, 8.5, 9e10};
+
+vorbis_look_psy_global *_vp_global_look(vorbis_info *vi){
+ codec_setup_info *ci=vi->codec_setup;
+ vorbis_info_psy_global *gi=&ci->psy_g_param;
+ vorbis_look_psy_global *look=_ogg_calloc(1,sizeof(*look));
+
+ look->channels=vi->channels;
+
+ look->ampmax=-9999.;
+ look->gi=gi;
+ return(look);
+}
+
+void _vp_global_free(vorbis_look_psy_global *look){
+ if(look){
+ memset(look,0,sizeof(*look));
+ _ogg_free(look);
+ }
+}
+
+void _vi_gpsy_free(vorbis_info_psy_global *i){
+ if(i){
+ memset(i,0,sizeof(*i));
+ _ogg_free(i);
+ }
+}
+
+void _vi_psy_free(vorbis_info_psy *i){
+ if(i){
+ memset(i,0,sizeof(*i));
+ _ogg_free(i);
+ }
+}
+
+static void min_curve(float *c,
+ float *c2){
+ int i;
+ for(i=0;i<EHMER_MAX;i++)if(c2[i]<c[i])c[i]=c2[i];
+}
+static void max_curve(float *c,
+ float *c2){
+ int i;
+ for(i=0;i<EHMER_MAX;i++)if(c2[i]>c[i])c[i]=c2[i];
+}
+
+static void attenuate_curve(float *c,float att){
+ int i;
+ for(i=0;i<EHMER_MAX;i++)
+ c[i]+=att;
+}
+
+static float ***setup_tone_curves(float curveatt_dB[P_BANDS],float binHz,int n,
+ float center_boost, float center_decay_rate){
+ int i,j,k,m;
+ float ath[EHMER_MAX];
+ float workc[P_BANDS][P_LEVELS][EHMER_MAX];
+ float athc[P_LEVELS][EHMER_MAX];
+ float *brute_buffer=alloca(n*sizeof(*brute_buffer));
+
+ float ***ret=_ogg_malloc(sizeof(*ret)*P_BANDS);
+
+ memset(workc,0,sizeof(workc));
+
+ for(i=0;i<P_BANDS;i++){
+ /* we add back in the ATH to avoid low level curves falling off to
+ -infinity and unnecessarily cutting off high level curves in the
+ curve limiting (last step). */
+
+ /* A half-band's settings must be valid over the whole band, and
+ it's better to mask too little than too much */
+ int ath_offset=i*4;
+ for(j=0;j<EHMER_MAX;j++){
+ float min=999.;
+ for(k=0;k<4;k++)
+ if(j+k+ath_offset<MAX_ATH){
+ if(min>ATH[j+k+ath_offset])min=ATH[j+k+ath_offset];
+ }else{
+ if(min>ATH[MAX_ATH-1])min=ATH[MAX_ATH-1];
+ }
+ ath[j]=min;
+ }
+
+ /* copy curves into working space, replicate the 50dB curve to 30
+ and 40, replicate the 100dB curve to 110 */
+ for(j=0;j<6;j++)
+ memcpy(workc[i][j+2],tonemasks[i][j],EHMER_MAX*sizeof(*tonemasks[i][j]));
+ memcpy(workc[i][0],tonemasks[i][0],EHMER_MAX*sizeof(*tonemasks[i][0]));
+ memcpy(workc[i][1],tonemasks[i][0],EHMER_MAX*sizeof(*tonemasks[i][0]));
+
+ /* apply centered curve boost/decay */
+ for(j=0;j<P_LEVELS;j++){
+ for(k=0;k<EHMER_MAX;k++){
+ float adj=center_boost+abs(EHMER_OFFSET-k)*center_decay_rate;
+ if(adj<0. && center_boost>0)adj=0.;
+ if(adj>0. && center_boost<0)adj=0.;
+ workc[i][j][k]+=adj;
+ }
+ }
+
+ /* normalize curves so the driving amplitude is 0dB */
+ /* make temp curves with the ATH overlayed */
+ for(j=0;j<P_LEVELS;j++){
+ attenuate_curve(workc[i][j],curveatt_dB[i]+100.-(j<2?2:j)*10.-P_LEVEL_0);
+ memcpy(athc[j],ath,EHMER_MAX*sizeof(**athc));
+ attenuate_curve(athc[j],+100.-j*10.f-P_LEVEL_0);
+ max_curve(athc[j],workc[i][j]);
+ }
+
+ /* Now limit the louder curves.
+
+ the idea is this: We don't know what the playback attenuation
+ will be; 0dB SL moves every time the user twiddles the volume
+ knob. So that means we have to use a single 'most pessimal' curve
+ for all masking amplitudes, right? Wrong. The *loudest* sound
+ can be in (we assume) a range of ...+100dB] SL. However, sounds
+ 20dB down will be in a range ...+80], 40dB down is from ...+60],
+ etc... */
+
+ for(j=1;j<P_LEVELS;j++){
+ min_curve(athc[j],athc[j-1]);
+ min_curve(workc[i][j],athc[j]);
+ }
+ }
+
+ for(i=0;i<P_BANDS;i++){
+ int hi_curve,lo_curve,bin;
+ ret[i]=_ogg_malloc(sizeof(**ret)*P_LEVELS);
+
+ /* low frequency curves are measured with greater resolution than
+ the MDCT/FFT will actually give us; we want the curve applied
+ to the tone data to be pessimistic and thus apply the minimum
+ masking possible for a given bin. That means that a single bin
+ could span more than one octave and that the curve will be a
+ composite of multiple octaves. It also may mean that a single
+ bin may span > an eighth of an octave and that the eighth
+ octave values may also be composited. */
+
+ /* which octave curves will we be compositing? */
+ bin=floor(fromOC(i*.5)/binHz);
+ lo_curve= ceil(toOC(bin*binHz+1)*2);
+ hi_curve= floor(toOC((bin+1)*binHz)*2);
+ if(lo_curve>i)lo_curve=i;
+ if(lo_curve<0)lo_curve=0;
+ if(hi_curve>=P_BANDS)hi_curve=P_BANDS-1;
+
+ for(m=0;m<P_LEVELS;m++){
+ ret[i][m]=_ogg_malloc(sizeof(***ret)*(EHMER_MAX+2));
+
+ for(j=0;j<n;j++)brute_buffer[j]=999.;
+
+ /* render the curve into bins, then pull values back into curve.
+ The point is that any inherent subsampling aliasing results in
+ a safe minimum */
+ for(k=lo_curve;k<=hi_curve;k++){
+ int l=0;
+
+ for(j=0;j<EHMER_MAX;j++){
+ int lo_bin= fromOC(j*.125+k*.5-2.0625)/binHz;
+ int hi_bin= fromOC(j*.125+k*.5-1.9375)/binHz+1;
+
+ if(lo_bin<0)lo_bin=0;
+ if(lo_bin>n)lo_bin=n;
+ if(lo_bin<l)l=lo_bin;
+ if(hi_bin<0)hi_bin=0;
+ if(hi_bin>n)hi_bin=n;
+
+ for(;l<hi_bin && l<n;l++)
+ if(brute_buffer[l]>workc[k][m][j])
+ brute_buffer[l]=workc[k][m][j];
+ }
+
+ for(;l<n;l++)
+ if(brute_buffer[l]>workc[k][m][EHMER_MAX-1])
+ brute_buffer[l]=workc[k][m][EHMER_MAX-1];
+
+ }
+
+ /* be equally paranoid about being valid up to next half ocatve */
+ if(i+1<P_BANDS){
+ int l=0;
+ k=i+1;
+ for(j=0;j<EHMER_MAX;j++){
+ int lo_bin= fromOC(j*.125+i*.5-2.0625)/binHz;
+ int hi_bin= fromOC(j*.125+i*.5-1.9375)/binHz+1;
+
+ if(lo_bin<0)lo_bin=0;
+ if(lo_bin>n)lo_bin=n;
+ if(lo_bin<l)l=lo_bin;
+ if(hi_bin<0)hi_bin=0;
+ if(hi_bin>n)hi_bin=n;
+
+ for(;l<hi_bin && l<n;l++)
+ if(brute_buffer[l]>workc[k][m][j])
+ brute_buffer[l]=workc[k][m][j];
+ }
+
+ for(;l<n;l++)
+ if(brute_buffer[l]>workc[k][m][EHMER_MAX-1])
+ brute_buffer[l]=workc[k][m][EHMER_MAX-1];
+
+ }
+
+
+ for(j=0;j<EHMER_MAX;j++){
+ int bin=fromOC(j*.125+i*.5-2.)/binHz;
+ if(bin<0){
+ ret[i][m][j+2]=-999.;
+ }else{
+ if(bin>=n){
+ ret[i][m][j+2]=-999.;
+ }else{
+ ret[i][m][j+2]=brute_buffer[bin];
+ }
+ }
+ }
+
+ /* add fenceposts */
+ for(j=0;j<EHMER_OFFSET;j++)
+ if(ret[i][m][j+2]>-200.f)break;
+ ret[i][m][0]=j;
+
+ for(j=EHMER_MAX-1;j>EHMER_OFFSET+1;j--)
+ if(ret[i][m][j+2]>-200.f)
+ break;
+ ret[i][m][1]=j;
+
+ }
+ }
+
+ return(ret);
+}
+
+void _vp_psy_init(vorbis_look_psy *p,vorbis_info_psy *vi,
+ vorbis_info_psy_global *gi,int n,long rate){
+ long i,j,lo=-99,hi=1;
+ long maxoc;
+ memset(p,0,sizeof(*p));
+
+ p->eighth_octave_lines=gi->eighth_octave_lines;
+ p->shiftoc=rint(log(gi->eighth_octave_lines*8.f)/log(2.f))-1;
+
+ p->firstoc=toOC(.25f*rate*.5/n)*(1<<(p->shiftoc+1))-gi->eighth_octave_lines;
+ maxoc=toOC((n+.25f)*rate*.5/n)*(1<<(p->shiftoc+1))+.5f;
+ p->total_octave_lines=maxoc-p->firstoc+1;
+ p->ath=_ogg_malloc(n*sizeof(*p->ath));
+
+ p->octave=_ogg_malloc(n*sizeof(*p->octave));
+ p->bark=_ogg_malloc(n*sizeof(*p->bark));
+ p->vi=vi;
+ p->n=n;
+ p->rate=rate;
+
+ /* AoTuV HF weighting */
+ p->m_val = 1.;
+ if(rate < 26000) p->m_val = 0;
+ else if(rate < 38000) p->m_val = .94; /* 32kHz */
+ else if(rate > 46000) p->m_val = 1.275; /* 48kHz */
+
+ /* set up the lookups for a given blocksize and sample rate */
+
+ for(i=0,j=0;i<MAX_ATH-1;i++){
+ int endpos=rint(fromOC((i+1)*.125-2.)*2*n/rate);
+ float base=ATH[i];
+ if(j<endpos){
+ float delta=(ATH[i+1]-base)/(endpos-j);
+ for(;j<endpos && j<n;j++){
+ p->ath[j]=base+100.;
+ base+=delta;
+ }
+ }
+ }
+
+ for(;j<n;j++){
+ p->ath[j]=p->ath[j-1];
+ }
+
+ for(i=0;i<n;i++){
+ float bark=toBARK(rate/(2*n)*i);
+
+ for(;lo+vi->noisewindowlomin<i &&
+ toBARK(rate/(2*n)*lo)<(bark-vi->noisewindowlo);lo++);
+
+ for(;hi<=n && (hi<i+vi->noisewindowhimin ||
+ toBARK(rate/(2*n)*hi)<(bark+vi->noisewindowhi));hi++);
+
+ p->bark[i]=((lo-1)<<16)+(hi-1);
+
+ }
+
+ for(i=0;i<n;i++)
+ p->octave[i]=toOC((i+.25f)*.5*rate/n)*(1<<(p->shiftoc+1))+.5f;
+
+ p->tonecurves=setup_tone_curves(vi->toneatt,rate*.5/n,n,
+ vi->tone_centerboost,vi->tone_decay);
+
+ /* set up rolling noise median */
+ p->noiseoffset=_ogg_malloc(P_NOISECURVES*sizeof(*p->noiseoffset));
+ for(i=0;i<P_NOISECURVES;i++)
+ p->noiseoffset[i]=_ogg_malloc(n*sizeof(**p->noiseoffset));
+
+ for(i=0;i<n;i++){
+ float halfoc=toOC((i+.5)*rate/(2.*n))*2.;
+ int inthalfoc;
+ float del;
+
+ if(halfoc<0)halfoc=0;
+ if(halfoc>=P_BANDS-1)halfoc=P_BANDS-1;
+ inthalfoc=(int)halfoc;
+ del=halfoc-inthalfoc;
+
+ for(j=0;j<P_NOISECURVES;j++)
+ p->noiseoffset[j][i]=
+ p->vi->noiseoff[j][inthalfoc]*(1.-del) +
+ p->vi->noiseoff[j][inthalfoc+1]*del;
+
+ }
+#if 0
+ {
+ static int ls=0;
+ _analysis_output_always("noiseoff0",ls,p->noiseoffset[0],n,1,0,0);
+ _analysis_output_always("noiseoff1",ls,p->noiseoffset[1],n,1,0,0);
+ _analysis_output_always("noiseoff2",ls++,p->noiseoffset[2],n,1,0,0);
+ }
+#endif
+}
+
+void _vp_psy_clear(vorbis_look_psy *p){
+ int i,j;
+ if(p){
+ if(p->ath)_ogg_free(p->ath);
+ if(p->octave)_ogg_free(p->octave);
+ if(p->bark)_ogg_free(p->bark);
+ if(p->tonecurves){
+ for(i=0;i<P_BANDS;i++){
+ for(j=0;j<P_LEVELS;j++){
+ _ogg_free(p->tonecurves[i][j]);
+ }
+ _ogg_free(p->tonecurves[i]);
+ }
+ _ogg_free(p->tonecurves);
+ }
+ if(p->noiseoffset){
+ for(i=0;i<P_NOISECURVES;i++){
+ _ogg_free(p->noiseoffset[i]);
+ }
+ _ogg_free(p->noiseoffset);
+ }
+ memset(p,0,sizeof(*p));
+ }
+}
+
+/* octave/(8*eighth_octave_lines) x scale and dB y scale */
+static void seed_curve(float *seed,
+ const float **curves,
+ float amp,
+ int oc, int n,
+ int linesper,float dBoffset){
+ int i,post1;
+ int seedptr;
+ const float *posts,*curve;
+
+ int choice=(int)((amp+dBoffset-P_LEVEL_0)*.1f);
+ choice=max(choice,0);
+ choice=min(choice,P_LEVELS-1);
+ posts=curves[choice];
+ curve=posts+2;
+ post1=(int)posts[1];
+ seedptr=oc+(posts[0]-EHMER_OFFSET)*linesper-(linesper>>1);
+
+ for(i=posts[0];i<post1;i++){
+ if(seedptr>0){
+ float lin=amp+curve[i];
+ if(seed[seedptr]<lin)seed[seedptr]=lin;
+ }
+ seedptr+=linesper;
+ if(seedptr>=n)break;
+ }
+}
+
+static void seed_loop(vorbis_look_psy *p,
+ const float ***curves,
+ const float *f,
+ const float *flr,
+ float *seed,
+ float specmax){
+ vorbis_info_psy *vi=p->vi;
+ long n=p->n,i;
+ float dBoffset=vi->max_curve_dB-specmax;
+
+ /* prime the working vector with peak values */
+
+ for(i=0;i<n;i++){
+ float max=f[i];
+ long oc=p->octave[i];
+ while(i+1<n && p->octave[i+1]==oc){
+ i++;
+ if(f[i]>max)max=f[i];
+ }
+
+ if(max+6.f>flr[i]){
+ oc=oc>>p->shiftoc;
+
+ if(oc>=P_BANDS)oc=P_BANDS-1;
+ if(oc<0)oc=0;
+
+ seed_curve(seed,
+ curves[oc],
+ max,
+ p->octave[i]-p->firstoc,
+ p->total_octave_lines,
+ p->eighth_octave_lines,
+ dBoffset);
+ }
+ }
+}
+
+static void seed_chase(float *seeds, int linesper, long n){
+ long *posstack=alloca(n*sizeof(*posstack));
+ float *ampstack=alloca(n*sizeof(*ampstack));
+ long stack=0;
+ long pos=0;
+ long i;
+
+ for(i=0;i<n;i++){
+ if(stack<2){
+ posstack[stack]=i;
+ ampstack[stack++]=seeds[i];
+ }else{
+ while(1){
+ if(seeds[i]<ampstack[stack-1]){
+ posstack[stack]=i;
+ ampstack[stack++]=seeds[i];
+ break;
+ }else{
+ if(i<posstack[stack-1]+linesper){
+ if(stack>1 && ampstack[stack-1]<=ampstack[stack-2] &&
+ i<posstack[stack-2]+linesper){
+ /* we completely overlap, making stack-1 irrelevant. pop it */
+ stack--;
+ continue;
+ }
+ }
+ posstack[stack]=i;
+ ampstack[stack++]=seeds[i];
+ break;
+
+ }
+ }
+ }
+ }
+
+ /* the stack now contains only the positions that are relevant. Scan
+ 'em straight through */
+
+ for(i=0;i<stack;i++){
+ long endpos;
+ if(i<stack-1 && ampstack[i+1]>ampstack[i]){
+ endpos=posstack[i+1];
+ }else{
+ endpos=posstack[i]+linesper+1; /* +1 is important, else bin 0 is
+ discarded in short frames */
+ }
+ if(endpos>n)endpos=n;
+ for(;pos<endpos;pos++)
+ seeds[pos]=ampstack[i];
+ }
+
+ /* there. Linear time. I now remember this was on a problem set I
+ had in Grad Skool... I didn't solve it at the time ;-) */
+
+}
+
+/* bleaugh, this is more complicated than it needs to be */
+#include<stdio.h>
+static void max_seeds(vorbis_look_psy *p,
+ float *seed,
+ float *flr){
+ long n=p->total_octave_lines;
+ int linesper=p->eighth_octave_lines;
+ long linpos=0;
+ long pos;
+
+ seed_chase(seed,linesper,n); /* for masking */
+
+ pos=p->octave[0]-p->firstoc-(linesper>>1);
+
+ while(linpos+1<p->n){
+ float minV=seed[pos];
+ long end=((p->octave[linpos]+p->octave[linpos+1])>>1)-p->firstoc;
+ if(minV>p->vi->tone_abs_limit)minV=p->vi->tone_abs_limit;
+ while(pos+1<=end){
+ pos++;
+ if((seed[pos]>NEGINF && seed[pos]<minV) || minV==NEGINF)
+ minV=seed[pos];
+ }
+
+ end=pos+p->firstoc;
+ for(;linpos<p->n && p->octave[linpos]<=end;linpos++)
+ if(flr[linpos]<minV)flr[linpos]=minV;
+ }
+
+ {
+ float minV=seed[p->total_octave_lines-1];
+ for(;linpos<p->n;linpos++)
+ if(flr[linpos]<minV)flr[linpos]=minV;
+ }
+
+}
+
+static void bark_noise_hybridmp(int n,const long *b,
+ const float *f,
+ float *noise,
+ const float offset,
+ const int fixed){
+
+ float *N=alloca(n*sizeof(*N));
+ float *X=alloca(n*sizeof(*N));
+ float *XX=alloca(n*sizeof(*N));
+ float *Y=alloca(n*sizeof(*N));
+ float *XY=alloca(n*sizeof(*N));
+
+ float tN, tX, tXX, tY, tXY;
+ int i;
+
+ int lo, hi;
+ float R=0.f;
+ float A=0.f;
+ float B=0.f;
+ float D=1.f;
+ float w, x, y;
+
+ tN = tX = tXX = tY = tXY = 0.f;
+
+ y = f[0] + offset;
+ if (y < 1.f) y = 1.f;
+
+ w = y * y * .5;
+
+ tN += w;
+ tX += w;
+ tY += w * y;
+
+ N[0] = tN;
+ X[0] = tX;
+ XX[0] = tXX;
+ Y[0] = tY;
+ XY[0] = tXY;
+
+ for (i = 1, x = 1.f; i < n; i++, x += 1.f) {
+
+ y = f[i] + offset;
+ if (y < 1.f) y = 1.f;
+
+ w = y * y;
+
+ tN += w;
+ tX += w * x;
+ tXX += w * x * x;
+ tY += w * y;
+ tXY += w * x * y;
+
+ N[i] = tN;
+ X[i] = tX;
+ XX[i] = tXX;
+ Y[i] = tY;
+ XY[i] = tXY;
+ }
+
+ for (i = 0, x = 0.f;; i++, x += 1.f) {
+
+ lo = b[i] >> 16;
+ if( lo>=0 ) break;
+ hi = b[i] & 0xffff;
+
+ tN = N[hi] + N[-lo];
+ tX = X[hi] - X[-lo];
+ tXX = XX[hi] + XX[-lo];
+ tY = Y[hi] + Y[-lo];
+ tXY = XY[hi] - XY[-lo];
+
+ A = tY * tXX - tX * tXY;
+ B = tN * tXY - tX * tY;
+ D = tN * tXX - tX * tX;
+ R = (A + x * B) / D;
+ if (R < 0.f)
+ R = 0.f;
+
+ noise[i] = R - offset;
+ }
+
+ for ( ;; i++, x += 1.f) {
+
+ lo = b[i] >> 16;
+ hi = b[i] & 0xffff;
+ if(hi>=n)break;
+
+ tN = N[hi] - N[lo];
+ tX = X[hi] - X[lo];
+ tXX = XX[hi] - XX[lo];
+ tY = Y[hi] - Y[lo];
+ tXY = XY[hi] - XY[lo];
+
+ A = tY * tXX - tX * tXY;
+ B = tN * tXY - tX * tY;
+ D = tN * tXX - tX * tX;
+ R = (A + x * B) / D;
+ if (R < 0.f) R = 0.f;
+
+ noise[i] = R - offset;
+ }
+ for ( ; i < n; i++, x += 1.f) {
+
+ R = (A + x * B) / D;
+ if (R < 0.f) R = 0.f;
+
+ noise[i] = R - offset;
+ }
+
+ if (fixed <= 0) return;
+
+ for (i = 0, x = 0.f;; i++, x += 1.f) {
+ hi = i + fixed / 2;
+ lo = hi - fixed;
+ if(lo>=0)break;
+
+ tN = N[hi] + N[-lo];
+ tX = X[hi] - X[-lo];
+ tXX = XX[hi] + XX[-lo];
+ tY = Y[hi] + Y[-lo];
+ tXY = XY[hi] - XY[-lo];
+
+
+ A = tY * tXX - tX * tXY;
+ B = tN * tXY - tX * tY;
+ D = tN * tXX - tX * tX;
+ R = (A + x * B) / D;
+
+ if (R - offset < noise[i]) noise[i] = R - offset;
+ }
+ for ( ;; i++, x += 1.f) {
+
+ hi = i + fixed / 2;
+ lo = hi - fixed;
+ if(hi>=n)break;
+
+ tN = N[hi] - N[lo];
+ tX = X[hi] - X[lo];
+ tXX = XX[hi] - XX[lo];
+ tY = Y[hi] - Y[lo];
+ tXY = XY[hi] - XY[lo];
+
+ A = tY * tXX - tX * tXY;
+ B = tN * tXY - tX * tY;
+ D = tN * tXX - tX * tX;
+ R = (A + x * B) / D;
+
+ if (R - offset < noise[i]) noise[i] = R - offset;
+ }
+ for ( ; i < n; i++, x += 1.f) {
+ R = (A + x * B) / D;
+ if (R - offset < noise[i]) noise[i] = R - offset;
+ }
+}
+
+void _vp_noisemask(vorbis_look_psy *p,
+ float *logmdct,
+ float *logmask){
+
+ int i,n=p->n;
+ float *work=alloca(n*sizeof(*work));
+
+ bark_noise_hybridmp(n,p->bark,logmdct,logmask,
+ 140.,-1);
+
+ for(i=0;i<n;i++)work[i]=logmdct[i]-logmask[i];
+
+ bark_noise_hybridmp(n,p->bark,work,logmask,0.,
+ p->vi->noisewindowfixed);
+
+ for(i=0;i<n;i++)work[i]=logmdct[i]-work[i];
+
+#if 0
+ {
+ static int seq=0;
+
+ float work2[n];
+ for(i=0;i<n;i++){
+ work2[i]=logmask[i]+work[i];
+ }
+
+ if(seq&1)
+ _analysis_output("median2R",seq/2,work,n,1,0,0);
+ else
+ _analysis_output("median2L",seq/2,work,n,1,0,0);
+
+ if(seq&1)
+ _analysis_output("envelope2R",seq/2,work2,n,1,0,0);
+ else
+ _analysis_output("envelope2L",seq/2,work2,n,1,0,0);
+ seq++;
+ }
+#endif
+
+ for(i=0;i<n;i++){
+ int dB=logmask[i]+.5;
+ if(dB>=NOISE_COMPAND_LEVELS)dB=NOISE_COMPAND_LEVELS-1;
+ if(dB<0)dB=0;
+ logmask[i]= work[i]+p->vi->noisecompand[dB];
+ }
+
+}
+
+void _vp_tonemask(vorbis_look_psy *p,
+ float *logfft,
+ float *logmask,
+ float global_specmax,
+ float local_specmax){
+
+ int i,n=p->n;
+
+ float *seed=alloca(sizeof(*seed)*p->total_octave_lines);
+ float att=local_specmax+p->vi->ath_adjatt;
+ for(i=0;i<p->total_octave_lines;i++)seed[i]=NEGINF;
+
+ /* set the ATH (floating below localmax, not global max by a
+ specified att) */
+ if(att<p->vi->ath_maxatt)att=p->vi->ath_maxatt;
+
+ for(i=0;i<n;i++)
+ logmask[i]=p->ath[i]+att;
+
+ /* tone masking */
+ seed_loop(p,(const float ***)p->tonecurves,logfft,logmask,seed,global_specmax);
+ max_seeds(p,seed,logmask);
+
+}
+
+void _vp_offset_and_mix(vorbis_look_psy *p,
+ float *noise,
+ float *tone,
+ int offset_select,
+ float *logmask,
+ float *mdct,
+ float *logmdct){
+ int i,n=p->n;
+ float de, coeffi, cx;/* AoTuV */
+ float toneatt=p->vi->tone_masteratt[offset_select];
+
+ cx = p->m_val;
+
+ for(i=0;i<n;i++){
+ float val= noise[i]+p->noiseoffset[offset_select][i];
+ if(val>p->vi->noisemaxsupp)val=p->vi->noisemaxsupp;
+ logmask[i]=max(val,tone[i]+toneatt);
+
+
+ /* AoTuV */
+ /** @ M1 **
+ The following codes improve a noise problem.
+ A fundamental idea uses the value of masking and carries out
+ the relative compensation of the MDCT.
+ However, this code is not perfect and all noise problems cannot be solved.
+ by Aoyumi @ 2004/04/18
+ */
+
+ if(offset_select == 1) {
+ coeffi = -17.2; /* coeffi is a -17.2dB threshold */
+ val = val - logmdct[i]; /* val == mdct line value relative to floor in dB */
+
+ if(val > coeffi){
+ /* mdct value is > -17.2 dB below floor */
+
+ de = 1.0-((val-coeffi)*0.005*cx);
+ /* pro-rated attenuation:
+ -0.00 dB boost if mdct value is -17.2dB (relative to floor)
+ -0.77 dB boost if mdct value is 0dB (relative to floor)
+ -1.64 dB boost if mdct value is +17.2dB (relative to floor)
+ etc... */
+
+ if(de < 0) de = 0.0001;
+ }else
+ /* mdct value is <= -17.2 dB below floor */
+
+ de = 1.0-((val-coeffi)*0.0003*cx);
+ /* pro-rated attenuation:
+ +0.00 dB atten if mdct value is -17.2dB (relative to floor)
+ +0.45 dB atten if mdct value is -34.4dB (relative to floor)
+ etc... */
+
+ mdct[i] *= de;
+
+ }
+ }
+}
+
+float _vp_ampmax_decay(float amp,vorbis_dsp_state *vd){
+ vorbis_info *vi=vd->vi;
+ codec_setup_info *ci=vi->codec_setup;
+ vorbis_info_psy_global *gi=&ci->psy_g_param;
+
+ int n=ci->blocksizes[vd->W]/2;
+ float secs=(float)n/vi->rate;
+
+ amp+=secs*gi->ampmax_att_per_sec;
+ if(amp<-9999)amp=-9999;
+ return(amp);
+}
+
+static float FLOOR1_fromdB_LOOKUP[256]={
+ 1.0649863e-07F, 1.1341951e-07F, 1.2079015e-07F, 1.2863978e-07F,
+ 1.3699951e-07F, 1.4590251e-07F, 1.5538408e-07F, 1.6548181e-07F,
+ 1.7623575e-07F, 1.8768855e-07F, 1.9988561e-07F, 2.128753e-07F,
+ 2.2670913e-07F, 2.4144197e-07F, 2.5713223e-07F, 2.7384213e-07F,
+ 2.9163793e-07F, 3.1059021e-07F, 3.3077411e-07F, 3.5226968e-07F,
+ 3.7516214e-07F, 3.9954229e-07F, 4.2550680e-07F, 4.5315863e-07F,
+ 4.8260743e-07F, 5.1396998e-07F, 5.4737065e-07F, 5.8294187e-07F,
+ 6.2082472e-07F, 6.6116941e-07F, 7.0413592e-07F, 7.4989464e-07F,
+ 7.9862701e-07F, 8.5052630e-07F, 9.0579828e-07F, 9.6466216e-07F,
+ 1.0273513e-06F, 1.0941144e-06F, 1.1652161e-06F, 1.2409384e-06F,
+ 1.3215816e-06F, 1.4074654e-06F, 1.4989305e-06F, 1.5963394e-06F,
+ 1.7000785e-06F, 1.8105592e-06F, 1.9282195e-06F, 2.0535261e-06F,
+ 2.1869758e-06F, 2.3290978e-06F, 2.4804557e-06F, 2.6416497e-06F,
+ 2.8133190e-06F, 2.9961443e-06F, 3.1908506e-06F, 3.3982101e-06F,
+ 3.6190449e-06F, 3.8542308e-06F, 4.1047004e-06F, 4.3714470e-06F,
+ 4.6555282e-06F, 4.9580707e-06F, 5.2802740e-06F, 5.6234160e-06F,
+ 5.9888572e-06F, 6.3780469e-06F, 6.7925283e-06F, 7.2339451e-06F,
+ 7.7040476e-06F, 8.2047000e-06F, 8.7378876e-06F, 9.3057248e-06F,
+ 9.9104632e-06F, 1.0554501e-05F, 1.1240392e-05F, 1.1970856e-05F,
+ 1.2748789e-05F, 1.3577278e-05F, 1.4459606e-05F, 1.5399272e-05F,
+ 1.6400004e-05F, 1.7465768e-05F, 1.8600792e-05F, 1.9809576e-05F,
+ 2.1096914e-05F, 2.2467911e-05F, 2.3928002e-05F, 2.5482978e-05F,
+ 2.7139006e-05F, 2.8902651e-05F, 3.0780908e-05F, 3.2781225e-05F,
+ 3.4911534e-05F, 3.7180282e-05F, 3.9596466e-05F, 4.2169667e-05F,
+ 4.4910090e-05F, 4.7828601e-05F, 5.0936773e-05F, 5.4246931e-05F,
+ 5.7772202e-05F, 6.1526565e-05F, 6.5524908e-05F, 6.9783085e-05F,
+ 7.4317983e-05F, 7.9147585e-05F, 8.4291040e-05F, 8.9768747e-05F,
+ 9.5602426e-05F, 0.00010181521F, 0.00010843174F, 0.00011547824F,
+ 0.00012298267F, 0.00013097477F, 0.00013948625F, 0.00014855085F,
+ 0.00015820453F, 0.00016848555F, 0.00017943469F, 0.00019109536F,
+ 0.00020351382F, 0.00021673929F, 0.00023082423F, 0.00024582449F,
+ 0.00026179955F, 0.00027881276F, 0.00029693158F, 0.00031622787F,
+ 0.00033677814F, 0.00035866388F, 0.00038197188F, 0.00040679456F,
+ 0.00043323036F, 0.00046138411F, 0.00049136745F, 0.00052329927F,
+ 0.00055730621F, 0.00059352311F, 0.00063209358F, 0.00067317058F,
+ 0.00071691700F, 0.00076350630F, 0.00081312324F, 0.00086596457F,
+ 0.00092223983F, 0.00098217216F, 0.0010459992F, 0.0011139742F,
+ 0.0011863665F, 0.0012634633F, 0.0013455702F, 0.0014330129F,
+ 0.0015261382F, 0.0016253153F, 0.0017309374F, 0.0018434235F,
+ 0.0019632195F, 0.0020908006F, 0.0022266726F, 0.0023713743F,
+ 0.0025254795F, 0.0026895994F, 0.0028643847F, 0.0030505286F,
+ 0.0032487691F, 0.0034598925F, 0.0036847358F, 0.0039241906F,
+ 0.0041792066F, 0.0044507950F, 0.0047400328F, 0.0050480668F,
+ 0.0053761186F, 0.0057254891F, 0.0060975636F, 0.0064938176F,
+ 0.0069158225F, 0.0073652516F, 0.0078438871F, 0.0083536271F,
+ 0.0088964928F, 0.009474637F, 0.010090352F, 0.010746080F,
+ 0.011444421F, 0.012188144F, 0.012980198F, 0.013823725F,
+ 0.014722068F, 0.015678791F, 0.016697687F, 0.017782797F,
+ 0.018938423F, 0.020169149F, 0.021479854F, 0.022875735F,
+ 0.024362330F, 0.025945531F, 0.027631618F, 0.029427276F,
+ 0.031339626F, 0.033376252F, 0.035545228F, 0.037855157F,
+ 0.040315199F, 0.042935108F, 0.045725273F, 0.048696758F,
+ 0.051861348F, 0.055231591F, 0.058820850F, 0.062643361F,
+ 0.066714279F, 0.071049749F, 0.075666962F, 0.080584227F,
+ 0.085821044F, 0.091398179F, 0.097337747F, 0.10366330F,
+ 0.11039993F, 0.11757434F, 0.12521498F, 0.13335215F,
+ 0.14201813F, 0.15124727F, 0.16107617F, 0.17154380F,
+ 0.18269168F, 0.19456402F, 0.20720788F, 0.22067342F,
+ 0.23501402F, 0.25028656F, 0.26655159F, 0.28387361F,
+ 0.30232132F, 0.32196786F, 0.34289114F, 0.36517414F,
+ 0.38890521F, 0.41417847F, 0.44109412F, 0.46975890F,
+ 0.50028648F, 0.53279791F, 0.56742212F, 0.60429640F,
+ 0.64356699F, 0.68538959F, 0.72993007F, 0.77736504F,
+ 0.82788260F, 0.88168307F, 0.9389798F, 1.F,
+};
+
+/* this is for per-channel noise normalization */
+static int apsort(const void *a, const void *b){
+ float f1=**(float**)a;
+ float f2=**(float**)b;
+ return (f1<f2)-(f1>f2);
+}
+
+static void flag_lossless(int limit, float prepoint, float postpoint, float *mdct,
+ float *floor, int *flag, int i, int jn){
+ int j;
+ for(j=0;j<jn;j++){
+ float point = j>=limit-i ? postpoint : prepoint;
+ float r = fabs(mdct[j])/floor[j];
+ if(r<point)
+ flag[j]=0;
+ else
+ flag[j]=1;
+ }
+}
+
+/* Overload/Side effect: On input, the *q vector holds either the
+ quantized energy (for elements with the flag set) or the absolute
+ values of the *r vector (for elements with flag unset). On output,
+ *q holds the quantized energy for all elements */
+static float noise_normalize(vorbis_look_psy *p, int limit, float *r, float *q, float *f, int *flags, float acc, int i, int n, int *out){
+
+ vorbis_info_psy *vi=p->vi;
+ float **sort = alloca(n*sizeof(*sort));
+ int j,count=0;
+ int start = (vi->normal_p ? vi->normal_start-i : n);
+ if(start>n)start=n;
+
+ /* force classic behavior where only energy in the current band is considered */
+ acc=0.f;
+
+ /* still responsible for populating *out where noise norm not in
+ effect. There's no need to [re]populate *q in these areas */
+ for(j=0;j<start;j++){
+ if(!flags || !flags[j]){ /* lossless coupling already quantized.
+ Don't touch; requantizing based on
+ energy would be incorrect. */
+ float ve = q[j]/f[j];
+ if(r[j]<0)
+ out[j] = -rint(sqrt(ve));
+ else
+ out[j] = rint(sqrt(ve));
+ }
+ }
+
+ /* sort magnitudes for noise norm portion of partition */
+ for(;j<n;j++){
+ if(!flags || !flags[j]){ /* can't noise norm elements that have
+ already been loslessly coupled; we can
+ only account for their energy error */
+ float ve = q[j]/f[j];
+ /* Despite all the new, more capable coupling code, for now we
+ implement noise norm as it has been up to this point. Only
+ consider promotions to unit magnitude from 0. In addition
+ the only energy error counted is quantizations to zero. */
+ /* also-- the original point code only applied noise norm at > pointlimit */
+ if(ve<.25f && (!flags || j>=limit-i)){
+ acc += ve;
+ sort[count++]=q+j; /* q is fabs(r) for unflagged element */
+ }else{
+ /* For now: no acc adjustment for nonzero quantization. populate *out and q as this value is final. */
+ if(r[j]<0)
+ out[j] = -rint(sqrt(ve));
+ else
+ out[j] = rint(sqrt(ve));
+ q[j] = out[j]*out[j]*f[j];
+ }
+ }/* else{
+ again, no energy adjustment for error in nonzero quant-- for now
+ }*/
+ }
+
+ if(count){
+ /* noise norm to do */
+ qsort(sort,count,sizeof(*sort),apsort);
+ for(j=0;j<count;j++){
+ int k=sort[j]-q;
+ if(acc>=vi->normal_thresh){
+ out[k]=unitnorm(r[k]);
+ acc-=1.f;
+ q[k]=f[k];
+ }else{
+ out[k]=0;
+ q[k]=0.f;
+ }
+ }
+ }
+
+ return acc;
+}
+
+/* Noise normalization, quantization and coupling are not wholly
+ seperable processes in depth>1 coupling. */
+void _vp_couple_quantize_normalize(int blobno,
+ vorbis_info_psy_global *g,
+ vorbis_look_psy *p,
+ vorbis_info_mapping0 *vi,
+ float **mdct,
+ int **iwork,
+ int *nonzero,
+ int sliding_lowpass,
+ int ch){
+
+ int i;
+ int n = p->n;
+ int partition=(p->vi->normal_p ? p->vi->normal_partition : 16);
+ int limit = g->coupling_pointlimit[p->vi->blockflag][blobno];
+ float prepoint=stereo_threshholds[g->coupling_prepointamp[blobno]];
+ float postpoint=stereo_threshholds[g->coupling_postpointamp[blobno]];
+#if 0
+ float de=0.1*p->m_val; /* a blend of the AoTuV M2 and M3 code here and below */
+#endif
+
+ /* mdct is our raw mdct output, floor not removed. */
+ /* inout passes in the ifloor, passes back quantized result */
+
+ /* unquantized energy (negative indicates amplitude has negative sign) */
+ float **raw = alloca(ch*sizeof(*raw));
+
+ /* dual pupose; quantized energy (if flag set), othersize fabs(raw) */
+ float **quant = alloca(ch*sizeof(*quant));
+
+ /* floor energy */
+ float **floor = alloca(ch*sizeof(*floor));
+
+ /* flags indicating raw/quantized status of elements in raw vector */
+ int **flag = alloca(ch*sizeof(*flag));
+
+ /* non-zero flag working vector */
+ int *nz = alloca(ch*sizeof(*nz));
+
+ /* energy surplus/defecit tracking */
+ float *acc = alloca((ch+vi->coupling_steps)*sizeof(*acc));
+
+ /* The threshold of a stereo is changed with the size of n */
+ if(n > 1000)
+ postpoint=stereo_threshholds_limited[g->coupling_postpointamp[blobno]];
+
+ raw[0] = alloca(ch*partition*sizeof(**raw));
+ quant[0] = alloca(ch*partition*sizeof(**quant));
+ floor[0] = alloca(ch*partition*sizeof(**floor));
+ flag[0] = alloca(ch*partition*sizeof(**flag));
+
+ for(i=1;i<ch;i++){
+ raw[i] = &raw[0][partition*i];
+ quant[i] = &quant[0][partition*i];
+ floor[i] = &floor[0][partition*i];
+ flag[i] = &flag[0][partition*i];
+ }
+ for(i=0;i<ch+vi->coupling_steps;i++)
+ acc[i]=0.f;
+
+ for(i=0;i<n;i+=partition){
+ int k,j,jn = partition > n-i ? n-i : partition;
+ int step,track = 0;
+
+ memcpy(nz,nonzero,sizeof(*nz)*ch);
+
+ /* prefill */
+ memset(flag[0],0,ch*partition*sizeof(**flag));
+ for(k=0;k<ch;k++){
+ int *iout = &iwork[k][i];
+ if(nz[k]){
+
+ for(j=0;j<jn;j++)
+ floor[k][j] = FLOOR1_fromdB_LOOKUP[iout[j]];
+
+ flag_lossless(limit,prepoint,postpoint,&mdct[k][i],floor[k],flag[k],i,jn);
+
+ for(j=0;j<jn;j++){
+ quant[k][j] = raw[k][j] = mdct[k][i+j]*mdct[k][i+j];
+ if(mdct[k][i+j]<0.f) raw[k][j]*=-1.f;
+ floor[k][j]*=floor[k][j];
+ }
+
+ acc[track]=noise_normalize(p,limit,raw[k],quant[k],floor[k],NULL,acc[track],i,jn,iout);
+
+ }else{
+ for(j=0;j<jn;j++){
+ floor[k][j] = 1e-10f;
+ raw[k][j] = 0.f;
+ quant[k][j] = 0.f;
+ flag[k][j] = 0;
+ iout[j]=0;
+ }
+ acc[track]=0.f;
+ }
+ track++;
+ }
+
+ /* coupling */
+ for(step=0;step<vi->coupling_steps;step++){
+ int Mi = vi->coupling_mag[step];
+ int Ai = vi->coupling_ang[step];
+ int *iM = &iwork[Mi][i];
+ int *iA = &iwork[Ai][i];
+ float *reM = raw[Mi];
+ float *reA = raw[Ai];
+ float *qeM = quant[Mi];
+ float *qeA = quant[Ai];
+ float *floorM = floor[Mi];
+ float *floorA = floor[Ai];
+ int *fM = flag[Mi];
+ int *fA = flag[Ai];
+
+ if(nz[Mi] || nz[Ai]){
+ nz[Mi] = nz[Ai] = 1;
+
+ for(j=0;j<jn;j++){
+
+ if(j<sliding_lowpass-i){
+ if(fM[j] || fA[j]){
+ /* lossless coupling */
+
+ reM[j] = fabs(reM[j])+fabs(reA[j]);
+ qeM[j] = qeM[j]+qeA[j];
+ fM[j]=fA[j]=1;
+
+ /* couple iM/iA */
+ {
+ int A = iM[j];
+ int B = iA[j];
+
+ if(abs(A)>abs(B)){
+ iA[j]=(A>0?A-B:B-A);
+ }else{
+ iA[j]=(B>0?A-B:B-A);
+ iM[j]=B;
+ }
+
+ /* collapse two equivalent tuples to one */
+ if(iA[j]>=abs(iM[j])*2){
+ iA[j]= -iA[j];
+ iM[j]= -iM[j];
+ }
+
+ }
+
+ }else{
+ /* lossy (point) coupling */
+ if(j<limit-i){
+ /* dipole */
+ reM[j] += reA[j];
+ qeM[j] = fabs(reM[j]);
+ }else{
+#if 0
+ /* AoTuV */
+ /** @ M2 **
+ The boost problem by the combination of noise normalization and point stereo is eased.
+ However, this is a temporary patch.
+ by Aoyumi @ 2004/04/18
+ */
+ float derate = (1.0 - de*((float)(j-limit+i) / (float)(n-limit)));
+ /* elliptical */
+ if(reM[j]+reA[j]<0){
+ reM[j] = - (qeM[j] = (fabs(reM[j])+fabs(reA[j]))*derate*derate);
+ }else{
+ reM[j] = (qeM[j] = (fabs(reM[j])+fabs(reA[j]))*derate*derate);
+ }
+#else
+ /* elliptical */
+ if(reM[j]+reA[j]<0){
+ reM[j] = - (qeM[j] = fabs(reM[j])+fabs(reA[j]));
+ }else{
+ reM[j] = (qeM[j] = fabs(reM[j])+fabs(reA[j]));
+ }
+#endif
+
+ }
+ reA[j]=qeA[j]=0.f;
+ fA[j]=1;
+ iA[j]=0;
+ }
+ }
+ floorM[j]=floorA[j]=floorM[j]+floorA[j];
+ }
+ /* normalize the resulting mag vector */
+ acc[track]=noise_normalize(p,limit,raw[Mi],quant[Mi],floor[Mi],flag[Mi],acc[track],i,jn,iM);
+ track++;
+ }
+ }
+ }
+
+ for(i=0;i<vi->coupling_steps;i++){
+ /* make sure coupling a zero and a nonzero channel results in two
+ nonzero channels. */
+ if(nonzero[vi->coupling_mag[i]] ||
+ nonzero[vi->coupling_ang[i]]){
+ nonzero[vi->coupling_mag[i]]=1;
+ nonzero[vi->coupling_ang[i]]=1;
+ }
+ }
+}
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: random psychoacoustics (not including preecho)
+ last mod: $Id: psy.h 16946 2010-03-03 16:12:40Z xiphmont $
+
+ ********************************************************************/
+
+#ifndef _V_PSY_H_
+#define _V_PSY_H_
+#include "smallft.h"
+
+#include "backends.h"
+#include "envelope.h"
+
+#ifndef EHMER_MAX
+#define EHMER_MAX 56
+#endif
+
+/* psychoacoustic setup ********************************************/
+#define P_BANDS 17 /* 62Hz to 16kHz */
+#define P_LEVELS 8 /* 30dB to 100dB */
+#define P_LEVEL_0 30. /* 30 dB */
+#define P_NOISECURVES 3
+
+#define NOISE_COMPAND_LEVELS 40
+typedef struct vorbis_info_psy{
+ int blockflag;
+
+ float ath_adjatt;
+ float ath_maxatt;
+
+ float tone_masteratt[P_NOISECURVES];
+ float tone_centerboost;
+ float tone_decay;
+ float tone_abs_limit;
+ float toneatt[P_BANDS];
+
+ int noisemaskp;
+ float noisemaxsupp;
+ float noisewindowlo;
+ float noisewindowhi;
+ int noisewindowlomin;
+ int noisewindowhimin;
+ int noisewindowfixed;
+ float noiseoff[P_NOISECURVES][P_BANDS];
+ float noisecompand[NOISE_COMPAND_LEVELS];
+
+ float max_curve_dB;
+
+ int normal_p;
+ int normal_start;
+ int normal_partition;
+ double normal_thresh;
+} vorbis_info_psy;
+
+typedef struct{
+ int eighth_octave_lines;
+
+ /* for block long/short tuning; encode only */
+ float preecho_thresh[VE_BANDS];
+ float postecho_thresh[VE_BANDS];
+ float stretch_penalty;
+ float preecho_minenergy;
+
+ float ampmax_att_per_sec;
+
+ /* channel coupling config */
+ int coupling_pkHz[PACKETBLOBS];
+ int coupling_pointlimit[2][PACKETBLOBS];
+ int coupling_prepointamp[PACKETBLOBS];
+ int coupling_postpointamp[PACKETBLOBS];
+ int sliding_lowpass[2][PACKETBLOBS];
+
+} vorbis_info_psy_global;
+
+typedef struct {
+ float ampmax;
+ int channels;
+
+ vorbis_info_psy_global *gi;
+ int coupling_pointlimit[2][P_NOISECURVES];
+} vorbis_look_psy_global;
+
+
+typedef struct {
+ int n;
+ struct vorbis_info_psy *vi;
+
+ float ***tonecurves;
+ float **noiseoffset;
+
+ float *ath;
+ long *octave; /* in n.ocshift format */
+ long *bark;
+
+ long firstoc;
+ long shiftoc;
+ int eighth_octave_lines; /* power of two, please */
+ int total_octave_lines;
+ long rate; /* cache it */
+
+ float m_val; /* Masking compensation value */
+
+} vorbis_look_psy;
+
+extern void _vp_psy_init(vorbis_look_psy *p,vorbis_info_psy *vi,
+ vorbis_info_psy_global *gi,int n,long rate);
+extern void _vp_psy_clear(vorbis_look_psy *p);
+extern void *_vi_psy_dup(void *source);
+
+extern void _vi_psy_free(vorbis_info_psy *i);
+extern vorbis_info_psy *_vi_psy_copy(vorbis_info_psy *i);
+
+extern void _vp_noisemask(vorbis_look_psy *p,
+ float *logmdct,
+ float *logmask);
+
+extern void _vp_tonemask(vorbis_look_psy *p,
+ float *logfft,
+ float *logmask,
+ float global_specmax,
+ float local_specmax);
+
+extern void _vp_offset_and_mix(vorbis_look_psy *p,
+ float *noise,
+ float *tone,
+ int offset_select,
+ float *logmask,
+ float *mdct,
+ float *logmdct);
+
+extern float _vp_ampmax_decay(float amp,vorbis_dsp_state *vd);
+
+extern void _vp_couple_quantize_normalize(int blobno,
+ vorbis_info_psy_global *g,
+ vorbis_look_psy *p,
+ vorbis_info_mapping0 *vi,
+ float **mdct,
+ int **iwork,
+ int *nonzero,
+ int sliding_lowpass,
+ int ch);
+
+#endif
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: registry for time, floor, res backends and channel mappings
+ last mod: $Id: registry.c 16227 2009-07-08 06:58:46Z xiphmont $
+
+ ********************************************************************/
+
+#include "vorbis/codec.h"
+#include "codec_internal.h"
+#include "registry.h"
+#include "misc.h"
+/* seems like major overkill now; the backend numbers will grow into
+ the infrastructure soon enough */
+
+extern const vorbis_func_floor floor0_exportbundle;
+extern const vorbis_func_floor floor1_exportbundle;
+extern const vorbis_func_residue residue0_exportbundle;
+extern const vorbis_func_residue residue1_exportbundle;
+extern const vorbis_func_residue residue2_exportbundle;
+extern const vorbis_func_mapping mapping0_exportbundle;
+
+const vorbis_func_floor *const _floor_P[]={
+ &floor0_exportbundle,
+ &floor1_exportbundle,
+};
+
+const vorbis_func_residue *const _residue_P[]={
+ &residue0_exportbundle,
+ &residue1_exportbundle,
+ &residue2_exportbundle,
+};
+
+const vorbis_func_mapping *const _mapping_P[]={
+ &mapping0_exportbundle,
+};
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2007 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: registry for time, floor, res backends and channel mappings
+ last mod: $Id: registry.h 15531 2008-11-24 23:50:06Z xiphmont $
+
+ ********************************************************************/
+
+#ifndef _V_REG_H_
+#define _V_REG_H_
+
+#define VI_TRANSFORMB 1
+#define VI_WINDOWB 1
+#define VI_TIMEB 1
+#define VI_FLOORB 2
+#define VI_RESB 3
+#define VI_MAPB 1
+
+extern const vorbis_func_floor *const _floor_P[];
+extern const vorbis_func_residue *const _residue_P[];
+extern const vorbis_func_mapping *const _mapping_P[];
+
+#endif
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2010 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: residue backend 0, 1 and 2 implementation
+ last mod: $Id: res0.c 17556 2010-10-21 18:25:19Z tterribe $
+
+ ********************************************************************/
+
+/* Slow, slow, slow, simpleminded and did I mention it was slow? The
+ encode/decode loops are coded for clarity and performance is not
+ yet even a nagging little idea lurking in the shadows. Oh and BTW,
+ it's slow. */
+
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <ogg/ogg.h>
+#include "vorbis/codec.h"
+#include "codec_internal.h"
+#include "registry.h"
+#include "codebook.h"
+#include "misc.h"
+#include "os.h"
+
+/*#define TRAIN_RES 1*/
+/*#define TRAIN_RESAUX 1*/
+
+#if defined(TRAIN_RES) || defined (TRAIN_RESAUX)
+#include <stdio.h>
+#endif
+
+typedef struct {
+ vorbis_info_residue0 *info;
+
+ int parts;
+ int stages;
+ codebook *fullbooks;
+ codebook *phrasebook;
+ codebook ***partbooks;
+
+ int partvals;
+ int **decodemap;
+
+ long postbits;
+ long phrasebits;
+ long frames;
+
+#if defined(TRAIN_RES) || defined(TRAIN_RESAUX)
+ int train_seq;
+ long *training_data[8][64];
+ float training_max[8][64];
+ float training_min[8][64];
+ float tmin;
+ float tmax;
+ int submap;
+#endif
+
+} vorbis_look_residue0;
+
+void res0_free_info(vorbis_info_residue *i){
+ vorbis_info_residue0 *info=(vorbis_info_residue0 *)i;
+ if(info){
+ memset(info,0,sizeof(*info));
+ _ogg_free(info);
+ }
+}
+
+void res0_free_look(vorbis_look_residue *i){
+ int j;
+ if(i){
+
+ vorbis_look_residue0 *look=(vorbis_look_residue0 *)i;
+
+#ifdef TRAIN_RES
+ {
+ int j,k,l;
+ for(j=0;j<look->parts;j++){
+ /*fprintf(stderr,"partition %d: ",j);*/
+ for(k=0;k<8;k++)
+ if(look->training_data[k][j]){
+ char buffer[80];
+ FILE *of;
+ codebook *statebook=look->partbooks[j][k];
+
+ /* long and short into the same bucket by current convention */
+ sprintf(buffer,"res_sub%d_part%d_pass%d.vqd",look->submap,j,k);
+ of=fopen(buffer,"a");
+
+ for(l=0;l<statebook->entries;l++)
+ fprintf(of,"%d:%ld\n",l,look->training_data[k][j][l]);
+
+ fclose(of);
+
+ /*fprintf(stderr,"%d(%.2f|%.2f) ",k,
+ look->training_min[k][j],look->training_max[k][j]);*/
+
+ _ogg_free(look->training_data[k][j]);
+ look->training_data[k][j]=NULL;
+ }
+ /*fprintf(stderr,"\n");*/
+ }
+ }
+ fprintf(stderr,"min/max residue: %g::%g\n",look->tmin,look->tmax);
+
+ /*fprintf(stderr,"residue bit usage %f:%f (%f total)\n",
+ (float)look->phrasebits/look->frames,
+ (float)look->postbits/look->frames,
+ (float)(look->postbits+look->phrasebits)/look->frames);*/
+#endif
+
+
+ /*vorbis_info_residue0 *info=look->info;
+
+ fprintf(stderr,
+ "%ld frames encoded in %ld phrasebits and %ld residue bits "
+ "(%g/frame) \n",look->frames,look->phrasebits,
+ look->resbitsflat,
+ (look->phrasebits+look->resbitsflat)/(float)look->frames);
+
+ for(j=0;j<look->parts;j++){
+ long acc=0;
+ fprintf(stderr,"\t[%d] == ",j);
+ for(k=0;k<look->stages;k++)
+ if((info->secondstages[j]>>k)&1){
+ fprintf(stderr,"%ld,",look->resbits[j][k]);
+ acc+=look->resbits[j][k];
+ }
+
+ fprintf(stderr,":: (%ld vals) %1.2fbits/sample\n",look->resvals[j],
+ acc?(float)acc/(look->resvals[j]*info->grouping):0);
+ }
+ fprintf(stderr,"\n");*/
+
+ for(j=0;j<look->parts;j++)
+ if(look->partbooks[j])_ogg_free(look->partbooks[j]);
+ _ogg_free(look->partbooks);
+ for(j=0;j<look->partvals;j++)
+ _ogg_free(look->decodemap[j]);
+ _ogg_free(look->decodemap);
+
+ memset(look,0,sizeof(*look));
+ _ogg_free(look);
+ }
+}
+
+static int ilog(unsigned int v){
+ int ret=0;
+ while(v){
+ ret++;
+ v>>=1;
+ }
+ return(ret);
+}
+
+static int icount(unsigned int v){
+ int ret=0;
+ while(v){
+ ret+=v&1;
+ v>>=1;
+ }
+ return(ret);
+}
+
+
+void res0_pack(vorbis_info_residue *vr,oggpack_buffer *opb){
+ vorbis_info_residue0 *info=(vorbis_info_residue0 *)vr;
+ int j,acc=0;
+ oggpack_write(opb,info->begin,24);
+ oggpack_write(opb,info->end,24);
+
+ oggpack_write(opb,info->grouping-1,24); /* residue vectors to group and
+ code with a partitioned book */
+ oggpack_write(opb,info->partitions-1,6); /* possible partition choices */
+ oggpack_write(opb,info->groupbook,8); /* group huffman book */
+
+ /* secondstages is a bitmask; as encoding progresses pass by pass, a
+ bitmask of one indicates this partition class has bits to write
+ this pass */
+ for(j=0;j<info->partitions;j++){
+ if(ilog(info->secondstages[j])>3){
+ /* yes, this is a minor hack due to not thinking ahead */
+ oggpack_write(opb,info->secondstages[j],3);
+ oggpack_write(opb,1,1);
+ oggpack_write(opb,info->secondstages[j]>>3,5);
+ }else
+ oggpack_write(opb,info->secondstages[j],4); /* trailing zero */
+ acc+=icount(info->secondstages[j]);
+ }
+ for(j=0;j<acc;j++)
+ oggpack_write(opb,info->booklist[j],8);
+
+}
+
+/* vorbis_info is for range checking */
+vorbis_info_residue *res0_unpack(vorbis_info *vi,oggpack_buffer *opb){
+ int j,acc=0;
+ vorbis_info_residue0 *info=_ogg_calloc(1,sizeof(*info));
+ codec_setup_info *ci=vi->codec_setup;
+
+ info->begin=oggpack_read(opb,24);
+ info->end=oggpack_read(opb,24);
+ info->grouping=oggpack_read(opb,24)+1;
+ info->partitions=oggpack_read(opb,6)+1;
+ info->groupbook=oggpack_read(opb,8);
+
+ /* check for premature EOP */
+ if(info->groupbook<0)goto errout;
+
+ for(j=0;j<info->partitions;j++){
+ int cascade=oggpack_read(opb,3);
+ int cflag=oggpack_read(opb,1);
+ if(cflag<0) goto errout;
+ if(cflag){
+ int c=oggpack_read(opb,5);
+ if(c<0) goto errout;
+ cascade|=(c<<3);
+ }
+ info->secondstages[j]=cascade;
+
+ acc+=icount(cascade);
+ }
+ for(j=0;j<acc;j++){
+ int book=oggpack_read(opb,8);
+ if(book<0) goto errout;
+ info->booklist[j]=book;
+ }
+
+ if(info->groupbook>=ci->books)goto errout;
+ for(j=0;j<acc;j++){
+ if(info->booklist[j]>=ci->books)goto errout;
+ if(ci->book_param[info->booklist[j]]->maptype==0)goto errout;
+ }
+
+ /* verify the phrasebook is not specifying an impossible or
+ inconsistent partitioning scheme. */
+ /* modify the phrasebook ranging check from r16327; an early beta
+ encoder had a bug where it used an oversized phrasebook by
+ accident. These files should continue to be playable, but don't
+ allow an exploit */
+ {
+ int entries = ci->book_param[info->groupbook]->entries;
+ int dim = ci->book_param[info->groupbook]->dim;
+ int partvals = 1;
+ if (dim<1) goto errout;
+ while(dim>0){
+ partvals *= info->partitions;
+ if(partvals > entries) goto errout;
+ dim--;
+ }
+ info->partvals = partvals;
+ }
+
+ return(info);
+ errout:
+ res0_free_info(info);
+ return(NULL);
+}
+
+vorbis_look_residue *res0_look(vorbis_dsp_state *vd,
+ vorbis_info_residue *vr){
+ vorbis_info_residue0 *info=(vorbis_info_residue0 *)vr;
+ vorbis_look_residue0 *look=_ogg_calloc(1,sizeof(*look));
+ codec_setup_info *ci=vd->vi->codec_setup;
+
+ int j,k,acc=0;
+ int dim;
+ int maxstage=0;
+ look->info=info;
+
+ look->parts=info->partitions;
+ look->fullbooks=ci->fullbooks;
+ look->phrasebook=ci->fullbooks+info->groupbook;
+ dim=look->phrasebook->dim;
+
+ look->partbooks=_ogg_calloc(look->parts,sizeof(*look->partbooks));
+
+ for(j=0;j<look->parts;j++){
+ int stages=ilog(info->secondstages[j]);
+ if(stages){
+ if(stages>maxstage)maxstage=stages;
+ look->partbooks[j]=_ogg_calloc(stages,sizeof(*look->partbooks[j]));
+ for(k=0;k<stages;k++)
+ if(info->secondstages[j]&(1<<k)){
+ look->partbooks[j][k]=ci->fullbooks+info->booklist[acc++];
+#ifdef TRAIN_RES
+ look->training_data[k][j]=_ogg_calloc(look->partbooks[j][k]->entries,
+ sizeof(***look->training_data));
+#endif
+ }
+ }
+ }
+
+ look->partvals=1;
+ for(j=0;j<dim;j++)
+ look->partvals*=look->parts;
+
+ look->stages=maxstage;
+ look->decodemap=_ogg_malloc(look->partvals*sizeof(*look->decodemap));
+ for(j=0;j<look->partvals;j++){
+ long val=j;
+ long mult=look->partvals/look->parts;
+ look->decodemap[j]=_ogg_malloc(dim*sizeof(*look->decodemap[j]));
+ for(k=0;k<dim;k++){
+ long deco=val/mult;
+ val-=deco*mult;
+ mult/=look->parts;
+ look->decodemap[j][k]=deco;
+ }
+ }
+#if defined(TRAIN_RES) || defined (TRAIN_RESAUX)
+ {
+ static int train_seq=0;
+ look->train_seq=train_seq++;
+ }
+#endif
+ return(look);
+}
+
+/* break an abstraction and copy some code for performance purposes */
+static int local_book_besterror(codebook *book,int *a){
+ int dim=book->dim;
+ int i,j,o;
+ int minval=book->minval;
+ int del=book->delta;
+ int qv=book->quantvals;
+ int ze=(qv>>1);
+ int index=0;
+ /* assumes integer/centered encoder codebook maptype 1 no more than dim 8 */
+ int p[8]={0,0,0,0,0,0,0,0};
+
+ if(del!=1){
+ for(i=0,o=dim;i<dim;i++){
+ int v = (a[--o]-minval+(del>>1))/del;
+ int m = (v<ze ? ((ze-v)<<1)-1 : ((v-ze)<<1));
+ index = index*qv+ (m<0?0:(m>=qv?qv-1:m));
+ p[o]=v*del+minval;
+ }
+ }else{
+ for(i=0,o=dim;i<dim;i++){
+ int v = a[--o]-minval;
+ int m = (v<ze ? ((ze-v)<<1)-1 : ((v-ze)<<1));
+ index = index*qv+ (m<0?0:(m>=qv?qv-1:m));
+ p[o]=v*del+minval;
+ }
+ }
+
+ if(book->c->lengthlist[index]<=0){
+ const static_codebook *c=book->c;
+ int best=-1;
+ /* assumes integer/centered encoder codebook maptype 1 no more than dim 8 */
+ int e[8]={0,0,0,0,0,0,0,0};
+ int maxval = book->minval + book->delta*(book->quantvals-1);
+ for(i=0;i<book->entries;i++){
+ if(c->lengthlist[i]>0){
+ int this=0;
+ for(j=0;j<dim;j++){
+ int val=(e[j]-a[j]);
+ this+=val*val;
+ }
+ if(best==-1 || this<best){
+ memcpy(p,e,sizeof(p));
+ best=this;
+ index=i;
+ }
+ }
+ /* assumes the value patterning created by the tools in vq/ */
+ j=0;
+ while(e[j]>=maxval)
+ e[j++]=0;
+ if(e[j]>=0)
+ e[j]+=book->delta;
+ e[j]= -e[j];
+ }
+ }
+
+ if(index>-1){
+ for(i=0;i<dim;i++)
+ *a++ -= p[i];
+ }
+
+ return(index);
+}
+
+static int _encodepart(oggpack_buffer *opb,int *vec, int n,
+ codebook *book,long *acc){
+ int i,bits=0;
+ int dim=book->dim;
+ int step=n/dim;
+
+ for(i=0;i<step;i++){
+ int entry=local_book_besterror(book,vec+i*dim);
+
+#ifdef TRAIN_RES
+ if(entry>=0)
+ acc[entry]++;
+#endif
+
+ bits+=vorbis_book_encode(book,entry,opb);
+
+ }
+
+ return(bits);
+}
+
+static long **_01class(vorbis_block *vb,vorbis_look_residue *vl,
+ int **in,int ch){
+ long i,j,k;
+ vorbis_look_residue0 *look=(vorbis_look_residue0 *)vl;
+ vorbis_info_residue0 *info=look->info;
+
+ /* move all this setup out later */
+ int samples_per_partition=info->grouping;
+ int possible_partitions=info->partitions;
+ int n=info->end-info->begin;
+
+ int partvals=n/samples_per_partition;
+ long **partword=_vorbis_block_alloc(vb,ch*sizeof(*partword));
+ float scale=100./samples_per_partition;
+
+ /* we find the partition type for each partition of each
+ channel. We'll go back and do the interleaved encoding in a
+ bit. For now, clarity */
+
+ for(i=0;i<ch;i++){
+ partword[i]=_vorbis_block_alloc(vb,n/samples_per_partition*sizeof(*partword[i]));
+ memset(partword[i],0,n/samples_per_partition*sizeof(*partword[i]));
+ }
+
+ for(i=0;i<partvals;i++){
+ int offset=i*samples_per_partition+info->begin;
+ for(j=0;j<ch;j++){
+ int max=0;
+ int ent=0;
+ for(k=0;k<samples_per_partition;k++){
+ if(abs(in[j][offset+k])>max)max=abs(in[j][offset+k]);
+ ent+=abs(in[j][offset+k]);
+ }
+ ent*=scale;
+
+ for(k=0;k<possible_partitions-1;k++)
+ if(max<=info->classmetric1[k] &&
+ (info->classmetric2[k]<0 || ent<info->classmetric2[k]))
+ break;
+
+ partword[j][i]=k;
+ }
+ }
+
+#ifdef TRAIN_RESAUX
+ {
+ FILE *of;
+ char buffer[80];
+
+ for(i=0;i<ch;i++){
+ sprintf(buffer,"resaux_%d.vqd",look->train_seq);
+ of=fopen(buffer,"a");
+ for(j=0;j<partvals;j++)
+ fprintf(of,"%ld, ",partword[i][j]);
+ fprintf(of,"\n");
+ fclose(of);
+ }
+ }
+#endif
+ look->frames++;
+
+ return(partword);
+}
+
+/* designed for stereo or other modes where the partition size is an
+ integer multiple of the number of channels encoded in the current
+ submap */
+static long **_2class(vorbis_block *vb,vorbis_look_residue *vl,int **in,
+ int ch){
+ long i,j,k,l;
+ vorbis_look_residue0 *look=(vorbis_look_residue0 *)vl;
+ vorbis_info_residue0 *info=look->info;
+
+ /* move all this setup out later */
+ int samples_per_partition=info->grouping;
+ int possible_partitions=info->partitions;
+ int n=info->end-info->begin;
+
+ int partvals=n/samples_per_partition;
+ long **partword=_vorbis_block_alloc(vb,sizeof(*partword));
+
+#if defined(TRAIN_RES) || defined (TRAIN_RESAUX)
+ FILE *of;
+ char buffer[80];
+#endif
+
+ partword[0]=_vorbis_block_alloc(vb,partvals*sizeof(*partword[0]));
+ memset(partword[0],0,partvals*sizeof(*partword[0]));
+
+ for(i=0,l=info->begin/ch;i<partvals;i++){
+ int magmax=0;
+ int angmax=0;
+ for(j=0;j<samples_per_partition;j+=ch){
+ if(abs(in[0][l])>magmax)magmax=abs(in[0][l]);
+ for(k=1;k<ch;k++)
+ if(abs(in[k][l])>angmax)angmax=abs(in[k][l]);
+ l++;
+ }
+
+ for(j=0;j<possible_partitions-1;j++)
+ if(magmax<=info->classmetric1[j] &&
+ angmax<=info->classmetric2[j])
+ break;
+
+ partword[0][i]=j;
+
+ }
+
+#ifdef TRAIN_RESAUX
+ sprintf(buffer,"resaux_%d.vqd",look->train_seq);
+ of=fopen(buffer,"a");
+ for(i=0;i<partvals;i++)
+ fprintf(of,"%ld, ",partword[0][i]);
+ fprintf(of,"\n");
+ fclose(of);
+#endif
+
+ look->frames++;
+
+ return(partword);
+}
+
+static int _01forward(oggpack_buffer *opb,
+ vorbis_block *vb,vorbis_look_residue *vl,
+ int **in,int ch,
+ long **partword,
+ int (*encode)(oggpack_buffer *,int *,int,
+ codebook *,long *),
+ int submap){
+ long i,j,k,s;
+ vorbis_look_residue0 *look=(vorbis_look_residue0 *)vl;
+ vorbis_info_residue0 *info=look->info;
+
+#ifdef TRAIN_RES
+ look->submap=submap;
+#endif
+
+ /* move all this setup out later */
+ int samples_per_partition=info->grouping;
+ int possible_partitions=info->partitions;
+ int partitions_per_word=look->phrasebook->dim;
+ int n=info->end-info->begin;
+
+ int partvals=n/samples_per_partition;
+ long resbits[128];
+ long resvals[128];
+
+#ifdef TRAIN_RES
+ for(i=0;i<ch;i++)
+ for(j=info->begin;j<info->end;j++){
+ if(in[i][j]>look->tmax)look->tmax=in[i][j];
+ if(in[i][j]<look->tmin)look->tmin=in[i][j];
+ }
+#endif
+
+ memset(resbits,0,sizeof(resbits));
+ memset(resvals,0,sizeof(resvals));
+
+ /* we code the partition words for each channel, then the residual
+ words for a partition per channel until we've written all the
+ residual words for that partition word. Then write the next
+ partition channel words... */
+
+ for(s=0;s<look->stages;s++){
+
+ for(i=0;i<partvals;){
+
+ /* first we encode a partition codeword for each channel */
+ if(s==0){
+ for(j=0;j<ch;j++){
+ long val=partword[j][i];
+ for(k=1;k<partitions_per_word;k++){
+ val*=possible_partitions;
+ if(i+k<partvals)
+ val+=partword[j][i+k];
+ }
+
+ /* training hack */
+ if(val<look->phrasebook->entries)
+ look->phrasebits+=vorbis_book_encode(look->phrasebook,val,opb);
+#if 0 /*def TRAIN_RES*/
+ else
+ fprintf(stderr,"!");
+#endif
+
+ }
+ }
+
+ /* now we encode interleaved residual values for the partitions */
+ for(k=0;k<partitions_per_word && i<partvals;k++,i++){
+ long offset=i*samples_per_partition+info->begin;
+
+ for(j=0;j<ch;j++){
+ if(s==0)resvals[partword[j][i]]+=samples_per_partition;
+ if(info->secondstages[partword[j][i]]&(1<<s)){
+ codebook *statebook=look->partbooks[partword[j][i]][s];
+ if(statebook){
+ int ret;
+ long *accumulator=NULL;
+
+#ifdef TRAIN_RES
+ accumulator=look->training_data[s][partword[j][i]];
+ {
+ int l;
+ int *samples=in[j]+offset;
+ for(l=0;l<samples_per_partition;l++){
+ if(samples[l]<look->training_min[s][partword[j][i]])
+ look->training_min[s][partword[j][i]]=samples[l];
+ if(samples[l]>look->training_max[s][partword[j][i]])
+ look->training_max[s][partword[j][i]]=samples[l];
+ }
+ }
+#endif
+
+ ret=encode(opb,in[j]+offset,samples_per_partition,
+ statebook,accumulator);
+
+ look->postbits+=ret;
+ resbits[partword[j][i]]+=ret;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ /*{
+ long total=0;
+ long totalbits=0;
+ fprintf(stderr,"%d :: ",vb->mode);
+ for(k=0;k<possible_partitions;k++){
+ fprintf(stderr,"%ld/%1.2g, ",resvals[k],(float)resbits[k]/resvals[k]);
+ total+=resvals[k];
+ totalbits+=resbits[k];
+ }
+
+ fprintf(stderr,":: %ld:%1.2g\n",total,(double)totalbits/total);
+ }*/
+
+ return(0);
+}
+
+/* a truncated packet here just means 'stop working'; it's not an error */
+static int _01inverse(vorbis_block *vb,vorbis_look_residue *vl,
+ float **in,int ch,
+ long (*decodepart)(codebook *, float *,
+ oggpack_buffer *,int)){
+
+ long i,j,k,l,s;
+ vorbis_look_residue0 *look=(vorbis_look_residue0 *)vl;
+ vorbis_info_residue0 *info=look->info;
+
+ /* move all this setup out later */
+ int samples_per_partition=info->grouping;
+ int partitions_per_word=look->phrasebook->dim;
+ int max=vb->pcmend>>1;
+ int end=(info->end<max?info->end:max);
+ int n=end-info->begin;
+
+ if(n>0){
+ int partvals=n/samples_per_partition;
+ int partwords=(partvals+partitions_per_word-1)/partitions_per_word;
+ int ***partword=alloca(ch*sizeof(*partword));
+
+ for(j=0;j<ch;j++)
+ partword[j]=_vorbis_block_alloc(vb,partwords*sizeof(*partword[j]));
+
+ for(s=0;s<look->stages;s++){
+
+ /* each loop decodes on partition codeword containing
+ partitions_per_word partitions */
+ for(i=0,l=0;i<partvals;l++){
+ if(s==0){
+ /* fetch the partition word for each channel */
+ for(j=0;j<ch;j++){
+ int temp=vorbis_book_decode(look->phrasebook,&vb->opb);
+
+ if(temp==-1 || temp>=info->partvals)goto eopbreak;
+ partword[j][l]=look->decodemap[temp];
+ if(partword[j][l]==NULL)goto errout;
+ }
+ }
+
+ /* now we decode residual values for the partitions */
+ for(k=0;k<partitions_per_word && i<partvals;k++,i++)
+ for(j=0;j<ch;j++){
+ long offset=info->begin+i*samples_per_partition;
+ if(info->secondstages[partword[j][l][k]]&(1<<s)){
+ codebook *stagebook=look->partbooks[partword[j][l][k]][s];
+ if(stagebook){
+ if(decodepart(stagebook,in[j]+offset,&vb->opb,
+ samples_per_partition)==-1)goto eopbreak;
+ }
+ }
+ }
+ }
+ }
+ }
+ errout:
+ eopbreak:
+ return(0);
+}
+
+int res0_inverse(vorbis_block *vb,vorbis_look_residue *vl,
+ float **in,int *nonzero,int ch){
+ int i,used=0;
+ for(i=0;i<ch;i++)
+ if(nonzero[i])
+ in[used++]=in[i];
+ if(used)
+ return(_01inverse(vb,vl,in,used,vorbis_book_decodevs_add));
+ else
+ return(0);
+}
+
+int res1_forward(oggpack_buffer *opb,vorbis_block *vb,vorbis_look_residue *vl,
+ int **in,int *nonzero,int ch, long **partword, int submap){
+ int i,used=0;
+ for(i=0;i<ch;i++)
+ if(nonzero[i])
+ in[used++]=in[i];
+
+ if(used){
+ return _01forward(opb,vb,vl,in,used,partword,_encodepart,submap);
+ }else{
+ return(0);
+ }
+}
+
+long **res1_class(vorbis_block *vb,vorbis_look_residue *vl,
+ int **in,int *nonzero,int ch){
+ int i,used=0;
+ for(i=0;i<ch;i++)
+ if(nonzero[i])
+ in[used++]=in[i];
+ if(used)
+ return(_01class(vb,vl,in,used));
+ else
+ return(0);
+}
+
+int res1_inverse(vorbis_block *vb,vorbis_look_residue *vl,
+ float **in,int *nonzero,int ch){
+ int i,used=0;
+ for(i=0;i<ch;i++)
+ if(nonzero[i])
+ in[used++]=in[i];
+ if(used)
+ return(_01inverse(vb,vl,in,used,vorbis_book_decodev_add));
+ else
+ return(0);
+}
+
+long **res2_class(vorbis_block *vb,vorbis_look_residue *vl,
+ int **in,int *nonzero,int ch){
+ int i,used=0;
+ for(i=0;i<ch;i++)
+ if(nonzero[i])used++;
+ if(used)
+ return(_2class(vb,vl,in,ch));
+ else
+ return(0);
+}
+
+/* res2 is slightly more different; all the channels are interleaved
+ into a single vector and encoded. */
+
+int res2_forward(oggpack_buffer *opb,
+ vorbis_block *vb,vorbis_look_residue *vl,
+ int **in,int *nonzero,int ch, long **partword,int submap){
+ long i,j,k,n=vb->pcmend/2,used=0;
+
+ /* don't duplicate the code; use a working vector hack for now and
+ reshape ourselves into a single channel res1 */
+ /* ugly; reallocs for each coupling pass :-( */
+ int *work=_vorbis_block_alloc(vb,ch*n*sizeof(*work));
+ for(i=0;i<ch;i++){
+ int *pcm=in[i];
+ if(nonzero[i])used++;
+ for(j=0,k=i;j<n;j++,k+=ch)
+ work[k]=pcm[j];
+ }
+
+ if(used){
+ return _01forward(opb,vb,vl,&work,1,partword,_encodepart,submap);
+ }else{
+ return(0);
+ }
+}
+
+/* duplicate code here as speed is somewhat more important */
+int res2_inverse(vorbis_block *vb,vorbis_look_residue *vl,
+ float **in,int *nonzero,int ch){
+ long i,k,l,s;
+ vorbis_look_residue0 *look=(vorbis_look_residue0 *)vl;
+ vorbis_info_residue0 *info=look->info;
+
+ /* move all this setup out later */
+ int samples_per_partition=info->grouping;
+ int partitions_per_word=look->phrasebook->dim;
+ int max=(vb->pcmend*ch)>>1;
+ int end=(info->end<max?info->end:max);
+ int n=end-info->begin;
+
+ if(n>0){
+ int partvals=n/samples_per_partition;
+ int partwords=(partvals+partitions_per_word-1)/partitions_per_word;
+ int **partword=_vorbis_block_alloc(vb,partwords*sizeof(*partword));
+
+ for(i=0;i<ch;i++)if(nonzero[i])break;
+ if(i==ch)return(0); /* no nonzero vectors */
+
+ for(s=0;s<look->stages;s++){
+ for(i=0,l=0;i<partvals;l++){
+
+ if(s==0){
+ /* fetch the partition word */
+ int temp=vorbis_book_decode(look->phrasebook,&vb->opb);
+ if(temp==-1 || temp>=info->partvals)goto eopbreak;
+ partword[l]=look->decodemap[temp];
+ if(partword[l]==NULL)goto errout;
+ }
+
+ /* now we decode residual values for the partitions */
+ for(k=0;k<partitions_per_word && i<partvals;k++,i++)
+ if(info->secondstages[partword[l][k]]&(1<<s)){
+ codebook *stagebook=look->partbooks[partword[l][k]][s];
+
+ if(stagebook){
+ if(vorbis_book_decodevv_add(stagebook,in,
+ i*samples_per_partition+info->begin,ch,
+ &vb->opb,samples_per_partition)==-1)
+ goto eopbreak;
+ }
+ }
+ }
+ }
+ }
+ errout:
+ eopbreak:
+ return(0);
+}
+
+
+const vorbis_func_residue residue0_exportbundle={
+ NULL,
+ &res0_unpack,
+ &res0_look,
+ &res0_free_info,
+ &res0_free_look,
+ NULL,
+ NULL,
+ &res0_inverse
+};
+
+const vorbis_func_residue residue1_exportbundle={
+ &res0_pack,
+ &res0_unpack,
+ &res0_look,
+ &res0_free_info,
+ &res0_free_look,
+ &res1_class,
+ &res1_forward,
+ &res1_inverse
+};
+
+const vorbis_func_residue residue2_exportbundle={
+ &res0_pack,
+ &res0_unpack,
+ &res0_look,
+ &res0_free_info,
+ &res0_free_look,
+ &res2_class,
+ &res2_forward,
+ &res2_inverse
+};
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: linear scale -> dB, Bark and Mel scales
+ last mod: $Id: scales.h 16227 2009-07-08 06:58:46Z xiphmont $
+
+ ********************************************************************/
+
+#ifndef _V_SCALES_H_
+#define _V_SCALES_H_
+
+#include <math.h>
+#include "os.h"
+
+#ifdef _MSC_VER
+/* MS Visual Studio doesn't have C99 inline keyword. */
+#define inline __inline
+#endif
+
+/* 20log10(x) */
+#define VORBIS_IEEE_FLOAT32 1
+#ifdef VORBIS_IEEE_FLOAT32
+
+static inline float unitnorm(float x){
+ union {
+ ogg_uint32_t i;
+ float f;
+ } ix;
+ ix.f = x;
+ ix.i = (ix.i & 0x80000000U) | (0x3f800000U);
+ return ix.f;
+}
+
+/* Segher was off (too high) by ~ .3 decibel. Center the conversion correctly. */
+static inline float todB(const float *x){
+ union {
+ ogg_uint32_t i;
+ float f;
+ } ix;
+ ix.f = *x;
+ ix.i = ix.i&0x7fffffff;
+ return (float)(ix.i * 7.17711438e-7f -764.6161886f);
+}
+
+#define todB_nn(x) todB(x)
+
+#else
+
+static float unitnorm(float x){
+ if(x<0)return(-1.f);
+ return(1.f);
+}
+
+#define todB(x) (*(x)==0?-400.f:log(*(x)**(x))*4.34294480f)
+#define todB_nn(x) (*(x)==0.f?-400.f:log(*(x))*8.6858896f)
+
+#endif
+
+#define fromdB(x) (exp((x)*.11512925f))
+
+/* The bark scale equations are approximations, since the original
+ table was somewhat hand rolled. The below are chosen to have the
+ best possible fit to the rolled tables, thus their somewhat odd
+ appearance (these are more accurate and over a longer range than
+ the oft-quoted bark equations found in the texts I have). The
+ approximations are valid from 0 - 30kHz (nyquist) or so.
+
+ all f in Hz, z in Bark */
+
+#define toBARK(n) (13.1f*atan(.00074f*(n))+2.24f*atan((n)*(n)*1.85e-8f)+1e-4f*(n))
+#define fromBARK(z) (102.f*(z)-2.f*pow(z,2.f)+.4f*pow(z,3.f)+pow(1.46f,z)-1.f)
+#define toMEL(n) (log(1.f+(n)*.001f)*1442.695f)
+#define fromMEL(m) (1000.f*exp((m)/1442.695f)-1000.f)
+
+/* Frequency to octave. We arbitrarily declare 63.5 Hz to be octave
+ 0.0 */
+
+#define toOC(n) (log(n)*1.442695f-5.965784f)
+#define fromOC(o) (exp(((o)+5.965784f)*.693147f))
+
+#endif
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: basic shared codebook operations
+ last mod: $Id: sharedbook.c 17030 2010-03-25 06:52:55Z xiphmont $
+
+ ********************************************************************/
+
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+#include <ogg/ogg.h>
+#include "os.h"
+#include "misc.h"
+#include "vorbis/codec.h"
+#include "codebook.h"
+#include "scales.h"
+
+/**** pack/unpack helpers ******************************************/
+int _ilog(unsigned int v){
+ int ret=0;
+ while(v){
+ ret++;
+ v>>=1;
+ }
+ return(ret);
+}
+
+/* 32 bit float (not IEEE; nonnormalized mantissa +
+ biased exponent) : neeeeeee eeemmmmm mmmmmmmm mmmmmmmm
+ Why not IEEE? It's just not that important here. */
+
+#define VQ_FEXP 10
+#define VQ_FMAN 21
+#define VQ_FEXP_BIAS 768 /* bias toward values smaller than 1. */
+
+/* doesn't currently guard under/overflow */
+long _float32_pack(float val){
+ int sign=0;
+ long exp;
+ long mant;
+ if(val<0){
+ sign=0x80000000;
+ val= -val;
+ }
+ exp= floor(log(val)/log(2.f)+.001); /*+epsilon*/
+ mant=rint(ldexp(val,(VQ_FMAN-1)-exp));
+ exp=(exp+VQ_FEXP_BIAS)<<VQ_FMAN;
+
+ return(sign|exp|mant);
+}
+
+float _float32_unpack(long val){
+ double mant=val&0x1fffff;
+ int sign=val&0x80000000;
+ long exp =(val&0x7fe00000L)>>VQ_FMAN;
+ if(sign)mant= -mant;
+ return(ldexp(mant,exp-(VQ_FMAN-1)-VQ_FEXP_BIAS));
+}
+
+/* given a list of word lengths, generate a list of codewords. Works
+ for length ordered or unordered, always assigns the lowest valued
+ codewords first. Extended to handle unused entries (length 0) */
+ogg_uint32_t *_make_words(long *l,long n,long sparsecount){
+ long i,j,count=0;
+ ogg_uint32_t marker[33];
+ ogg_uint32_t *r=_ogg_malloc((sparsecount?sparsecount:n)*sizeof(*r));
+ memset(marker,0,sizeof(marker));
+
+ for(i=0;i<n;i++){
+ long length=l[i];
+ if(length>0){
+ ogg_uint32_t entry=marker[length];
+
+ /* when we claim a node for an entry, we also claim the nodes
+ below it (pruning off the imagined tree that may have dangled
+ from it) as well as blocking the use of any nodes directly
+ above for leaves */
+
+ /* update ourself */
+ if(length<32 && (entry>>length)){
+ /* error condition; the lengths must specify an overpopulated tree */
+ _ogg_free(r);
+ return(NULL);
+ }
+ r[count++]=entry;
+
+ /* Look to see if the next shorter marker points to the node
+ above. if so, update it and repeat. */
+ {
+ for(j=length;j>0;j--){
+
+ if(marker[j]&1){
+ /* have to jump branches */
+ if(j==1)
+ marker[1]++;
+ else
+ marker[j]=marker[j-1]<<1;
+ break; /* invariant says next upper marker would already
+ have been moved if it was on the same path */
+ }
+ marker[j]++;
+ }
+ }
+
+ /* prune the tree; the implicit invariant says all the longer
+ markers were dangling from our just-taken node. Dangle them
+ from our *new* node. */
+ for(j=length+1;j<33;j++)
+ if((marker[j]>>1) == entry){
+ entry=marker[j];
+ marker[j]=marker[j-1]<<1;
+ }else
+ break;
+ }else
+ if(sparsecount==0)count++;
+ }
+
+ /* sanity check the huffman tree; an underpopulated tree must be
+ rejected. The only exception is the one-node pseudo-nil tree,
+ which appears to be underpopulated because the tree doesn't
+ really exist; there's only one possible 'codeword' or zero bits,
+ but the above tree-gen code doesn't mark that. */
+ if(sparsecount != 1){
+ for(i=1;i<33;i++)
+ if(marker[i] & (0xffffffffUL>>(32-i))){
+ _ogg_free(r);
+ return(NULL);
+ }
+ }
+
+ /* bitreverse the words because our bitwise packer/unpacker is LSb
+ endian */
+ for(i=0,count=0;i<n;i++){
+ ogg_uint32_t temp=0;
+ for(j=0;j<l[i];j++){
+ temp<<=1;
+ temp|=(r[count]>>j)&1;
+ }
+
+ if(sparsecount){
+ if(l[i])
+ r[count++]=temp;
+ }else
+ r[count++]=temp;
+ }
+
+ return(r);
+}
+
+/* there might be a straightforward one-line way to do the below
+ that's portable and totally safe against roundoff, but I haven't
+ thought of it. Therefore, we opt on the side of caution */
+long _book_maptype1_quantvals(const static_codebook *b){
+ long vals=floor(pow((float)b->entries,1.f/b->dim));
+
+ /* the above *should* be reliable, but we'll not assume that FP is
+ ever reliable when bitstream sync is at stake; verify via integer
+ means that vals really is the greatest value of dim for which
+ vals^b->bim <= b->entries */
+ /* treat the above as an initial guess */
+ while(1){
+ long acc=1;
+ long acc1=1;
+ int i;
+ for(i=0;i<b->dim;i++){
+ acc*=vals;
+ acc1*=vals+1;
+ }
+ if(acc<=b->entries && acc1>b->entries){
+ return(vals);
+ }else{
+ if(acc>b->entries){
+ vals--;
+ }else{
+ vals++;
+ }
+ }
+ }
+}
+
+/* unpack the quantized list of values for encode/decode ***********/
+/* we need to deal with two map types: in map type 1, the values are
+ generated algorithmically (each column of the vector counts through
+ the values in the quant vector). in map type 2, all the values came
+ in in an explicit list. Both value lists must be unpacked */
+float *_book_unquantize(const static_codebook *b,int n,int *sparsemap){
+ long j,k,count=0;
+ if(b->maptype==1 || b->maptype==2){
+ int quantvals;
+ float mindel=_float32_unpack(b->q_min);
+ float delta=_float32_unpack(b->q_delta);
+ float *r=_ogg_calloc(n*b->dim,sizeof(*r));
+
+ /* maptype 1 and 2 both use a quantized value vector, but
+ different sizes */
+ switch(b->maptype){
+ case 1:
+ /* most of the time, entries%dimensions == 0, but we need to be
+ well defined. We define that the possible vales at each
+ scalar is values == entries/dim. If entries%dim != 0, we'll
+ have 'too few' values (values*dim<entries), which means that
+ we'll have 'left over' entries; left over entries use zeroed
+ values (and are wasted). So don't generate codebooks like
+ that */
+ quantvals=_book_maptype1_quantvals(b);
+ for(j=0;j<b->entries;j++){
+ if((sparsemap && b->lengthlist[j]) || !sparsemap){
+ float last=0.f;
+ int indexdiv=1;
+ for(k=0;k<b->dim;k++){
+ int index= (j/indexdiv)%quantvals;
+ float val=b->quantlist[index];
+ val=fabs(val)*delta+mindel+last;
+ if(b->q_sequencep)last=val;
+ if(sparsemap)
+ r[sparsemap[count]*b->dim+k]=val;
+ else
+ r[count*b->dim+k]=val;
+ indexdiv*=quantvals;
+ }
+ count++;
+ }
+
+ }
+ break;
+ case 2:
+ for(j=0;j<b->entries;j++){
+ if((sparsemap && b->lengthlist[j]) || !sparsemap){
+ float last=0.f;
+
+ for(k=0;k<b->dim;k++){
+ float val=b->quantlist[j*b->dim+k];
+ val=fabs(val)*delta+mindel+last;
+ if(b->q_sequencep)last=val;
+ if(sparsemap)
+ r[sparsemap[count]*b->dim+k]=val;
+ else
+ r[count*b->dim+k]=val;
+ }
+ count++;
+ }
+ }
+ break;
+ }
+
+ return(r);
+ }
+ return(NULL);
+}
+
+void vorbis_staticbook_destroy(static_codebook *b){
+ if(b->allocedp){
+ if(b->quantlist)_ogg_free(b->quantlist);
+ if(b->lengthlist)_ogg_free(b->lengthlist);
+ memset(b,0,sizeof(*b));
+ _ogg_free(b);
+ } /* otherwise, it is in static memory */
+}
+
+void vorbis_book_clear(codebook *b){
+ /* static book is not cleared; we're likely called on the lookup and
+ the static codebook belongs to the info struct */
+ if(b->valuelist)_ogg_free(b->valuelist);
+ if(b->codelist)_ogg_free(b->codelist);
+
+ if(b->dec_index)_ogg_free(b->dec_index);
+ if(b->dec_codelengths)_ogg_free(b->dec_codelengths);
+ if(b->dec_firsttable)_ogg_free(b->dec_firsttable);
+
+ memset(b,0,sizeof(*b));
+}
+
+int vorbis_book_init_encode(codebook *c,const static_codebook *s){
+
+ memset(c,0,sizeof(*c));
+ c->c=s;
+ c->entries=s->entries;
+ c->used_entries=s->entries;
+ c->dim=s->dim;
+ c->codelist=_make_words(s->lengthlist,s->entries,0);
+ /*c->valuelist=_book_unquantize(s,s->entries,NULL);*/
+ c->quantvals=_book_maptype1_quantvals(s);
+ c->minval=(int)rint(_float32_unpack(s->q_min));
+ c->delta=(int)rint(_float32_unpack(s->q_delta));
+
+ return(0);
+}
+
+static ogg_uint32_t bitreverse(ogg_uint32_t x){
+ x= ((x>>16)&0x0000ffffUL) | ((x<<16)&0xffff0000UL);
+ x= ((x>> 8)&0x00ff00ffUL) | ((x<< 8)&0xff00ff00UL);
+ x= ((x>> 4)&0x0f0f0f0fUL) | ((x<< 4)&0xf0f0f0f0UL);
+ x= ((x>> 2)&0x33333333UL) | ((x<< 2)&0xccccccccUL);
+ return((x>> 1)&0x55555555UL) | ((x<< 1)&0xaaaaaaaaUL);
+}
+
+static int sort32a(const void *a,const void *b){
+ return ( **(ogg_uint32_t **)a>**(ogg_uint32_t **)b)-
+ ( **(ogg_uint32_t **)a<**(ogg_uint32_t **)b);
+}
+
+/* decode codebook arrangement is more heavily optimized than encode */
+int vorbis_book_init_decode(codebook *c,const static_codebook *s){
+ int i,j,n=0,tabn;
+ int *sortindex;
+ memset(c,0,sizeof(*c));
+
+ /* count actually used entries */
+ for(i=0;i<s->entries;i++)
+ if(s->lengthlist[i]>0)
+ n++;
+
+ c->entries=s->entries;
+ c->used_entries=n;
+ c->dim=s->dim;
+
+ if(n>0){
+
+ /* two different remappings go on here.
+
+ First, we collapse the likely sparse codebook down only to
+ actually represented values/words. This collapsing needs to be
+ indexed as map-valueless books are used to encode original entry
+ positions as integers.
+
+ Second, we reorder all vectors, including the entry index above,
+ by sorted bitreversed codeword to allow treeless decode. */
+
+ /* perform sort */
+ ogg_uint32_t *codes=_make_words(s->lengthlist,s->entries,c->used_entries);
+ ogg_uint32_t **codep=alloca(sizeof(*codep)*n);
+
+ if(codes==NULL)goto err_out;
+
+ for(i=0;i<n;i++){
+ codes[i]=bitreverse(codes[i]);
+ codep[i]=codes+i;
+ }
+
+ qsort(codep,n,sizeof(*codep),sort32a);
+
+ sortindex=alloca(n*sizeof(*sortindex));
+ c->codelist=_ogg_malloc(n*sizeof(*c->codelist));
+ /* the index is a reverse index */
+ for(i=0;i<n;i++){
+ int position=codep[i]-codes;
+ sortindex[position]=i;
+ }
+
+ for(i=0;i<n;i++)
+ c->codelist[sortindex[i]]=codes[i];
+ _ogg_free(codes);
+
+
+ c->valuelist=_book_unquantize(s,n,sortindex);
+ c->dec_index=_ogg_malloc(n*sizeof(*c->dec_index));
+
+ for(n=0,i=0;i<s->entries;i++)
+ if(s->lengthlist[i]>0)
+ c->dec_index[sortindex[n++]]=i;
+
+ c->dec_codelengths=_ogg_malloc(n*sizeof(*c->dec_codelengths));
+ for(n=0,i=0;i<s->entries;i++)
+ if(s->lengthlist[i]>0)
+ c->dec_codelengths[sortindex[n++]]=s->lengthlist[i];
+
+ c->dec_firsttablen=_ilog(c->used_entries)-4; /* this is magic */
+ if(c->dec_firsttablen<5)c->dec_firsttablen=5;
+ if(c->dec_firsttablen>8)c->dec_firsttablen=8;
+
+ tabn=1<<c->dec_firsttablen;
+ c->dec_firsttable=_ogg_calloc(tabn,sizeof(*c->dec_firsttable));
+ c->dec_maxlength=0;
+
+ for(i=0;i<n;i++){
+ if(c->dec_maxlength<c->dec_codelengths[i])
+ c->dec_maxlength=c->dec_codelengths[i];
+ if(c->dec_codelengths[i]<=c->dec_firsttablen){
+ ogg_uint32_t orig=bitreverse(c->codelist[i]);
+ for(j=0;j<(1<<(c->dec_firsttablen-c->dec_codelengths[i]));j++)
+ c->dec_firsttable[orig|(j<<c->dec_codelengths[i])]=i+1;
+ }
+ }
+
+ /* now fill in 'unused' entries in the firsttable with hi/lo search
+ hints for the non-direct-hits */
+ {
+ ogg_uint32_t mask=0xfffffffeUL<<(31-c->dec_firsttablen);
+ long lo=0,hi=0;
+
+ for(i=0;i<tabn;i++){
+ ogg_uint32_t word=i<<(32-c->dec_firsttablen);
+ if(c->dec_firsttable[bitreverse(word)]==0){
+ while((lo+1)<n && c->codelist[lo+1]<=word)lo++;
+ while( hi<n && word>=(c->codelist[hi]&mask))hi++;
+
+ /* we only actually have 15 bits per hint to play with here.
+ In order to overflow gracefully (nothing breaks, efficiency
+ just drops), encode as the difference from the extremes. */
+ {
+ unsigned long loval=lo;
+ unsigned long hival=n-hi;
+
+ if(loval>0x7fff)loval=0x7fff;
+ if(hival>0x7fff)hival=0x7fff;
+ c->dec_firsttable[bitreverse(word)]=
+ 0x80000000UL | (loval<<15) | hival;
+ }
+ }
+ }
+ }
+ }
+
+ return(0);
+ err_out:
+ vorbis_book_clear(c);
+ return(-1);
+}
+
+long vorbis_book_codeword(codebook *book,int entry){
+ if(book->c) /* only use with encode; decode optimizations are
+ allowed to break this */
+ return book->codelist[entry];
+ return -1;
+}
+
+long vorbis_book_codelen(codebook *book,int entry){
+ if(book->c) /* only use with encode; decode optimizations are
+ allowed to break this */
+ return book->c->lengthlist[entry];
+ return -1;
+}
+
+#ifdef _V_SELFTEST
+
+/* Unit tests of the dequantizer; this stuff will be OK
+ cross-platform, I simply want to be sure that special mapping cases
+ actually work properly; a bug could go unnoticed for a while */
+
+#include <stdio.h>
+
+/* cases:
+
+ no mapping
+ full, explicit mapping
+ algorithmic mapping
+
+ nonsequential
+ sequential
+*/
+
+static long full_quantlist1[]={0,1,2,3, 4,5,6,7, 8,3,6,1};
+static long partial_quantlist1[]={0,7,2};
+
+/* no mapping */
+static_codebook test1={
+ 4,16,
+ NULL,
+ 0,
+ 0,0,0,0,
+ NULL,
+ 0
+};
+static float *test1_result=NULL;
+
+/* linear, full mapping, nonsequential */
+static_codebook test2={
+ 4,3,
+ NULL,
+ 2,
+ -533200896,1611661312,4,0,
+ full_quantlist1,
+ 0
+};
+static float test2_result[]={-3,-2,-1,0, 1,2,3,4, 5,0,3,-2};
+
+/* linear, full mapping, sequential */
+static_codebook test3={
+ 4,3,
+ NULL,
+ 2,
+ -533200896,1611661312,4,1,
+ full_quantlist1,
+ 0
+};
+static float test3_result[]={-3,-5,-6,-6, 1,3,6,10, 5,5,8,6};
+
+/* linear, algorithmic mapping, nonsequential */
+static_codebook test4={
+ 3,27,
+ NULL,
+ 1,
+ -533200896,1611661312,4,0,
+ partial_quantlist1,
+ 0
+};
+static float test4_result[]={-3,-3,-3, 4,-3,-3, -1,-3,-3,
+ -3, 4,-3, 4, 4,-3, -1, 4,-3,
+ -3,-1,-3, 4,-1,-3, -1,-1,-3,
+ -3,-3, 4, 4,-3, 4, -1,-3, 4,
+ -3, 4, 4, 4, 4, 4, -1, 4, 4,
+ -3,-1, 4, 4,-1, 4, -1,-1, 4,
+ -3,-3,-1, 4,-3,-1, -1,-3,-1,
+ -3, 4,-1, 4, 4,-1, -1, 4,-1,
+ -3,-1,-1, 4,-1,-1, -1,-1,-1};
+
+/* linear, algorithmic mapping, sequential */
+static_codebook test5={
+ 3,27,
+ NULL,
+ 1,
+ -533200896,1611661312,4,1,
+ partial_quantlist1,
+ 0
+};
+static float test5_result[]={-3,-6,-9, 4, 1,-2, -1,-4,-7,
+ -3, 1,-2, 4, 8, 5, -1, 3, 0,
+ -3,-4,-7, 4, 3, 0, -1,-2,-5,
+ -3,-6,-2, 4, 1, 5, -1,-4, 0,
+ -3, 1, 5, 4, 8,12, -1, 3, 7,
+ -3,-4, 0, 4, 3, 7, -1,-2, 2,
+ -3,-6,-7, 4, 1, 0, -1,-4,-5,
+ -3, 1, 0, 4, 8, 7, -1, 3, 2,
+ -3,-4,-5, 4, 3, 2, -1,-2,-3};
+
+void run_test(static_codebook *b,float *comp){
+ float *out=_book_unquantize(b,b->entries,NULL);
+ int i;
+
+ if(comp){
+ if(!out){
+ fprintf(stderr,"_book_unquantize incorrectly returned NULL\n");
+ exit(1);
+ }
+
+ for(i=0;i<b->entries*b->dim;i++)
+ if(fabs(out[i]-comp[i])>.0001){
+ fprintf(stderr,"disagreement in unquantized and reference data:\n"
+ "position %d, %g != %g\n",i,out[i],comp[i]);
+ exit(1);
+ }
+
+ }else{
+ if(out){
+ fprintf(stderr,"_book_unquantize returned a value array: \n"
+ " correct result should have been NULL\n");
+ exit(1);
+ }
+ }
+}
+
+int main(){
+ /* run the nine dequant tests, and compare to the hand-rolled results */
+ fprintf(stderr,"Dequant test 1... ");
+ run_test(&test1,test1_result);
+ fprintf(stderr,"OK\nDequant test 2... ");
+ run_test(&test2,test2_result);
+ fprintf(stderr,"OK\nDequant test 3... ");
+ run_test(&test3,test3_result);
+ fprintf(stderr,"OK\nDequant test 4... ");
+ run_test(&test4,test4_result);
+ fprintf(stderr,"OK\nDequant test 5... ");
+ run_test(&test5,test5_result);
+ fprintf(stderr,"OK\n\n");
+
+ return(0);
+}
+
+#endif
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: *unnormalized* fft transform
+ last mod: $Id: smallft.c 16227 2009-07-08 06:58:46Z xiphmont $
+
+ ********************************************************************/
+
+/* FFT implementation from OggSquish, minus cosine transforms,
+ * minus all but radix 2/4 case. In Vorbis we only need this
+ * cut-down version.
+ *
+ * To do more than just power-of-two sized vectors, see the full
+ * version I wrote for NetLib.
+ *
+ * Note that the packing is a little strange; rather than the FFT r/i
+ * packing following R_0, I_n, R_1, I_1, R_2, I_2 ... R_n-1, I_n-1,
+ * it follows R_0, R_1, I_1, R_2, I_2 ... R_n-1, I_n-1, I_n like the
+ * FORTRAN version
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include "smallft.h"
+#include "os.h"
+#include "misc.h"
+
+static void drfti1(int n, float *wa, int *ifac){
+ static int ntryh[4] = { 4,2,3,5 };
+ static float tpi = 6.28318530717958648f;
+ float arg,argh,argld,fi;
+ int ntry=0,i,j=-1;
+ int k1, l1, l2, ib;
+ int ld, ii, ip, is, nq, nr;
+ int ido, ipm, nfm1;
+ int nl=n;
+ int nf=0;
+
+ L101:
+ j++;
+ if (j < 4)
+ ntry=ntryh[j];
+ else
+ ntry+=2;
+
+ L104:
+ nq=nl/ntry;
+ nr=nl-ntry*nq;
+ if (nr!=0) goto L101;
+
+ nf++;
+ ifac[nf+1]=ntry;
+ nl=nq;
+ if(ntry!=2)goto L107;
+ if(nf==1)goto L107;
+
+ for (i=1;i<nf;i++){
+ ib=nf-i+1;
+ ifac[ib+1]=ifac[ib];
+ }
+ ifac[2] = 2;
+
+ L107:
+ if(nl!=1)goto L104;
+ ifac[0]=n;
+ ifac[1]=nf;
+ argh=tpi/n;
+ is=0;
+ nfm1=nf-1;
+ l1=1;
+
+ if(nfm1==0)return;
+
+ for (k1=0;k1<nfm1;k1++){
+ ip=ifac[k1+2];
+ ld=0;
+ l2=l1*ip;
+ ido=n/l2;
+ ipm=ip-1;
+
+ for (j=0;j<ipm;j++){
+ ld+=l1;
+ i=is;
+ argld=(float)ld*argh;
+ fi=0.f;
+ for (ii=2;ii<ido;ii+=2){
+ fi+=1.f;
+ arg=fi*argld;
+ wa[i++]=cos(arg);
+ wa[i++]=sin(arg);
+ }
+ is+=ido;
+ }
+ l1=l2;
+ }
+}
+
+static void fdrffti(int n, float *wsave, int *ifac){
+
+ if (n == 1) return;
+ drfti1(n, wsave+n, ifac);
+}
+
+static void dradf2(int ido,int l1,float *cc,float *ch,float *wa1){
+ int i,k;
+ float ti2,tr2;
+ int t0,t1,t2,t3,t4,t5,t6;
+
+ t1=0;
+ t0=(t2=l1*ido);
+ t3=ido<<1;
+ for(k=0;k<l1;k++){
+ ch[t1<<1]=cc[t1]+cc[t2];
+ ch[(t1<<1)+t3-1]=cc[t1]-cc[t2];
+ t1+=ido;
+ t2+=ido;
+ }
+
+ if(ido<2)return;
+ if(ido==2)goto L105;
+
+ t1=0;
+ t2=t0;
+ for(k=0;k<l1;k++){
+ t3=t2;
+ t4=(t1<<1)+(ido<<1);
+ t5=t1;
+ t6=t1+t1;
+ for(i=2;i<ido;i+=2){
+ t3+=2;
+ t4-=2;
+ t5+=2;
+ t6+=2;
+ tr2=wa1[i-2]*cc[t3-1]+wa1[i-1]*cc[t3];
+ ti2=wa1[i-2]*cc[t3]-wa1[i-1]*cc[t3-1];
+ ch[t6]=cc[t5]+ti2;
+ ch[t4]=ti2-cc[t5];
+ ch[t6-1]=cc[t5-1]+tr2;
+ ch[t4-1]=cc[t5-1]-tr2;
+ }
+ t1+=ido;
+ t2+=ido;
+ }
+
+ if(ido%2==1)return;
+
+ L105:
+ t3=(t2=(t1=ido)-1);
+ t2+=t0;
+ for(k=0;k<l1;k++){
+ ch[t1]=-cc[t2];
+ ch[t1-1]=cc[t3];
+ t1+=ido<<1;
+ t2+=ido;
+ t3+=ido;
+ }
+}
+
+static void dradf4(int ido,int l1,float *cc,float *ch,float *wa1,
+ float *wa2,float *wa3){
+ static float hsqt2 = .70710678118654752f;
+ int i,k,t0,t1,t2,t3,t4,t5,t6;
+ float ci2,ci3,ci4,cr2,cr3,cr4,ti1,ti2,ti3,ti4,tr1,tr2,tr3,tr4;
+ t0=l1*ido;
+
+ t1=t0;
+ t4=t1<<1;
+ t2=t1+(t1<<1);
+ t3=0;
+
+ for(k=0;k<l1;k++){
+ tr1=cc[t1]+cc[t2];
+ tr2=cc[t3]+cc[t4];
+
+ ch[t5=t3<<2]=tr1+tr2;
+ ch[(ido<<2)+t5-1]=tr2-tr1;
+ ch[(t5+=(ido<<1))-1]=cc[t3]-cc[t4];
+ ch[t5]=cc[t2]-cc[t1];
+
+ t1+=ido;
+ t2+=ido;
+ t3+=ido;
+ t4+=ido;
+ }
+
+ if(ido<2)return;
+ if(ido==2)goto L105;
+
+
+ t1=0;
+ for(k=0;k<l1;k++){
+ t2=t1;
+ t4=t1<<2;
+ t5=(t6=ido<<1)+t4;
+ for(i=2;i<ido;i+=2){
+ t3=(t2+=2);
+ t4+=2;
+ t5-=2;
+
+ t3+=t0;
+ cr2=wa1[i-2]*cc[t3-1]+wa1[i-1]*cc[t3];
+ ci2=wa1[i-2]*cc[t3]-wa1[i-1]*cc[t3-1];
+ t3+=t0;
+ cr3=wa2[i-2]*cc[t3-1]+wa2[i-1]*cc[t3];
+ ci3=wa2[i-2]*cc[t3]-wa2[i-1]*cc[t3-1];
+ t3+=t0;
+ cr4=wa3[i-2]*cc[t3-1]+wa3[i-1]*cc[t3];
+ ci4=wa3[i-2]*cc[t3]-wa3[i-1]*cc[t3-1];
+
+ tr1=cr2+cr4;
+ tr4=cr4-cr2;
+ ti1=ci2+ci4;
+ ti4=ci2-ci4;
+
+ ti2=cc[t2]+ci3;
+ ti3=cc[t2]-ci3;
+ tr2=cc[t2-1]+cr3;
+ tr3=cc[t2-1]-cr3;
+
+ ch[t4-1]=tr1+tr2;
+ ch[t4]=ti1+ti2;
+
+ ch[t5-1]=tr3-ti4;
+ ch[t5]=tr4-ti3;
+
+ ch[t4+t6-1]=ti4+tr3;
+ ch[t4+t6]=tr4+ti3;
+
+ ch[t5+t6-1]=tr2-tr1;
+ ch[t5+t6]=ti1-ti2;
+ }
+ t1+=ido;
+ }
+ if(ido&1)return;
+
+ L105:
+
+ t2=(t1=t0+ido-1)+(t0<<1);
+ t3=ido<<2;
+ t4=ido;
+ t5=ido<<1;
+ t6=ido;
+
+ for(k=0;k<l1;k++){
+ ti1=-hsqt2*(cc[t1]+cc[t2]);
+ tr1=hsqt2*(cc[t1]-cc[t2]);
+
+ ch[t4-1]=tr1+cc[t6-1];
+ ch[t4+t5-1]=cc[t6-1]-tr1;
+
+ ch[t4]=ti1-cc[t1+t0];
+ ch[t4+t5]=ti1+cc[t1+t0];
+
+ t1+=ido;
+ t2+=ido;
+ t4+=t3;
+ t6+=ido;
+ }
+}
+
+static void dradfg(int ido,int ip,int l1,int idl1,float *cc,float *c1,
+ float *c2,float *ch,float *ch2,float *wa){
+
+ static float tpi=6.283185307179586f;
+ int idij,ipph,i,j,k,l,ic,ik,is;
+ int t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10;
+ float dc2,ai1,ai2,ar1,ar2,ds2;
+ int nbd;
+ float dcp,arg,dsp,ar1h,ar2h;
+ int idp2,ipp2;
+
+ arg=tpi/(float)ip;
+ dcp=cos(arg);
+ dsp=sin(arg);
+ ipph=(ip+1)>>1;
+ ipp2=ip;
+ idp2=ido;
+ nbd=(ido-1)>>1;
+ t0=l1*ido;
+ t10=ip*ido;
+
+ if(ido==1)goto L119;
+ for(ik=0;ik<idl1;ik++)ch2[ik]=c2[ik];
+
+ t1=0;
+ for(j=1;j<ip;j++){
+ t1+=t0;
+ t2=t1;
+ for(k=0;k<l1;k++){
+ ch[t2]=c1[t2];
+ t2+=ido;
+ }
+ }
+
+ is=-ido;
+ t1=0;
+ if(nbd>l1){
+ for(j=1;j<ip;j++){
+ t1+=t0;
+ is+=ido;
+ t2= -ido+t1;
+ for(k=0;k<l1;k++){
+ idij=is-1;
+ t2+=ido;
+ t3=t2;
+ for(i=2;i<ido;i+=2){
+ idij+=2;
+ t3+=2;
+ ch[t3-1]=wa[idij-1]*c1[t3-1]+wa[idij]*c1[t3];
+ ch[t3]=wa[idij-1]*c1[t3]-wa[idij]*c1[t3-1];
+ }
+ }
+ }
+ }else{
+
+ for(j=1;j<ip;j++){
+ is+=ido;
+ idij=is-1;
+ t1+=t0;
+ t2=t1;
+ for(i=2;i<ido;i+=2){
+ idij+=2;
+ t2+=2;
+ t3=t2;
+ for(k=0;k<l1;k++){
+ ch[t3-1]=wa[idij-1]*c1[t3-1]+wa[idij]*c1[t3];
+ ch[t3]=wa[idij-1]*c1[t3]-wa[idij]*c1[t3-1];
+ t3+=ido;
+ }
+ }
+ }
+ }
+
+ t1=0;
+ t2=ipp2*t0;
+ if(nbd<l1){
+ for(j=1;j<ipph;j++){
+ t1+=t0;
+ t2-=t0;
+ t3=t1;
+ t4=t2;
+ for(i=2;i<ido;i+=2){
+ t3+=2;
+ t4+=2;
+ t5=t3-ido;
+ t6=t4-ido;
+ for(k=0;k<l1;k++){
+ t5+=ido;
+ t6+=ido;
+ c1[t5-1]=ch[t5-1]+ch[t6-1];
+ c1[t6-1]=ch[t5]-ch[t6];
+ c1[t5]=ch[t5]+ch[t6];
+ c1[t6]=ch[t6-1]-ch[t5-1];
+ }
+ }
+ }
+ }else{
+ for(j=1;j<ipph;j++){
+ t1+=t0;
+ t2-=t0;
+ t3=t1;
+ t4=t2;
+ for(k=0;k<l1;k++){
+ t5=t3;
+ t6=t4;
+ for(i=2;i<ido;i+=2){
+ t5+=2;
+ t6+=2;
+ c1[t5-1]=ch[t5-1]+ch[t6-1];
+ c1[t6-1]=ch[t5]-ch[t6];
+ c1[t5]=ch[t5]+ch[t6];
+ c1[t6]=ch[t6-1]-ch[t5-1];
+ }
+ t3+=ido;
+ t4+=ido;
+ }
+ }
+ }
+
+L119:
+ for(ik=0;ik<idl1;ik++)c2[ik]=ch2[ik];
+
+ t1=0;
+ t2=ipp2*idl1;
+ for(j=1;j<ipph;j++){
+ t1+=t0;
+ t2-=t0;
+ t3=t1-ido;
+ t4=t2-ido;
+ for(k=0;k<l1;k++){
+ t3+=ido;
+ t4+=ido;
+ c1[t3]=ch[t3]+ch[t4];
+ c1[t4]=ch[t4]-ch[t3];
+ }
+ }
+
+ ar1=1.f;
+ ai1=0.f;
+ t1=0;
+ t2=ipp2*idl1;
+ t3=(ip-1)*idl1;
+ for(l=1;l<ipph;l++){
+ t1+=idl1;
+ t2-=idl1;
+ ar1h=dcp*ar1-dsp*ai1;
+ ai1=dcp*ai1+dsp*ar1;
+ ar1=ar1h;
+ t4=t1;
+ t5=t2;
+ t6=t3;
+ t7=idl1;
+
+ for(ik=0;ik<idl1;ik++){
+ ch2[t4++]=c2[ik]+ar1*c2[t7++];
+ ch2[t5++]=ai1*c2[t6++];
+ }
+
+ dc2=ar1;
+ ds2=ai1;
+ ar2=ar1;
+ ai2=ai1;
+
+ t4=idl1;
+ t5=(ipp2-1)*idl1;
+ for(j=2;j<ipph;j++){
+ t4+=idl1;
+ t5-=idl1;
+
+ ar2h=dc2*ar2-ds2*ai2;
+ ai2=dc2*ai2+ds2*ar2;
+ ar2=ar2h;
+
+ t6=t1;
+ t7=t2;
+ t8=t4;
+ t9=t5;
+ for(ik=0;ik<idl1;ik++){
+ ch2[t6++]+=ar2*c2[t8++];
+ ch2[t7++]+=ai2*c2[t9++];
+ }
+ }
+ }
+
+ t1=0;
+ for(j=1;j<ipph;j++){
+ t1+=idl1;
+ t2=t1;
+ for(ik=0;ik<idl1;ik++)ch2[ik]+=c2[t2++];
+ }
+
+ if(ido<l1)goto L132;
+
+ t1=0;
+ t2=0;
+ for(k=0;k<l1;k++){
+ t3=t1;
+ t4=t2;
+ for(i=0;i<ido;i++)cc[t4++]=ch[t3++];
+ t1+=ido;
+ t2+=t10;
+ }
+
+ goto L135;
+
+ L132:
+ for(i=0;i<ido;i++){
+ t1=i;
+ t2=i;
+ for(k=0;k<l1;k++){
+ cc[t2]=ch[t1];
+ t1+=ido;
+ t2+=t10;
+ }
+ }
+
+ L135:
+ t1=0;
+ t2=ido<<1;
+ t3=0;
+ t4=ipp2*t0;
+ for(j=1;j<ipph;j++){
+
+ t1+=t2;
+ t3+=t0;
+ t4-=t0;
+
+ t5=t1;
+ t6=t3;
+ t7=t4;
+
+ for(k=0;k<l1;k++){
+ cc[t5-1]=ch[t6];
+ cc[t5]=ch[t7];
+ t5+=t10;
+ t6+=ido;
+ t7+=ido;
+ }
+ }
+
+ if(ido==1)return;
+ if(nbd<l1)goto L141;
+
+ t1=-ido;
+ t3=0;
+ t4=0;
+ t5=ipp2*t0;
+ for(j=1;j<ipph;j++){
+ t1+=t2;
+ t3+=t2;
+ t4+=t0;
+ t5-=t0;
+ t6=t1;
+ t7=t3;
+ t8=t4;
+ t9=t5;
+ for(k=0;k<l1;k++){
+ for(i=2;i<ido;i+=2){
+ ic=idp2-i;
+ cc[i+t7-1]=ch[i+t8-1]+ch[i+t9-1];
+ cc[ic+t6-1]=ch[i+t8-1]-ch[i+t9-1];
+ cc[i+t7]=ch[i+t8]+ch[i+t9];
+ cc[ic+t6]=ch[i+t9]-ch[i+t8];
+ }
+ t6+=t10;
+ t7+=t10;
+ t8+=ido;
+ t9+=ido;
+ }
+ }
+ return;
+
+ L141:
+
+ t1=-ido;
+ t3=0;
+ t4=0;
+ t5=ipp2*t0;
+ for(j=1;j<ipph;j++){
+ t1+=t2;
+ t3+=t2;
+ t4+=t0;
+ t5-=t0;
+ for(i=2;i<ido;i+=2){
+ t6=idp2+t1-i;
+ t7=i+t3;
+ t8=i+t4;
+ t9=i+t5;
+ for(k=0;k<l1;k++){
+ cc[t7-1]=ch[t8-1]+ch[t9-1];
+ cc[t6-1]=ch[t8-1]-ch[t9-1];
+ cc[t7]=ch[t8]+ch[t9];
+ cc[t6]=ch[t9]-ch[t8];
+ t6+=t10;
+ t7+=t10;
+ t8+=ido;
+ t9+=ido;
+ }
+ }
+ }
+}
+
+static void drftf1(int n,float *c,float *ch,float *wa,int *ifac){
+ int i,k1,l1,l2;
+ int na,kh,nf;
+ int ip,iw,ido,idl1,ix2,ix3;
+
+ nf=ifac[1];
+ na=1;
+ l2=n;
+ iw=n;
+
+ for(k1=0;k1<nf;k1++){
+ kh=nf-k1;
+ ip=ifac[kh+1];
+ l1=l2/ip;
+ ido=n/l2;
+ idl1=ido*l1;
+ iw-=(ip-1)*ido;
+ na=1-na;
+
+ if(ip!=4)goto L102;
+
+ ix2=iw+ido;
+ ix3=ix2+ido;
+ if(na!=0)
+ dradf4(ido,l1,ch,c,wa+iw-1,wa+ix2-1,wa+ix3-1);
+ else
+ dradf4(ido,l1,c,ch,wa+iw-1,wa+ix2-1,wa+ix3-1);
+ goto L110;
+
+ L102:
+ if(ip!=2)goto L104;
+ if(na!=0)goto L103;
+
+ dradf2(ido,l1,c,ch,wa+iw-1);
+ goto L110;
+
+ L103:
+ dradf2(ido,l1,ch,c,wa+iw-1);
+ goto L110;
+
+ L104:
+ if(ido==1)na=1-na;
+ if(na!=0)goto L109;
+
+ dradfg(ido,ip,l1,idl1,c,c,c,ch,ch,wa+iw-1);
+ na=1;
+ goto L110;
+
+ L109:
+ dradfg(ido,ip,l1,idl1,ch,ch,ch,c,c,wa+iw-1);
+ na=0;
+
+ L110:
+ l2=l1;
+ }
+
+ if(na==1)return;
+
+ for(i=0;i<n;i++)c[i]=ch[i];
+}
+
+static void dradb2(int ido,int l1,float *cc,float *ch,float *wa1){
+ int i,k,t0,t1,t2,t3,t4,t5,t6;
+ float ti2,tr2;
+
+ t0=l1*ido;
+
+ t1=0;
+ t2=0;
+ t3=(ido<<1)-1;
+ for(k=0;k<l1;k++){
+ ch[t1]=cc[t2]+cc[t3+t2];
+ ch[t1+t0]=cc[t2]-cc[t3+t2];
+ t2=(t1+=ido)<<1;
+ }
+
+ if(ido<2)return;
+ if(ido==2)goto L105;
+
+ t1=0;
+ t2=0;
+ for(k=0;k<l1;k++){
+ t3=t1;
+ t5=(t4=t2)+(ido<<1);
+ t6=t0+t1;
+ for(i=2;i<ido;i+=2){
+ t3+=2;
+ t4+=2;
+ t5-=2;
+ t6+=2;
+ ch[t3-1]=cc[t4-1]+cc[t5-1];
+ tr2=cc[t4-1]-cc[t5-1];
+ ch[t3]=cc[t4]-cc[t5];
+ ti2=cc[t4]+cc[t5];
+ ch[t6-1]=wa1[i-2]*tr2-wa1[i-1]*ti2;
+ ch[t6]=wa1[i-2]*ti2+wa1[i-1]*tr2;
+ }
+ t2=(t1+=ido)<<1;
+ }
+
+ if(ido%2==1)return;
+
+L105:
+ t1=ido-1;
+ t2=ido-1;
+ for(k=0;k<l1;k++){
+ ch[t1]=cc[t2]+cc[t2];
+ ch[t1+t0]=-(cc[t2+1]+cc[t2+1]);
+ t1+=ido;
+ t2+=ido<<1;
+ }
+}
+
+static void dradb3(int ido,int l1,float *cc,float *ch,float *wa1,
+ float *wa2){
+ static float taur = -.5f;
+ static float taui = .8660254037844386f;
+ int i,k,t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10;
+ float ci2,ci3,di2,di3,cr2,cr3,dr2,dr3,ti2,tr2;
+ t0=l1*ido;
+
+ t1=0;
+ t2=t0<<1;
+ t3=ido<<1;
+ t4=ido+(ido<<1);
+ t5=0;
+ for(k=0;k<l1;k++){
+ tr2=cc[t3-1]+cc[t3-1];
+ cr2=cc[t5]+(taur*tr2);
+ ch[t1]=cc[t5]+tr2;
+ ci3=taui*(cc[t3]+cc[t3]);
+ ch[t1+t0]=cr2-ci3;
+ ch[t1+t2]=cr2+ci3;
+ t1+=ido;
+ t3+=t4;
+ t5+=t4;
+ }
+
+ if(ido==1)return;
+
+ t1=0;
+ t3=ido<<1;
+ for(k=0;k<l1;k++){
+ t7=t1+(t1<<1);
+ t6=(t5=t7+t3);
+ t8=t1;
+ t10=(t9=t1+t0)+t0;
+
+ for(i=2;i<ido;i+=2){
+ t5+=2;
+ t6-=2;
+ t7+=2;
+ t8+=2;
+ t9+=2;
+ t10+=2;
+ tr2=cc[t5-1]+cc[t6-1];
+ cr2=cc[t7-1]+(taur*tr2);
+ ch[t8-1]=cc[t7-1]+tr2;
+ ti2=cc[t5]-cc[t6];
+ ci2=cc[t7]+(taur*ti2);
+ ch[t8]=cc[t7]+ti2;
+ cr3=taui*(cc[t5-1]-cc[t6-1]);
+ ci3=taui*(cc[t5]+cc[t6]);
+ dr2=cr2-ci3;
+ dr3=cr2+ci3;
+ di2=ci2+cr3;
+ di3=ci2-cr3;
+ ch[t9-1]=wa1[i-2]*dr2-wa1[i-1]*di2;
+ ch[t9]=wa1[i-2]*di2+wa1[i-1]*dr2;
+ ch[t10-1]=wa2[i-2]*dr3-wa2[i-1]*di3;
+ ch[t10]=wa2[i-2]*di3+wa2[i-1]*dr3;
+ }
+ t1+=ido;
+ }
+}
+
+static void dradb4(int ido,int l1,float *cc,float *ch,float *wa1,
+ float *wa2,float *wa3){
+ static float sqrt2=1.414213562373095f;
+ int i,k,t0,t1,t2,t3,t4,t5,t6,t7,t8;
+ float ci2,ci3,ci4,cr2,cr3,cr4,ti1,ti2,ti3,ti4,tr1,tr2,tr3,tr4;
+ t0=l1*ido;
+
+ t1=0;
+ t2=ido<<2;
+ t3=0;
+ t6=ido<<1;
+ for(k=0;k<l1;k++){
+ t4=t3+t6;
+ t5=t1;
+ tr3=cc[t4-1]+cc[t4-1];
+ tr4=cc[t4]+cc[t4];
+ tr1=cc[t3]-cc[(t4+=t6)-1];
+ tr2=cc[t3]+cc[t4-1];
+ ch[t5]=tr2+tr3;
+ ch[t5+=t0]=tr1-tr4;
+ ch[t5+=t0]=tr2-tr3;
+ ch[t5+=t0]=tr1+tr4;
+ t1+=ido;
+ t3+=t2;
+ }
+
+ if(ido<2)return;
+ if(ido==2)goto L105;
+
+ t1=0;
+ for(k=0;k<l1;k++){
+ t5=(t4=(t3=(t2=t1<<2)+t6))+t6;
+ t7=t1;
+ for(i=2;i<ido;i+=2){
+ t2+=2;
+ t3+=2;
+ t4-=2;
+ t5-=2;
+ t7+=2;
+ ti1=cc[t2]+cc[t5];
+ ti2=cc[t2]-cc[t5];
+ ti3=cc[t3]-cc[t4];
+ tr4=cc[t3]+cc[t4];
+ tr1=cc[t2-1]-cc[t5-1];
+ tr2=cc[t2-1]+cc[t5-1];
+ ti4=cc[t3-1]-cc[t4-1];
+ tr3=cc[t3-1]+cc[t4-1];
+ ch[t7-1]=tr2+tr3;
+ cr3=tr2-tr3;
+ ch[t7]=ti2+ti3;
+ ci3=ti2-ti3;
+ cr2=tr1-tr4;
+ cr4=tr1+tr4;
+ ci2=ti1+ti4;
+ ci4=ti1-ti4;
+
+ ch[(t8=t7+t0)-1]=wa1[i-2]*cr2-wa1[i-1]*ci2;
+ ch[t8]=wa1[i-2]*ci2+wa1[i-1]*cr2;
+ ch[(t8+=t0)-1]=wa2[i-2]*cr3-wa2[i-1]*ci3;
+ ch[t8]=wa2[i-2]*ci3+wa2[i-1]*cr3;
+ ch[(t8+=t0)-1]=wa3[i-2]*cr4-wa3[i-1]*ci4;
+ ch[t8]=wa3[i-2]*ci4+wa3[i-1]*cr4;
+ }
+ t1+=ido;
+ }
+
+ if(ido%2 == 1)return;
+
+ L105:
+
+ t1=ido;
+ t2=ido<<2;
+ t3=ido-1;
+ t4=ido+(ido<<1);
+ for(k=0;k<l1;k++){
+ t5=t3;
+ ti1=cc[t1]+cc[t4];
+ ti2=cc[t4]-cc[t1];
+ tr1=cc[t1-1]-cc[t4-1];
+ tr2=cc[t1-1]+cc[t4-1];
+ ch[t5]=tr2+tr2;
+ ch[t5+=t0]=sqrt2*(tr1-ti1);
+ ch[t5+=t0]=ti2+ti2;
+ ch[t5+=t0]=-sqrt2*(tr1+ti1);
+
+ t3+=ido;
+ t1+=t2;
+ t4+=t2;
+ }
+}
+
+static void dradbg(int ido,int ip,int l1,int idl1,float *cc,float *c1,
+ float *c2,float *ch,float *ch2,float *wa){
+ static float tpi=6.283185307179586f;
+ int idij,ipph,i,j,k,l,ik,is,t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,
+ t11,t12;
+ float dc2,ai1,ai2,ar1,ar2,ds2;
+ int nbd;
+ float dcp,arg,dsp,ar1h,ar2h;
+ int ipp2;
+
+ t10=ip*ido;
+ t0=l1*ido;
+ arg=tpi/(float)ip;
+ dcp=cos(arg);
+ dsp=sin(arg);
+ nbd=(ido-1)>>1;
+ ipp2=ip;
+ ipph=(ip+1)>>1;
+ if(ido<l1)goto L103;
+
+ t1=0;
+ t2=0;
+ for(k=0;k<l1;k++){
+ t3=t1;
+ t4=t2;
+ for(i=0;i<ido;i++){
+ ch[t3]=cc[t4];
+ t3++;
+ t4++;
+ }
+ t1+=ido;
+ t2+=t10;
+ }
+ goto L106;
+
+ L103:
+ t1=0;
+ for(i=0;i<ido;i++){
+ t2=t1;
+ t3=t1;
+ for(k=0;k<l1;k++){
+ ch[t2]=cc[t3];
+ t2+=ido;
+ t3+=t10;
+ }
+ t1++;
+ }
+
+ L106:
+ t1=0;
+ t2=ipp2*t0;
+ t7=(t5=ido<<1);
+ for(j=1;j<ipph;j++){
+ t1+=t0;
+ t2-=t0;
+ t3=t1;
+ t4=t2;
+ t6=t5;
+ for(k=0;k<l1;k++){
+ ch[t3]=cc[t6-1]+cc[t6-1];
+ ch[t4]=cc[t6]+cc[t6];
+ t3+=ido;
+ t4+=ido;
+ t6+=t10;
+ }
+ t5+=t7;
+ }
+
+ if (ido == 1)goto L116;
+ if(nbd<l1)goto L112;
+
+ t1=0;
+ t2=ipp2*t0;
+ t7=0;
+ for(j=1;j<ipph;j++){
+ t1+=t0;
+ t2-=t0;
+ t3=t1;
+ t4=t2;
+
+ t7+=(ido<<1);
+ t8=t7;
+ for(k=0;k<l1;k++){
+ t5=t3;
+ t6=t4;
+ t9=t8;
+ t11=t8;
+ for(i=2;i<ido;i+=2){
+ t5+=2;
+ t6+=2;
+ t9+=2;
+ t11-=2;
+ ch[t5-1]=cc[t9-1]+cc[t11-1];
+ ch[t6-1]=cc[t9-1]-cc[t11-1];
+ ch[t5]=cc[t9]-cc[t11];
+ ch[t6]=cc[t9]+cc[t11];
+ }
+ t3+=ido;
+ t4+=ido;
+ t8+=t10;
+ }
+ }
+ goto L116;
+
+ L112:
+ t1=0;
+ t2=ipp2*t0;
+ t7=0;
+ for(j=1;j<ipph;j++){
+ t1+=t0;
+ t2-=t0;
+ t3=t1;
+ t4=t2;
+ t7+=(ido<<1);
+ t8=t7;
+ t9=t7;
+ for(i=2;i<ido;i+=2){
+ t3+=2;
+ t4+=2;
+ t8+=2;
+ t9-=2;
+ t5=t3;
+ t6=t4;
+ t11=t8;
+ t12=t9;
+ for(k=0;k<l1;k++){
+ ch[t5-1]=cc[t11-1]+cc[t12-1];
+ ch[t6-1]=cc[t11-1]-cc[t12-1];
+ ch[t5]=cc[t11]-cc[t12];
+ ch[t6]=cc[t11]+cc[t12];
+ t5+=ido;
+ t6+=ido;
+ t11+=t10;
+ t12+=t10;
+ }
+ }
+ }
+
+L116:
+ ar1=1.f;
+ ai1=0.f;
+ t1=0;
+ t9=(t2=ipp2*idl1);
+ t3=(ip-1)*idl1;
+ for(l=1;l<ipph;l++){
+ t1+=idl1;
+ t2-=idl1;
+
+ ar1h=dcp*ar1-dsp*ai1;
+ ai1=dcp*ai1+dsp*ar1;
+ ar1=ar1h;
+ t4=t1;
+ t5=t2;
+ t6=0;
+ t7=idl1;
+ t8=t3;
+ for(ik=0;ik<idl1;ik++){
+ c2[t4++]=ch2[t6++]+ar1*ch2[t7++];
+ c2[t5++]=ai1*ch2[t8++];
+ }
+ dc2=ar1;
+ ds2=ai1;
+ ar2=ar1;
+ ai2=ai1;
+
+ t6=idl1;
+ t7=t9-idl1;
+ for(j=2;j<ipph;j++){
+ t6+=idl1;
+ t7-=idl1;
+ ar2h=dc2*ar2-ds2*ai2;
+ ai2=dc2*ai2+ds2*ar2;
+ ar2=ar2h;
+ t4=t1;
+ t5=t2;
+ t11=t6;
+ t12=t7;
+ for(ik=0;ik<idl1;ik++){
+ c2[t4++]+=ar2*ch2[t11++];
+ c2[t5++]+=ai2*ch2[t12++];
+ }
+ }
+ }
+
+ t1=0;
+ for(j=1;j<ipph;j++){
+ t1+=idl1;
+ t2=t1;
+ for(ik=0;ik<idl1;ik++)ch2[ik]+=ch2[t2++];
+ }
+
+ t1=0;
+ t2=ipp2*t0;
+ for(j=1;j<ipph;j++){
+ t1+=t0;
+ t2-=t0;
+ t3=t1;
+ t4=t2;
+ for(k=0;k<l1;k++){
+ ch[t3]=c1[t3]-c1[t4];
+ ch[t4]=c1[t3]+c1[t4];
+ t3+=ido;
+ t4+=ido;
+ }
+ }
+
+ if(ido==1)goto L132;
+ if(nbd<l1)goto L128;
+
+ t1=0;
+ t2=ipp2*t0;
+ for(j=1;j<ipph;j++){
+ t1+=t0;
+ t2-=t0;
+ t3=t1;
+ t4=t2;
+ for(k=0;k<l1;k++){
+ t5=t3;
+ t6=t4;
+ for(i=2;i<ido;i+=2){
+ t5+=2;
+ t6+=2;
+ ch[t5-1]=c1[t5-1]-c1[t6];
+ ch[t6-1]=c1[t5-1]+c1[t6];
+ ch[t5]=c1[t5]+c1[t6-1];
+ ch[t6]=c1[t5]-c1[t6-1];
+ }
+ t3+=ido;
+ t4+=ido;
+ }
+ }
+ goto L132;
+
+ L128:
+ t1=0;
+ t2=ipp2*t0;
+ for(j=1;j<ipph;j++){
+ t1+=t0;
+ t2-=t0;
+ t3=t1;
+ t4=t2;
+ for(i=2;i<ido;i+=2){
+ t3+=2;
+ t4+=2;
+ t5=t3;
+ t6=t4;
+ for(k=0;k<l1;k++){
+ ch[t5-1]=c1[t5-1]-c1[t6];
+ ch[t6-1]=c1[t5-1]+c1[t6];
+ ch[t5]=c1[t5]+c1[t6-1];
+ ch[t6]=c1[t5]-c1[t6-1];
+ t5+=ido;
+ t6+=ido;
+ }
+ }
+ }
+
+L132:
+ if(ido==1)return;
+
+ for(ik=0;ik<idl1;ik++)c2[ik]=ch2[ik];
+
+ t1=0;
+ for(j=1;j<ip;j++){
+ t2=(t1+=t0);
+ for(k=0;k<l1;k++){
+ c1[t2]=ch[t2];
+ t2+=ido;
+ }
+ }
+
+ if(nbd>l1)goto L139;
+
+ is= -ido-1;
+ t1=0;
+ for(j=1;j<ip;j++){
+ is+=ido;
+ t1+=t0;
+ idij=is;
+ t2=t1;
+ for(i=2;i<ido;i+=2){
+ t2+=2;
+ idij+=2;
+ t3=t2;
+ for(k=0;k<l1;k++){
+ c1[t3-1]=wa[idij-1]*ch[t3-1]-wa[idij]*ch[t3];
+ c1[t3]=wa[idij-1]*ch[t3]+wa[idij]*ch[t3-1];
+ t3+=ido;
+ }
+ }
+ }
+ return;
+
+ L139:
+ is= -ido-1;
+ t1=0;
+ for(j=1;j<ip;j++){
+ is+=ido;
+ t1+=t0;
+ t2=t1;
+ for(k=0;k<l1;k++){
+ idij=is;
+ t3=t2;
+ for(i=2;i<ido;i+=2){
+ idij+=2;
+ t3+=2;
+ c1[t3-1]=wa[idij-1]*ch[t3-1]-wa[idij]*ch[t3];
+ c1[t3]=wa[idij-1]*ch[t3]+wa[idij]*ch[t3-1];
+ }
+ t2+=ido;
+ }
+ }
+}
+
+static void drftb1(int n, float *c, float *ch, float *wa, int *ifac){
+ int i,k1,l1,l2;
+ int na;
+ int nf,ip,iw,ix2,ix3,ido,idl1;
+
+ nf=ifac[1];
+ na=0;
+ l1=1;
+ iw=1;
+
+ for(k1=0;k1<nf;k1++){
+ ip=ifac[k1 + 2];
+ l2=ip*l1;
+ ido=n/l2;
+ idl1=ido*l1;
+ if(ip!=4)goto L103;
+ ix2=iw+ido;
+ ix3=ix2+ido;
+
+ if(na!=0)
+ dradb4(ido,l1,ch,c,wa+iw-1,wa+ix2-1,wa+ix3-1);
+ else
+ dradb4(ido,l1,c,ch,wa+iw-1,wa+ix2-1,wa+ix3-1);
+ na=1-na;
+ goto L115;
+
+ L103:
+ if(ip!=2)goto L106;
+
+ if(na!=0)
+ dradb2(ido,l1,ch,c,wa+iw-1);
+ else
+ dradb2(ido,l1,c,ch,wa+iw-1);
+ na=1-na;
+ goto L115;
+
+ L106:
+ if(ip!=3)goto L109;
+
+ ix2=iw+ido;
+ if(na!=0)
+ dradb3(ido,l1,ch,c,wa+iw-1,wa+ix2-1);
+ else
+ dradb3(ido,l1,c,ch,wa+iw-1,wa+ix2-1);
+ na=1-na;
+ goto L115;
+
+ L109:
+/* The radix five case can be translated later..... */
+/* if(ip!=5)goto L112;
+
+ ix2=iw+ido;
+ ix3=ix2+ido;
+ ix4=ix3+ido;
+ if(na!=0)
+ dradb5(ido,l1,ch,c,wa+iw-1,wa+ix2-1,wa+ix3-1,wa+ix4-1);
+ else
+ dradb5(ido,l1,c,ch,wa+iw-1,wa+ix2-1,wa+ix3-1,wa+ix4-1);
+ na=1-na;
+ goto L115;
+
+ L112:*/
+ if(na!=0)
+ dradbg(ido,ip,l1,idl1,ch,ch,ch,c,c,wa+iw-1);
+ else
+ dradbg(ido,ip,l1,idl1,c,c,c,ch,ch,wa+iw-1);
+ if(ido==1)na=1-na;
+
+ L115:
+ l1=l2;
+ iw+=(ip-1)*ido;
+ }
+
+ if(na==0)return;
+
+ for(i=0;i<n;i++)c[i]=ch[i];
+}
+
+void drft_forward(drft_lookup *l,float *data){
+ if(l->n==1)return;
+ drftf1(l->n,data,l->trigcache,l->trigcache+l->n,l->splitcache);
+}
+
+void drft_backward(drft_lookup *l,float *data){
+ if (l->n==1)return;
+ drftb1(l->n,data,l->trigcache,l->trigcache+l->n,l->splitcache);
+}
+
+void drft_init(drft_lookup *l,int n){
+ l->n=n;
+ l->trigcache=_ogg_calloc(3*n,sizeof(*l->trigcache));
+ l->splitcache=_ogg_calloc(32,sizeof(*l->splitcache));
+ fdrffti(n, l->trigcache, l->splitcache);
+}
+
+void drft_clear(drft_lookup *l){
+ if(l){
+ if(l->trigcache)_ogg_free(l->trigcache);
+ if(l->splitcache)_ogg_free(l->splitcache);
+ memset(l,0,sizeof(*l));
+ }
+}
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2007 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: fft transform
+ last mod: $Id: smallft.h 13293 2007-07-24 00:09:47Z xiphmont $
+
+ ********************************************************************/
+
+#ifndef _V_SMFT_H_
+#define _V_SMFT_H_
+
+#include "vorbis/codec.h"
+
+typedef struct {
+ int n;
+ float *trigcache;
+ int *splitcache;
+} drft_lookup;
+
+extern void drft_forward(drft_lookup *l,float *data);
+extern void drft_backward(drft_lookup *l,float *data);
+extern void drft_init(drft_lookup *l,int n);
+extern void drft_clear(drft_lookup *l);
+
+#endif
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: single-block PCM synthesis
+ last mod: $Id: synthesis.c 17474 2010-09-30 03:41:41Z gmaxwell $
+
+ ********************************************************************/
+
+#include <stdio.h>
+#include <ogg/ogg.h>
+#include "vorbis/codec.h"
+#include "codec_internal.h"
+#include "registry.h"
+#include "misc.h"
+#include "os.h"
+
+int vorbis_synthesis(vorbis_block *vb,ogg_packet *op){
+ vorbis_dsp_state *vd= vb ? vb->vd : 0;
+ private_state *b= vd ? vd->backend_state : 0;
+ vorbis_info *vi= vd ? vd->vi : 0;
+ codec_setup_info *ci= vi ? vi->codec_setup : 0;
+ oggpack_buffer *opb=vb ? &vb->opb : 0;
+ int type,mode,i;
+
+ if (!vd || !b || !vi || !ci || !opb) {
+ return OV_EBADPACKET;
+ }
+
+ /* first things first. Make sure decode is ready */
+ _vorbis_block_ripcord(vb);
+ oggpack_readinit(opb,op->packet,op->bytes);
+
+ /* Check the packet type */
+ if(oggpack_read(opb,1)!=0){
+ /* Oops. This is not an audio data packet */
+ return(OV_ENOTAUDIO);
+ }
+
+ /* read our mode and pre/post windowsize */
+ mode=oggpack_read(opb,b->modebits);
+ if(mode==-1){
+ return(OV_EBADPACKET);
+ }
+
+ vb->mode=mode;
+ if(!ci->mode_param[mode]){
+ return(OV_EBADPACKET);
+ }
+
+ vb->W=ci->mode_param[mode]->blockflag;
+ if(vb->W){
+
+ /* this doesn;t get mapped through mode selection as it's used
+ only for window selection */
+ vb->lW=oggpack_read(opb,1);
+ vb->nW=oggpack_read(opb,1);
+ if(vb->nW==-1){
+ return(OV_EBADPACKET);
+ }
+ }else{
+ vb->lW=0;
+ vb->nW=0;
+ }
+
+ /* more setup */
+ vb->granulepos=op->granulepos;
+ vb->sequence=op->packetno;
+ vb->eofflag=op->e_o_s;
+
+ /* alloc pcm passback storage */
+ vb->pcmend=ci->blocksizes[vb->W];
+ vb->pcm=_vorbis_block_alloc(vb,sizeof(*vb->pcm)*vi->channels);
+ for(i=0;i<vi->channels;i++)
+ vb->pcm[i]=_vorbis_block_alloc(vb,vb->pcmend*sizeof(*vb->pcm[i]));
+
+ /* unpack_header enforces range checking */
+ type=ci->map_type[ci->mode_param[mode]->mapping];
+
+ return(_mapping_P[type]->inverse(vb,ci->map_param[ci->mode_param[mode]->
+ mapping]));
+}
+
+/* used to track pcm position without actually performing decode.
+ Useful for sequential 'fast forward' */
+int vorbis_synthesis_trackonly(vorbis_block *vb,ogg_packet *op){
+ vorbis_dsp_state *vd=vb->vd;
+ private_state *b=vd->backend_state;
+ vorbis_info *vi=vd->vi;
+ codec_setup_info *ci=vi->codec_setup;
+ oggpack_buffer *opb=&vb->opb;
+ int mode;
+
+ /* first things first. Make sure decode is ready */
+ _vorbis_block_ripcord(vb);
+ oggpack_readinit(opb,op->packet,op->bytes);
+
+ /* Check the packet type */
+ if(oggpack_read(opb,1)!=0){
+ /* Oops. This is not an audio data packet */
+ return(OV_ENOTAUDIO);
+ }
+
+ /* read our mode and pre/post windowsize */
+ mode=oggpack_read(opb,b->modebits);
+ if(mode==-1)return(OV_EBADPACKET);
+
+ vb->mode=mode;
+ if(!ci->mode_param[mode]){
+ return(OV_EBADPACKET);
+ }
+
+ vb->W=ci->mode_param[mode]->blockflag;
+ if(vb->W){
+ vb->lW=oggpack_read(opb,1);
+ vb->nW=oggpack_read(opb,1);
+ if(vb->nW==-1) return(OV_EBADPACKET);
+ }else{
+ vb->lW=0;
+ vb->nW=0;
+ }
+
+ /* more setup */
+ vb->granulepos=op->granulepos;
+ vb->sequence=op->packetno;
+ vb->eofflag=op->e_o_s;
+
+ /* no pcm */
+ vb->pcmend=0;
+ vb->pcm=NULL;
+
+ return(0);
+}
+
+long vorbis_packet_blocksize(vorbis_info *vi,ogg_packet *op){
+ codec_setup_info *ci=vi->codec_setup;
+ oggpack_buffer opb;
+ int mode;
+
+ oggpack_readinit(&opb,op->packet,op->bytes);
+
+ /* Check the packet type */
+ if(oggpack_read(&opb,1)!=0){
+ /* Oops. This is not an audio data packet */
+ return(OV_ENOTAUDIO);
+ }
+
+ {
+ int modebits=0;
+ int v=ci->modes;
+ while(v>1){
+ modebits++;
+ v>>=1;
+ }
+
+ /* read our mode and pre/post windowsize */
+ mode=oggpack_read(&opb,modebits);
+ }
+ if(mode==-1)return(OV_EBADPACKET);
+ return(ci->blocksizes[ci->mode_param[mode]->blockflag]);
+}
+
+int vorbis_synthesis_halfrate(vorbis_info *vi,int flag){
+ /* set / clear half-sample-rate mode */
+ codec_setup_info *ci=vi->codec_setup;
+
+ /* right now, our MDCT can't handle < 64 sample windows. */
+ if(ci->blocksizes[0]<=64 && flag)return -1;
+ ci->halfrate_flag=(flag?1:0);
+ return 0;
+}
+
+int vorbis_synthesis_halfrate_p(vorbis_info *vi){
+ codec_setup_info *ci=vi->codec_setup;
+ return ci->halfrate_flag;
+}
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: simple programmatic interface for encoder mode setup
+ last mod: $Id: vorbisenc.c 17028 2010-03-25 05:22:15Z xiphmont $
+
+ ********************************************************************/
+
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include "vorbis/codec.h"
+#include "vorbis/vorbisenc.h"
+
+#include "codec_internal.h"
+
+#include "os.h"
+#include "misc.h"
+
+/* careful with this; it's using static array sizing to make managing
+ all the modes a little less annoying. If we use a residue backend
+ with > 12 partition types, or a different division of iteration,
+ this needs to be updated. */
+typedef struct {
+ const static_codebook *books[12][4];
+} static_bookblock;
+
+typedef struct {
+ int res_type;
+ int limit_type; /* 0 lowpass limited, 1 point stereo limited */
+ int grouping;
+ const vorbis_info_residue0 *res;
+ const static_codebook *book_aux;
+ const static_codebook *book_aux_managed;
+ const static_bookblock *books_base;
+ const static_bookblock *books_base_managed;
+} vorbis_residue_template;
+
+typedef struct {
+ const vorbis_info_mapping0 *map;
+ const vorbis_residue_template *res;
+} vorbis_mapping_template;
+
+typedef struct vp_adjblock{
+ int block[P_BANDS];
+} vp_adjblock;
+
+typedef struct {
+ int data[NOISE_COMPAND_LEVELS];
+} compandblock;
+
+/* high level configuration information for setting things up
+ step-by-step with the detailed vorbis_encode_ctl interface.
+ There's a fair amount of redundancy such that interactive setup
+ does not directly deal with any vorbis_info or codec_setup_info
+ initialization; it's all stored (until full init) in this highlevel
+ setup, then flushed out to the real codec setup structs later. */
+
+typedef struct {
+ int att[P_NOISECURVES];
+ float boost;
+ float decay;
+} att3;
+typedef struct { int data[P_NOISECURVES]; } adj3;
+
+typedef struct {
+ int pre[PACKETBLOBS];
+ int post[PACKETBLOBS];
+ float kHz[PACKETBLOBS];
+ float lowpasskHz[PACKETBLOBS];
+} adj_stereo;
+
+typedef struct {
+ int lo;
+ int hi;
+ int fixed;
+} noiseguard;
+typedef struct {
+ int data[P_NOISECURVES][17];
+} noise3;
+
+typedef struct {
+ int mappings;
+ const double *rate_mapping;
+ const double *quality_mapping;
+ int coupling_restriction;
+ long samplerate_min_restriction;
+ long samplerate_max_restriction;
+
+
+ const int *blocksize_short;
+ const int *blocksize_long;
+
+ const att3 *psy_tone_masteratt;
+ const int *psy_tone_0dB;
+ const int *psy_tone_dBsuppress;
+
+ const vp_adjblock *psy_tone_adj_impulse;
+ const vp_adjblock *psy_tone_adj_long;
+ const vp_adjblock *psy_tone_adj_other;
+
+ const noiseguard *psy_noiseguards;
+ const noise3 *psy_noise_bias_impulse;
+ const noise3 *psy_noise_bias_padding;
+ const noise3 *psy_noise_bias_trans;
+ const noise3 *psy_noise_bias_long;
+ const int *psy_noise_dBsuppress;
+
+ const compandblock *psy_noise_compand;
+ const double *psy_noise_compand_short_mapping;
+ const double *psy_noise_compand_long_mapping;
+
+ const int *psy_noise_normal_start[2];
+ const int *psy_noise_normal_partition[2];
+ const double *psy_noise_normal_thresh;
+
+ const int *psy_ath_float;
+ const int *psy_ath_abs;
+
+ const double *psy_lowpass;
+
+ const vorbis_info_psy_global *global_params;
+ const double *global_mapping;
+ const adj_stereo *stereo_modes;
+
+ const static_codebook *const *const *const floor_books;
+ const vorbis_info_floor1 *floor_params;
+ const int floor_mappings;
+ const int **floor_mapping_list;
+
+ const vorbis_mapping_template *maps;
+} ve_setup_data_template;
+
+/* a few static coder conventions */
+static const vorbis_info_mode _mode_template[2]={
+ {0,0,0,0},
+ {1,0,0,1}
+};
+
+static const vorbis_info_mapping0 _map_nominal[2]={
+ {1, {0,0}, {0}, {0}, 1,{0},{1}},
+ {1, {0,0}, {1}, {1}, 1,{0},{1}}
+};
+
+#include "modes/setup_44.h"
+#include "modes/setup_44u.h"
+#include "modes/setup_44p51.h"
+#include "modes/setup_32.h"
+#include "modes/setup_8.h"
+#include "modes/setup_11.h"
+#include "modes/setup_16.h"
+#include "modes/setup_22.h"
+#include "modes/setup_X.h"
+
+static const ve_setup_data_template *const setup_list[]={
+ &ve_setup_44_stereo,
+ &ve_setup_44_51,
+ &ve_setup_44_uncoupled,
+
+ &ve_setup_32_stereo,
+ &ve_setup_32_uncoupled,
+
+ &ve_setup_22_stereo,
+ &ve_setup_22_uncoupled,
+ &ve_setup_16_stereo,
+ &ve_setup_16_uncoupled,
+
+ &ve_setup_11_stereo,
+ &ve_setup_11_uncoupled,
+ &ve_setup_8_stereo,
+ &ve_setup_8_uncoupled,
+
+ &ve_setup_X_stereo,
+ &ve_setup_X_uncoupled,
+ &ve_setup_XX_stereo,
+ &ve_setup_XX_uncoupled,
+ 0
+};
+
+static void vorbis_encode_floor_setup(vorbis_info *vi,int s,
+ const static_codebook *const *const *const books,
+ const vorbis_info_floor1 *in,
+ const int *x){
+ int i,k,is=s;
+ vorbis_info_floor1 *f=_ogg_calloc(1,sizeof(*f));
+ codec_setup_info *ci=vi->codec_setup;
+
+ memcpy(f,in+x[is],sizeof(*f));
+
+ /* books */
+ {
+ int partitions=f->partitions;
+ int maxclass=-1;
+ int maxbook=-1;
+ for(i=0;i<partitions;i++)
+ if(f->partitionclass[i]>maxclass)maxclass=f->partitionclass[i];
+ for(i=0;i<=maxclass;i++){
+ if(f->class_book[i]>maxbook)maxbook=f->class_book[i];
+ f->class_book[i]+=ci->books;
+ for(k=0;k<(1<<f->class_subs[i]);k++){
+ if(f->class_subbook[i][k]>maxbook)maxbook=f->class_subbook[i][k];
+ if(f->class_subbook[i][k]>=0)f->class_subbook[i][k]+=ci->books;
+ }
+ }
+
+ for(i=0;i<=maxbook;i++)
+ ci->book_param[ci->books++]=(static_codebook *)books[x[is]][i];
+ }
+
+ /* for now, we're only using floor 1 */
+ ci->floor_type[ci->floors]=1;
+ ci->floor_param[ci->floors]=f;
+ ci->floors++;
+
+ return;
+}
+
+static void vorbis_encode_global_psych_setup(vorbis_info *vi,double s,
+ const vorbis_info_psy_global *in,
+ const double *x){
+ int i,is=s;
+ double ds=s-is;
+ codec_setup_info *ci=vi->codec_setup;
+ vorbis_info_psy_global *g=&ci->psy_g_param;
+
+ memcpy(g,in+(int)x[is],sizeof(*g));
+
+ ds=x[is]*(1.-ds)+x[is+1]*ds;
+ is=(int)ds;
+ ds-=is;
+ if(ds==0 && is>0){
+ is--;
+ ds=1.;
+ }
+
+ /* interpolate the trigger threshholds */
+ for(i=0;i<4;i++){
+ g->preecho_thresh[i]=in[is].preecho_thresh[i]*(1.-ds)+in[is+1].preecho_thresh[i]*ds;
+ g->postecho_thresh[i]=in[is].postecho_thresh[i]*(1.-ds)+in[is+1].postecho_thresh[i]*ds;
+ }
+ g->ampmax_att_per_sec=ci->hi.amplitude_track_dBpersec;
+ return;
+}
+
+static void vorbis_encode_global_stereo(vorbis_info *vi,
+ const highlevel_encode_setup *const hi,
+ const adj_stereo *p){
+ float s=hi->stereo_point_setting;
+ int i,is=s;
+ double ds=s-is;
+ codec_setup_info *ci=vi->codec_setup;
+ vorbis_info_psy_global *g=&ci->psy_g_param;
+
+ if(p){
+ memcpy(g->coupling_prepointamp,p[is].pre,sizeof(*p[is].pre)*PACKETBLOBS);
+ memcpy(g->coupling_postpointamp,p[is].post,sizeof(*p[is].post)*PACKETBLOBS);
+
+ if(hi->managed){
+ /* interpolate the kHz threshholds */
+ for(i=0;i<PACKETBLOBS;i++){
+ float kHz=p[is].kHz[i]*(1.-ds)+p[is+1].kHz[i]*ds;
+ g->coupling_pointlimit[0][i]=kHz*1000./vi->rate*ci->blocksizes[0];
+ g->coupling_pointlimit[1][i]=kHz*1000./vi->rate*ci->blocksizes[1];
+ g->coupling_pkHz[i]=kHz;
+
+ kHz=p[is].lowpasskHz[i]*(1.-ds)+p[is+1].lowpasskHz[i]*ds;
+ g->sliding_lowpass[0][i]=kHz*1000./vi->rate*ci->blocksizes[0];
+ g->sliding_lowpass[1][i]=kHz*1000./vi->rate*ci->blocksizes[1];
+
+ }
+ }else{
+ float kHz=p[is].kHz[PACKETBLOBS/2]*(1.-ds)+p[is+1].kHz[PACKETBLOBS/2]*ds;
+ for(i=0;i<PACKETBLOBS;i++){
+ g->coupling_pointlimit[0][i]=kHz*1000./vi->rate*ci->blocksizes[0];
+ g->coupling_pointlimit[1][i]=kHz*1000./vi->rate*ci->blocksizes[1];
+ g->coupling_pkHz[i]=kHz;
+ }
+
+ kHz=p[is].lowpasskHz[PACKETBLOBS/2]*(1.-ds)+p[is+1].lowpasskHz[PACKETBLOBS/2]*ds;
+ for(i=0;i<PACKETBLOBS;i++){
+ g->sliding_lowpass[0][i]=kHz*1000./vi->rate*ci->blocksizes[0];
+ g->sliding_lowpass[1][i]=kHz*1000./vi->rate*ci->blocksizes[1];
+ }
+ }
+ }else{
+ for(i=0;i<PACKETBLOBS;i++){
+ g->sliding_lowpass[0][i]=ci->blocksizes[0];
+ g->sliding_lowpass[1][i]=ci->blocksizes[1];
+ }
+ }
+ return;
+}
+
+static void vorbis_encode_psyset_setup(vorbis_info *vi,double s,
+ const int *nn_start,
+ const int *nn_partition,
+ const double *nn_thresh,
+ int block){
+ codec_setup_info *ci=vi->codec_setup;
+ vorbis_info_psy *p=ci->psy_param[block];
+ highlevel_encode_setup *hi=&ci->hi;
+ int is=s;
+
+ if(block>=ci->psys)
+ ci->psys=block+1;
+ if(!p){
+ p=_ogg_calloc(1,sizeof(*p));
+ ci->psy_param[block]=p;
+ }
+
+ memcpy(p,&_psy_info_template,sizeof(*p));
+ p->blockflag=block>>1;
+
+ if(hi->noise_normalize_p){
+ p->normal_p=1;
+ p->normal_start=nn_start[is];
+ p->normal_partition=nn_partition[is];
+ p->normal_thresh=nn_thresh[is];
+ }
+
+ return;
+}
+
+static void vorbis_encode_tonemask_setup(vorbis_info *vi,double s,int block,
+ const att3 *att,
+ const int *max,
+ const vp_adjblock *in){
+ int i,is=s;
+ double ds=s-is;
+ codec_setup_info *ci=vi->codec_setup;
+ vorbis_info_psy *p=ci->psy_param[block];
+
+ /* 0 and 2 are only used by bitmanagement, but there's no harm to always
+ filling the values in here */
+ p->tone_masteratt[0]=att[is].att[0]*(1.-ds)+att[is+1].att[0]*ds;
+ p->tone_masteratt[1]=att[is].att[1]*(1.-ds)+att[is+1].att[1]*ds;
+ p->tone_masteratt[2]=att[is].att[2]*(1.-ds)+att[is+1].att[2]*ds;
+ p->tone_centerboost=att[is].boost*(1.-ds)+att[is+1].boost*ds;
+ p->tone_decay=att[is].decay*(1.-ds)+att[is+1].decay*ds;
+
+ p->max_curve_dB=max[is]*(1.-ds)+max[is+1]*ds;
+
+ for(i=0;i<P_BANDS;i++)
+ p->toneatt[i]=in[is].block[i]*(1.-ds)+in[is+1].block[i]*ds;
+ return;
+}
+
+
+static void vorbis_encode_compand_setup(vorbis_info *vi,double s,int block,
+ const compandblock *in,
+ const double *x){
+ int i,is=s;
+ double ds=s-is;
+ codec_setup_info *ci=vi->codec_setup;
+ vorbis_info_psy *p=ci->psy_param[block];
+
+ ds=x[is]*(1.-ds)+x[is+1]*ds;
+ is=(int)ds;
+ ds-=is;
+ if(ds==0 && is>0){
+ is--;
+ ds=1.;
+ }
+
+ /* interpolate the compander settings */
+ for(i=0;i<NOISE_COMPAND_LEVELS;i++)
+ p->noisecompand[i]=in[is].data[i]*(1.-ds)+in[is+1].data[i]*ds;
+ return;
+}
+
+static void vorbis_encode_peak_setup(vorbis_info *vi,double s,int block,
+ const int *suppress){
+ int is=s;
+ double ds=s-is;
+ codec_setup_info *ci=vi->codec_setup;
+ vorbis_info_psy *p=ci->psy_param[block];
+
+ p->tone_abs_limit=suppress[is]*(1.-ds)+suppress[is+1]*ds;
+
+ return;
+}
+
+static void vorbis_encode_noisebias_setup(vorbis_info *vi,double s,int block,
+ const int *suppress,
+ const noise3 *in,
+ const noiseguard *guard,
+ double userbias){
+ int i,is=s,j;
+ double ds=s-is;
+ codec_setup_info *ci=vi->codec_setup;
+ vorbis_info_psy *p=ci->psy_param[block];
+
+ p->noisemaxsupp=suppress[is]*(1.-ds)+suppress[is+1]*ds;
+ p->noisewindowlomin=guard[block].lo;
+ p->noisewindowhimin=guard[block].hi;
+ p->noisewindowfixed=guard[block].fixed;
+
+ for(j=0;j<P_NOISECURVES;j++)
+ for(i=0;i<P_BANDS;i++)
+ p->noiseoff[j][i]=in[is].data[j][i]*(1.-ds)+in[is+1].data[j][i]*ds;
+
+ /* impulse blocks may take a user specified bias to boost the
+ nominal/high noise encoding depth */
+ for(j=0;j<P_NOISECURVES;j++){
+ float min=p->noiseoff[j][0]+6; /* the lowest it can go */
+ for(i=0;i<P_BANDS;i++){
+ p->noiseoff[j][i]+=userbias;
+ if(p->noiseoff[j][i]<min)p->noiseoff[j][i]=min;
+ }
+ }
+
+ return;
+}
+
+static void vorbis_encode_ath_setup(vorbis_info *vi,int block){
+ codec_setup_info *ci=vi->codec_setup;
+ vorbis_info_psy *p=ci->psy_param[block];
+
+ p->ath_adjatt=ci->hi.ath_floating_dB;
+ p->ath_maxatt=ci->hi.ath_absolute_dB;
+ return;
+}
+
+
+static int book_dup_or_new(codec_setup_info *ci,const static_codebook *book){
+ int i;
+ for(i=0;i<ci->books;i++)
+ if(ci->book_param[i]==book)return(i);
+
+ return(ci->books++);
+}
+
+static void vorbis_encode_blocksize_setup(vorbis_info *vi,double s,
+ const int *shortb,const int *longb){
+
+ codec_setup_info *ci=vi->codec_setup;
+ int is=s;
+
+ int blockshort=shortb[is];
+ int blocklong=longb[is];
+ ci->blocksizes[0]=blockshort;
+ ci->blocksizes[1]=blocklong;
+
+}
+
+static void vorbis_encode_residue_setup(vorbis_info *vi,
+ int number, int block,
+ const vorbis_residue_template *res){
+
+ codec_setup_info *ci=vi->codec_setup;
+ int i;
+
+ vorbis_info_residue0 *r=ci->residue_param[number]=
+ _ogg_malloc(sizeof(*r));
+
+ memcpy(r,res->res,sizeof(*r));
+ if(ci->residues<=number)ci->residues=number+1;
+
+ r->grouping=res->grouping;
+ ci->residue_type[number]=res->res_type;
+
+ /* fill in all the books */
+ {
+ int booklist=0,k;
+
+ if(ci->hi.managed){
+ for(i=0;i<r->partitions;i++)
+ for(k=0;k<4;k++)
+ if(res->books_base_managed->books[i][k])
+ r->secondstages[i]|=(1<<k);
+
+ r->groupbook=book_dup_or_new(ci,res->book_aux_managed);
+ ci->book_param[r->groupbook]=(static_codebook *)res->book_aux_managed;
+
+ for(i=0;i<r->partitions;i++){
+ for(k=0;k<4;k++){
+ if(res->books_base_managed->books[i][k]){
+ int bookid=book_dup_or_new(ci,res->books_base_managed->books[i][k]);
+ r->booklist[booklist++]=bookid;
+ ci->book_param[bookid]=(static_codebook *)res->books_base_managed->books[i][k];
+ }
+ }
+ }
+
+ }else{
+
+ for(i=0;i<r->partitions;i++)
+ for(k=0;k<4;k++)
+ if(res->books_base->books[i][k])
+ r->secondstages[i]|=(1<<k);
+
+ r->groupbook=book_dup_or_new(ci,res->book_aux);
+ ci->book_param[r->groupbook]=(static_codebook *)res->book_aux;
+
+ for(i=0;i<r->partitions;i++){
+ for(k=0;k<4;k++){
+ if(res->books_base->books[i][k]){
+ int bookid=book_dup_or_new(ci,res->books_base->books[i][k]);
+ r->booklist[booklist++]=bookid;
+ ci->book_param[bookid]=(static_codebook *)res->books_base->books[i][k];
+ }
+ }
+ }
+ }
+ }
+
+ /* lowpass setup/pointlimit */
+ {
+ double freq=ci->hi.lowpass_kHz*1000.;
+ vorbis_info_floor1 *f=ci->floor_param[block]; /* by convention */
+ double nyq=vi->rate/2.;
+ long blocksize=ci->blocksizes[block]>>1;
+
+ /* lowpass needs to be set in the floor and the residue. */
+ if(freq>nyq)freq=nyq;
+ /* in the floor, the granularity can be very fine; it doesn't alter
+ the encoding structure, only the samples used to fit the floor
+ approximation */
+ f->n=freq/nyq*blocksize;
+
+ /* this res may by limited by the maximum pointlimit of the mode,
+ not the lowpass. the floor is always lowpass limited. */
+ switch(res->limit_type){
+ case 1: /* point stereo limited */
+ if(ci->hi.managed)
+ freq=ci->psy_g_param.coupling_pkHz[PACKETBLOBS-1]*1000.;
+ else
+ freq=ci->psy_g_param.coupling_pkHz[PACKETBLOBS/2]*1000.;
+ if(freq>nyq)freq=nyq;
+ break;
+ case 2: /* LFE channel; lowpass at ~ 250Hz */
+ freq=250;
+ break;
+ default:
+ /* already set */
+ break;
+ }
+
+ /* in the residue, we're constrained, physically, by partition
+ boundaries. We still lowpass 'wherever', but we have to round up
+ here to next boundary, or the vorbis spec will round it *down* to
+ previous boundary in encode/decode */
+ if(ci->residue_type[number]==2){
+ /* residue 2 bundles together multiple channels; used by stereo
+ and surround. Count the channels in use */
+ /* Multiple maps/submaps can point to the same residue. In the case
+ of residue 2, they all better have the same number of
+ channels/samples. */
+ int j,k,ch=0;
+ for(i=0;i<ci->maps&&ch==0;i++){
+ vorbis_info_mapping0 *mi=(vorbis_info_mapping0 *)ci->map_param[i];
+ for(j=0;j<mi->submaps && ch==0;j++)
+ if(mi->residuesubmap[j]==number) /* we found a submap referencing theis residue backend */
+ for(k=0;k<vi->channels;k++)
+ if(mi->chmuxlist[k]==j) /* this channel belongs to the submap */
+ ch++;
+ }
+
+ r->end=(int)((freq/nyq*blocksize*ch)/r->grouping+.9)* /* round up only if we're well past */
+ r->grouping;
+ /* the blocksize and grouping may disagree at the end */
+ if(r->end>blocksize*ch)r->end=blocksize*ch/r->grouping*r->grouping;
+
+ }else{
+
+ r->end=(int)((freq/nyq*blocksize)/r->grouping+.9)* /* round up only if we're well past */
+ r->grouping;
+ /* the blocksize and grouping may disagree at the end */
+ if(r->end>blocksize)r->end=blocksize/r->grouping*r->grouping;
+
+ }
+
+ if(r->end==0)r->end=r->grouping; /* LFE channel */
+
+ }
+}
+
+/* we assume two maps in this encoder */
+static void vorbis_encode_map_n_res_setup(vorbis_info *vi,double s,
+ const vorbis_mapping_template *maps){
+
+ codec_setup_info *ci=vi->codec_setup;
+ int i,j,is=s,modes=2;
+ const vorbis_info_mapping0 *map=maps[is].map;
+ const vorbis_info_mode *mode=_mode_template;
+ const vorbis_residue_template *res=maps[is].res;
+
+ if(ci->blocksizes[0]==ci->blocksizes[1])modes=1;
+
+ for(i=0;i<modes;i++){
+
+ ci->map_param[i]=_ogg_calloc(1,sizeof(*map));
+ ci->mode_param[i]=_ogg_calloc(1,sizeof(*mode));
+
+ memcpy(ci->mode_param[i],mode+i,sizeof(*_mode_template));
+ if(i>=ci->modes)ci->modes=i+1;
+
+ ci->map_type[i]=0;
+ memcpy(ci->map_param[i],map+i,sizeof(*map));
+ if(i>=ci->maps)ci->maps=i+1;
+
+ for(j=0;j<map[i].submaps;j++)
+ vorbis_encode_residue_setup(vi,map[i].residuesubmap[j],i
+ ,res+map[i].residuesubmap[j]);
+ }
+}
+
+static double setting_to_approx_bitrate(vorbis_info *vi){
+ codec_setup_info *ci=vi->codec_setup;
+ highlevel_encode_setup *hi=&ci->hi;
+ ve_setup_data_template *setup=(ve_setup_data_template *)hi->setup;
+ int is=hi->base_setting;
+ double ds=hi->base_setting-is;
+ int ch=vi->channels;
+ const double *r=setup->rate_mapping;
+
+ if(r==NULL)
+ return(-1);
+
+ return((r[is]*(1.-ds)+r[is+1]*ds)*ch);
+}
+
+static const void *get_setup_template(long ch,long srate,
+ double req,int q_or_bitrate,
+ double *base_setting){
+ int i=0,j;
+ if(q_or_bitrate)req/=ch;
+
+ while(setup_list[i]){
+ if(setup_list[i]->coupling_restriction==-1 ||
+ setup_list[i]->coupling_restriction==ch){
+ if(srate>=setup_list[i]->samplerate_min_restriction &&
+ srate<=setup_list[i]->samplerate_max_restriction){
+ int mappings=setup_list[i]->mappings;
+ const double *map=(q_or_bitrate?
+ setup_list[i]->rate_mapping:
+ setup_list[i]->quality_mapping);
+
+ /* the template matches. Does the requested quality mode
+ fall within this template's modes? */
+ if(req<map[0]){++i;continue;}
+ if(req>map[setup_list[i]->mappings]){++i;continue;}
+ for(j=0;j<mappings;j++)
+ if(req>=map[j] && req<map[j+1])break;
+ /* an all-points match */
+ if(j==mappings)
+ *base_setting=j-.001;
+ else{
+ float low=map[j];
+ float high=map[j+1];
+ float del=(req-low)/(high-low);
+ *base_setting=j+del;
+ }
+
+ return(setup_list[i]);
+ }
+ }
+ i++;
+ }
+
+ return NULL;
+}
+
+/* encoders will need to use vorbis_info_init beforehand and call
+ vorbis_info clear when all done */
+
+/* two interfaces; this, more detailed one, and later a convenience
+ layer on top */
+
+/* the final setup call */
+int vorbis_encode_setup_init(vorbis_info *vi){
+ int i,i0=0,singleblock=0;
+ codec_setup_info *ci=vi->codec_setup;
+ ve_setup_data_template *setup=NULL;
+ highlevel_encode_setup *hi=&ci->hi;
+
+ if(ci==NULL)return(OV_EINVAL);
+ if(!hi->impulse_block_p)i0=1;
+
+ /* too low/high an ATH floater is nonsensical, but doesn't break anything */
+ if(hi->ath_floating_dB>-80)hi->ath_floating_dB=-80;
+ if(hi->ath_floating_dB<-200)hi->ath_floating_dB=-200;
+
+ /* again, bound this to avoid the app shooting itself int he foot
+ too badly */
+ if(hi->amplitude_track_dBpersec>0.)hi->amplitude_track_dBpersec=0.;
+ if(hi->amplitude_track_dBpersec<-99999.)hi->amplitude_track_dBpersec=-99999.;
+
+ /* get the appropriate setup template; matches the fetch in previous
+ stages */
+ setup=(ve_setup_data_template *)hi->setup;
+ if(setup==NULL)return(OV_EINVAL);
+
+ hi->set_in_stone=1;
+ /* choose block sizes from configured sizes as well as paying
+ attention to long_block_p and short_block_p. If the configured
+ short and long blocks are the same length, we set long_block_p
+ and unset short_block_p */
+ vorbis_encode_blocksize_setup(vi,hi->base_setting,
+ setup->blocksize_short,
+ setup->blocksize_long);
+ if(ci->blocksizes[0]==ci->blocksizes[1])singleblock=1;
+
+ /* floor setup; choose proper floor params. Allocated on the floor
+ stack in order; if we alloc only a single long floor, it's 0 */
+ for(i=0;i<setup->floor_mappings;i++)
+ vorbis_encode_floor_setup(vi,hi->base_setting,
+ setup->floor_books,
+ setup->floor_params,
+ setup->floor_mapping_list[i]);
+
+ /* setup of [mostly] short block detection and stereo*/
+ vorbis_encode_global_psych_setup(vi,hi->trigger_setting,
+ setup->global_params,
+ setup->global_mapping);
+ vorbis_encode_global_stereo(vi,hi,setup->stereo_modes);
+
+ /* basic psych setup and noise normalization */
+ vorbis_encode_psyset_setup(vi,hi->base_setting,
+ setup->psy_noise_normal_start[0],
+ setup->psy_noise_normal_partition[0],
+ setup->psy_noise_normal_thresh,
+ 0);
+ vorbis_encode_psyset_setup(vi,hi->base_setting,
+ setup->psy_noise_normal_start[0],
+ setup->psy_noise_normal_partition[0],
+ setup->psy_noise_normal_thresh,
+ 1);
+ if(!singleblock){
+ vorbis_encode_psyset_setup(vi,hi->base_setting,
+ setup->psy_noise_normal_start[1],
+ setup->psy_noise_normal_partition[1],
+ setup->psy_noise_normal_thresh,
+ 2);
+ vorbis_encode_psyset_setup(vi,hi->base_setting,
+ setup->psy_noise_normal_start[1],
+ setup->psy_noise_normal_partition[1],
+ setup->psy_noise_normal_thresh,
+ 3);
+ }
+
+ /* tone masking setup */
+ vorbis_encode_tonemask_setup(vi,hi->block[i0].tone_mask_setting,0,
+ setup->psy_tone_masteratt,
+ setup->psy_tone_0dB,
+ setup->psy_tone_adj_impulse);
+ vorbis_encode_tonemask_setup(vi,hi->block[1].tone_mask_setting,1,
+ setup->psy_tone_masteratt,
+ setup->psy_tone_0dB,
+ setup->psy_tone_adj_other);
+ if(!singleblock){
+ vorbis_encode_tonemask_setup(vi,hi->block[2].tone_mask_setting,2,
+ setup->psy_tone_masteratt,
+ setup->psy_tone_0dB,
+ setup->psy_tone_adj_other);
+ vorbis_encode_tonemask_setup(vi,hi->block[3].tone_mask_setting,3,
+ setup->psy_tone_masteratt,
+ setup->psy_tone_0dB,
+ setup->psy_tone_adj_long);
+ }
+
+ /* noise companding setup */
+ vorbis_encode_compand_setup(vi,hi->block[i0].noise_compand_setting,0,
+ setup->psy_noise_compand,
+ setup->psy_noise_compand_short_mapping);
+ vorbis_encode_compand_setup(vi,hi->block[1].noise_compand_setting,1,
+ setup->psy_noise_compand,
+ setup->psy_noise_compand_short_mapping);
+ if(!singleblock){
+ vorbis_encode_compand_setup(vi,hi->block[2].noise_compand_setting,2,
+ setup->psy_noise_compand,
+ setup->psy_noise_compand_long_mapping);
+ vorbis_encode_compand_setup(vi,hi->block[3].noise_compand_setting,3,
+ setup->psy_noise_compand,
+ setup->psy_noise_compand_long_mapping);
+ }
+
+ /* peak guarding setup */
+ vorbis_encode_peak_setup(vi,hi->block[i0].tone_peaklimit_setting,0,
+ setup->psy_tone_dBsuppress);
+ vorbis_encode_peak_setup(vi,hi->block[1].tone_peaklimit_setting,1,
+ setup->psy_tone_dBsuppress);
+ if(!singleblock){
+ vorbis_encode_peak_setup(vi,hi->block[2].tone_peaklimit_setting,2,
+ setup->psy_tone_dBsuppress);
+ vorbis_encode_peak_setup(vi,hi->block[3].tone_peaklimit_setting,3,
+ setup->psy_tone_dBsuppress);
+ }
+
+ /* noise bias setup */
+ vorbis_encode_noisebias_setup(vi,hi->block[i0].noise_bias_setting,0,
+ setup->psy_noise_dBsuppress,
+ setup->psy_noise_bias_impulse,
+ setup->psy_noiseguards,
+ (i0==0?hi->impulse_noisetune:0.));
+ vorbis_encode_noisebias_setup(vi,hi->block[1].noise_bias_setting,1,
+ setup->psy_noise_dBsuppress,
+ setup->psy_noise_bias_padding,
+ setup->psy_noiseguards,0.);
+ if(!singleblock){
+ vorbis_encode_noisebias_setup(vi,hi->block[2].noise_bias_setting,2,
+ setup->psy_noise_dBsuppress,
+ setup->psy_noise_bias_trans,
+ setup->psy_noiseguards,0.);
+ vorbis_encode_noisebias_setup(vi,hi->block[3].noise_bias_setting,3,
+ setup->psy_noise_dBsuppress,
+ setup->psy_noise_bias_long,
+ setup->psy_noiseguards,0.);
+ }
+
+ vorbis_encode_ath_setup(vi,0);
+ vorbis_encode_ath_setup(vi,1);
+ if(!singleblock){
+ vorbis_encode_ath_setup(vi,2);
+ vorbis_encode_ath_setup(vi,3);
+ }
+
+ vorbis_encode_map_n_res_setup(vi,hi->base_setting,setup->maps);
+
+ /* set bitrate readonlies and management */
+ if(hi->bitrate_av>0)
+ vi->bitrate_nominal=hi->bitrate_av;
+ else{
+ vi->bitrate_nominal=setting_to_approx_bitrate(vi);
+ }
+
+ vi->bitrate_lower=hi->bitrate_min;
+ vi->bitrate_upper=hi->bitrate_max;
+ if(hi->bitrate_av)
+ vi->bitrate_window=(double)hi->bitrate_reservoir/hi->bitrate_av;
+ else
+ vi->bitrate_window=0.;
+
+ if(hi->managed){
+ ci->bi.avg_rate=hi->bitrate_av;
+ ci->bi.min_rate=hi->bitrate_min;
+ ci->bi.max_rate=hi->bitrate_max;
+
+ ci->bi.reservoir_bits=hi->bitrate_reservoir;
+ ci->bi.reservoir_bias=
+ hi->bitrate_reservoir_bias;
+
+ ci->bi.slew_damp=hi->bitrate_av_damp;
+
+ }
+
+ return(0);
+
+}
+
+static void vorbis_encode_setup_setting(vorbis_info *vi,
+ long channels,
+ long rate){
+ int i,is;
+ codec_setup_info *ci=vi->codec_setup;
+ highlevel_encode_setup *hi=&ci->hi;
+ const ve_setup_data_template *setup=hi->setup;
+ double ds;
+
+ vi->version=0;
+ vi->channels=channels;
+ vi->rate=rate;
+
+ hi->impulse_block_p=1;
+ hi->noise_normalize_p=1;
+
+ is=hi->base_setting;
+ ds=hi->base_setting-is;
+
+ hi->stereo_point_setting=hi->base_setting;
+
+ if(!hi->lowpass_altered)
+ hi->lowpass_kHz=
+ setup->psy_lowpass[is]*(1.-ds)+setup->psy_lowpass[is+1]*ds;
+
+ hi->ath_floating_dB=setup->psy_ath_float[is]*(1.-ds)+
+ setup->psy_ath_float[is+1]*ds;
+ hi->ath_absolute_dB=setup->psy_ath_abs[is]*(1.-ds)+
+ setup->psy_ath_abs[is+1]*ds;
+
+ hi->amplitude_track_dBpersec=-6.;
+ hi->trigger_setting=hi->base_setting;
+
+ for(i=0;i<4;i++){
+ hi->block[i].tone_mask_setting=hi->base_setting;
+ hi->block[i].tone_peaklimit_setting=hi->base_setting;
+ hi->block[i].noise_bias_setting=hi->base_setting;
+ hi->block[i].noise_compand_setting=hi->base_setting;
+ }
+}
+
+int vorbis_encode_setup_vbr(vorbis_info *vi,
+ long channels,
+ long rate,
+ float quality){
+ codec_setup_info *ci=vi->codec_setup;
+ highlevel_encode_setup *hi=&ci->hi;
+
+ quality+=.0000001;
+ if(quality>=1.)quality=.9999;
+
+ hi->req=quality;
+ hi->setup=get_setup_template(channels,rate,quality,0,&hi->base_setting);
+ if(!hi->setup)return OV_EIMPL;
+
+ vorbis_encode_setup_setting(vi,channels,rate);
+ hi->managed=0;
+ hi->coupling_p=1;
+
+ return 0;
+}
+
+int vorbis_encode_init_vbr(vorbis_info *vi,
+ long channels,
+ long rate,
+
+ float base_quality /* 0. to 1. */
+ ){
+ int ret=0;
+
+ ret=vorbis_encode_setup_vbr(vi,channels,rate,base_quality);
+
+ if(ret){
+ vorbis_info_clear(vi);
+ return ret;
+ }
+ ret=vorbis_encode_setup_init(vi);
+ if(ret)
+ vorbis_info_clear(vi);
+ return(ret);
+}
+
+int vorbis_encode_setup_managed(vorbis_info *vi,
+ long channels,
+ long rate,
+
+ long max_bitrate,
+ long nominal_bitrate,
+ long min_bitrate){
+
+ codec_setup_info *ci=vi->codec_setup;
+ highlevel_encode_setup *hi=&ci->hi;
+ double tnominal=nominal_bitrate;
+
+ if(nominal_bitrate<=0.){
+ if(max_bitrate>0.){
+ if(min_bitrate>0.)
+ nominal_bitrate=(max_bitrate+min_bitrate)*.5;
+ else
+ nominal_bitrate=max_bitrate*.875;
+ }else{
+ if(min_bitrate>0.){
+ nominal_bitrate=min_bitrate;
+ }else{
+ return(OV_EINVAL);
+ }
+ }
+ }
+
+ hi->req=nominal_bitrate;
+ hi->setup=get_setup_template(channels,rate,nominal_bitrate,1,&hi->base_setting);
+ if(!hi->setup)return OV_EIMPL;
+
+ vorbis_encode_setup_setting(vi,channels,rate);
+
+ /* initialize management with sane defaults */
+ hi->coupling_p=1;
+ hi->managed=1;
+ hi->bitrate_min=min_bitrate;
+ hi->bitrate_max=max_bitrate;
+ hi->bitrate_av=tnominal;
+ hi->bitrate_av_damp=1.5f; /* full range in no less than 1.5 second */
+ hi->bitrate_reservoir=nominal_bitrate*2;
+ hi->bitrate_reservoir_bias=.1; /* bias toward hoarding bits */
+
+ return(0);
+
+}
+
+int vorbis_encode_init(vorbis_info *vi,
+ long channels,
+ long rate,
+
+ long max_bitrate,
+ long nominal_bitrate,
+ long min_bitrate){
+
+ int ret=vorbis_encode_setup_managed(vi,channels,rate,
+ max_bitrate,
+ nominal_bitrate,
+ min_bitrate);
+ if(ret){
+ vorbis_info_clear(vi);
+ return(ret);
+ }
+
+ ret=vorbis_encode_setup_init(vi);
+ if(ret)
+ vorbis_info_clear(vi);
+ return(ret);
+}
+
+int vorbis_encode_ctl(vorbis_info *vi,int number,void *arg){
+ if(vi){
+ codec_setup_info *ci=vi->codec_setup;
+ highlevel_encode_setup *hi=&ci->hi;
+ int setp=(number&0xf); /* a read request has a low nibble of 0 */
+
+ if(setp && hi->set_in_stone)return(OV_EINVAL);
+
+ switch(number){
+
+ /* now deprecated *****************/
+ case OV_ECTL_RATEMANAGE_GET:
+ {
+
+ struct ovectl_ratemanage_arg *ai=
+ (struct ovectl_ratemanage_arg *)arg;
+
+ ai->management_active=hi->managed;
+ ai->bitrate_hard_window=ai->bitrate_av_window=
+ (double)hi->bitrate_reservoir/vi->rate;
+ ai->bitrate_av_window_center=1.;
+ ai->bitrate_hard_min=hi->bitrate_min;
+ ai->bitrate_hard_max=hi->bitrate_max;
+ ai->bitrate_av_lo=hi->bitrate_av;
+ ai->bitrate_av_hi=hi->bitrate_av;
+
+ }
+ return(0);
+
+ /* now deprecated *****************/
+ case OV_ECTL_RATEMANAGE_SET:
+ {
+ struct ovectl_ratemanage_arg *ai=
+ (struct ovectl_ratemanage_arg *)arg;
+ if(ai==NULL){
+ hi->managed=0;
+ }else{
+ hi->managed=ai->management_active;
+ vorbis_encode_ctl(vi,OV_ECTL_RATEMANAGE_AVG,arg);
+ vorbis_encode_ctl(vi,OV_ECTL_RATEMANAGE_HARD,arg);
+ }
+ }
+ return 0;
+
+ /* now deprecated *****************/
+ case OV_ECTL_RATEMANAGE_AVG:
+ {
+ struct ovectl_ratemanage_arg *ai=
+ (struct ovectl_ratemanage_arg *)arg;
+ if(ai==NULL){
+ hi->bitrate_av=0;
+ }else{
+ hi->bitrate_av=(ai->bitrate_av_lo+ai->bitrate_av_hi)*.5;
+ }
+ }
+ return(0);
+ /* now deprecated *****************/
+ case OV_ECTL_RATEMANAGE_HARD:
+ {
+ struct ovectl_ratemanage_arg *ai=
+ (struct ovectl_ratemanage_arg *)arg;
+ if(ai==NULL){
+ hi->bitrate_min=0;
+ hi->bitrate_max=0;
+ }else{
+ hi->bitrate_min=ai->bitrate_hard_min;
+ hi->bitrate_max=ai->bitrate_hard_max;
+ hi->bitrate_reservoir=ai->bitrate_hard_window*
+ (hi->bitrate_max+hi->bitrate_min)*.5;
+ }
+ if(hi->bitrate_reservoir<128.)
+ hi->bitrate_reservoir=128.;
+ }
+ return(0);
+
+ /* replacement ratemanage interface */
+ case OV_ECTL_RATEMANAGE2_GET:
+ {
+ struct ovectl_ratemanage2_arg *ai=
+ (struct ovectl_ratemanage2_arg *)arg;
+ if(ai==NULL)return OV_EINVAL;
+
+ ai->management_active=hi->managed;
+ ai->bitrate_limit_min_kbps=hi->bitrate_min/1000;
+ ai->bitrate_limit_max_kbps=hi->bitrate_max/1000;
+ ai->bitrate_average_kbps=hi->bitrate_av/1000;
+ ai->bitrate_average_damping=hi->bitrate_av_damp;
+ ai->bitrate_limit_reservoir_bits=hi->bitrate_reservoir;
+ ai->bitrate_limit_reservoir_bias=hi->bitrate_reservoir_bias;
+ }
+ return (0);
+ case OV_ECTL_RATEMANAGE2_SET:
+ {
+ struct ovectl_ratemanage2_arg *ai=
+ (struct ovectl_ratemanage2_arg *)arg;
+ if(ai==NULL){
+ hi->managed=0;
+ }else{
+ /* sanity check; only catch invariant violations */
+ if(ai->bitrate_limit_min_kbps>0 &&
+ ai->bitrate_average_kbps>0 &&
+ ai->bitrate_limit_min_kbps>ai->bitrate_average_kbps)
+ return OV_EINVAL;
+
+ if(ai->bitrate_limit_max_kbps>0 &&
+ ai->bitrate_average_kbps>0 &&
+ ai->bitrate_limit_max_kbps<ai->bitrate_average_kbps)
+ return OV_EINVAL;
+
+ if(ai->bitrate_limit_min_kbps>0 &&
+ ai->bitrate_limit_max_kbps>0 &&
+ ai->bitrate_limit_min_kbps>ai->bitrate_limit_max_kbps)
+ return OV_EINVAL;
+
+ if(ai->bitrate_average_damping <= 0.)
+ return OV_EINVAL;
+
+ if(ai->bitrate_limit_reservoir_bits < 0)
+ return OV_EINVAL;
+
+ if(ai->bitrate_limit_reservoir_bias < 0.)
+ return OV_EINVAL;
+
+ if(ai->bitrate_limit_reservoir_bias > 1.)
+ return OV_EINVAL;
+
+ hi->managed=ai->management_active;
+ hi->bitrate_min=ai->bitrate_limit_min_kbps * 1000;
+ hi->bitrate_max=ai->bitrate_limit_max_kbps * 1000;
+ hi->bitrate_av=ai->bitrate_average_kbps * 1000;
+ hi->bitrate_av_damp=ai->bitrate_average_damping;
+ hi->bitrate_reservoir=ai->bitrate_limit_reservoir_bits;
+ hi->bitrate_reservoir_bias=ai->bitrate_limit_reservoir_bias;
+ }
+ }
+ return 0;
+
+ case OV_ECTL_LOWPASS_GET:
+ {
+ double *farg=(double *)arg;
+ *farg=hi->lowpass_kHz;
+ }
+ return(0);
+ case OV_ECTL_LOWPASS_SET:
+ {
+ double *farg=(double *)arg;
+ hi->lowpass_kHz=*farg;
+
+ if(hi->lowpass_kHz<2.)hi->lowpass_kHz=2.;
+ if(hi->lowpass_kHz>99.)hi->lowpass_kHz=99.;
+ hi->lowpass_altered=1;
+ }
+ return(0);
+ case OV_ECTL_IBLOCK_GET:
+ {
+ double *farg=(double *)arg;
+ *farg=hi->impulse_noisetune;
+ }
+ return(0);
+ case OV_ECTL_IBLOCK_SET:
+ {
+ double *farg=(double *)arg;
+ hi->impulse_noisetune=*farg;
+
+ if(hi->impulse_noisetune>0.)hi->impulse_noisetune=0.;
+ if(hi->impulse_noisetune<-15.)hi->impulse_noisetune=-15.;
+ }
+ return(0);
+ case OV_ECTL_COUPLING_GET:
+ {
+ int *iarg=(int *)arg;
+ *iarg=hi->coupling_p;
+ }
+ return(0);
+ case OV_ECTL_COUPLING_SET:
+ {
+ const void *new_template;
+ double new_base=0.;
+ int *iarg=(int *)arg;
+ hi->coupling_p=((*iarg)!=0);
+
+ /* Fetching a new template can alter the base_setting, which
+ many other parameters are based on. Right now, the only
+ parameter drawn from the base_setting that can be altered
+ by an encctl is the lowpass, so that is explictly flagged
+ to not be overwritten when we fetch a new template and
+ recompute the dependant settings */
+ new_template = get_setup_template(hi->coupling_p?vi->channels:-1,
+ vi->rate,
+ hi->req,
+ hi->managed,
+ &new_base);
+ if(!hi->setup)return OV_EIMPL;
+ hi->setup=new_template;
+ hi->base_setting=new_base;
+ vorbis_encode_setup_setting(vi,vi->channels,vi->rate);
+ }
+ return(0);
+ }
+ return(OV_EIMPL);
+ }
+ return(OV_EINVAL);
+}
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2001 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: vorbis encode-engine setup
+ last mod: $Id: vorbisenc.h 17021 2010-03-24 09:29:41Z xiphmont $
+
+ ********************************************************************/
+
+/** \file
+ * Libvorbisenc is a convenient API for setting up an encoding
+ * environment using libvorbis. Libvorbisenc encapsulates the
+ * actions needed to set up the encoder properly.
+ */
+
+#ifndef _OV_ENC_H_
+#define _OV_ENC_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+#include "codec.h"
+
+/**
+ * This is the primary function within libvorbisenc for setting up managed
+ * bitrate modes.
+ *
+ * Before this function is called, the \ref vorbis_info
+ * struct should be initialized by using vorbis_info_init() from the libvorbis
+ * API. After encoding, vorbis_info_clear() should be called.
+ *
+ * The max_bitrate, nominal_bitrate, and min_bitrate settings are used to set
+ * constraints for the encoded file. This function uses these settings to
+ * select the appropriate encoding mode and set it up.
+ *
+ * \param vi Pointer to an initialized \ref vorbis_info struct.
+ * \param channels The number of channels to be encoded.
+ * \param rate The sampling rate of the source audio.
+ * \param max_bitrate Desired maximum bitrate (limit). -1 indicates unset.
+ * \param nominal_bitrate Desired average, or central, bitrate. -1 indicates unset.
+ * \param min_bitrate Desired minimum bitrate. -1 indicates unset.
+ *
+ * \return Zero for success, and negative values for failure.
+ *
+ * \retval 0 Success.
+ * \retval OV_EFAULT Internal logic fault; indicates a bug or heap/stack corruption.
+ * \retval OV_EINVAL Invalid setup request, eg, out of range argument.
+ * \retval OV_EIMPL Unimplemented mode; unable to comply with bitrate request.
+ */
+extern int vorbis_encode_init(vorbis_info *vi,
+ long channels,
+ long rate,
+
+ long max_bitrate,
+ long nominal_bitrate,
+ long min_bitrate);
+
+/**
+ * This function performs step-one of a three-step bitrate-managed encode
+ * setup. It functions similarly to the one-step setup performed by \ref
+ * vorbis_encode_init but allows an application to make further encode setup
+ * tweaks using \ref vorbis_encode_ctl before finally calling \ref
+ * vorbis_encode_setup_init to complete the setup process.
+ *
+ * Before this function is called, the \ref vorbis_info struct should be
+ * initialized by using vorbis_info_init() from the libvorbis API. After
+ * encoding, vorbis_info_clear() should be called.
+ *
+ * The max_bitrate, nominal_bitrate, and min_bitrate settings are used to set
+ * constraints for the encoded file. This function uses these settings to
+ * select the appropriate encoding mode and set it up.
+ *
+ * \param vi Pointer to an initialized vorbis_info struct.
+ * \param channels The number of channels to be encoded.
+ * \param rate The sampling rate of the source audio.
+ * \param max_bitrate Desired maximum bitrate (limit). -1 indicates unset.
+ * \param nominal_bitrate Desired average, or central, bitrate. -1 indicates unset.
+ * \param min_bitrate Desired minimum bitrate. -1 indicates unset.
+ *
+ * \return Zero for success, and negative for failure.
+ *
+ * \retval 0 Success
+ * \retval OV_EFAULT Internal logic fault; indicates a bug or heap/stack corruption.
+ * \retval OV_EINVAL Invalid setup request, eg, out of range argument.
+ * \retval OV_EIMPL Unimplemented mode; unable to comply with bitrate request.
+ */
+extern int vorbis_encode_setup_managed(vorbis_info *vi,
+ long channels,
+ long rate,
+
+ long max_bitrate,
+ long nominal_bitrate,
+ long min_bitrate);
+
+/**
+ * This function performs step-one of a three-step variable bitrate
+ * (quality-based) encode setup. It functions similarly to the one-step setup
+ * performed by \ref vorbis_encode_init_vbr() but allows an application to
+ * make further encode setup tweaks using \ref vorbis_encode_ctl() before
+ * finally calling \ref vorbis_encode_setup_init to complete the setup
+ * process.
+ *
+ * Before this function is called, the \ref vorbis_info struct should be
+ * initialized by using \ref vorbis_info_init() from the libvorbis API. After
+ * encoding, vorbis_info_clear() should be called.
+ *
+ * \param vi Pointer to an initialized vorbis_info struct.
+ * \param channels The number of channels to be encoded.
+ * \param rate The sampling rate of the source audio.
+ * \param quality Desired quality level, currently from -0.1 to 1.0 (lo to hi).
+ *
+ * \return Zero for success, and negative values for failure.
+ *
+ * \retval 0 Success
+ * \retval OV_EFAULT Internal logic fault; indicates a bug or heap/stack corruption.
+ * \retval OV_EINVAL Invalid setup request, eg, out of range argument.
+ * \retval OV_EIMPL Unimplemented mode; unable to comply with quality level request.
+ */
+extern int vorbis_encode_setup_vbr(vorbis_info *vi,
+ long channels,
+ long rate,
+
+ float quality
+ );
+
+/**
+ * This is the primary function within libvorbisenc for setting up variable
+ * bitrate ("quality" based) modes.
+ *
+ *
+ * Before this function is called, the vorbis_info struct should be
+ * initialized by using vorbis_info_init() from the libvorbis API. After
+ * encoding, vorbis_info_clear() should be called.
+ *
+ * \param vi Pointer to an initialized vorbis_info struct.
+ * \param channels The number of channels to be encoded.
+ * \param rate The sampling rate of the source audio.
+ * \param base_quality Desired quality level, currently from -0.1 to 1.0 (lo to hi).
+ *
+ *
+ * \return Zero for success, or a negative number for failure.
+ *
+ * \retval 0 Success
+ * \retval OV_EFAULT Internal logic fault; indicates a bug or heap/stack corruption.
+ * \retval OV_EINVAL Invalid setup request, eg, out of range argument.
+ * \retval OV_EIMPL Unimplemented mode; unable to comply with quality level request.
+ */
+extern int vorbis_encode_init_vbr(vorbis_info *vi,
+ long channels,
+ long rate,
+
+ float base_quality
+ );
+
+/**
+ * This function performs the last stage of three-step encoding setup, as
+ * described in the API overview under managed bitrate modes.
+ *
+ * Before this function is called, the \ref vorbis_info struct should be
+ * initialized by using vorbis_info_init() from the libvorbis API, one of
+ * \ref vorbis_encode_setup_managed() or \ref vorbis_encode_setup_vbr() called to
+ * initialize the high-level encoding setup, and \ref vorbis_encode_ctl()
+ * called if necessary to make encoding setup changes.
+ * vorbis_encode_setup_init() finalizes the highlevel encoding structure into
+ * a complete encoding setup after which the application may make no further
+ * setup changes.
+ *
+ * After encoding, vorbis_info_clear() should be called.
+ *
+ * \param vi Pointer to an initialized \ref vorbis_info struct.
+ *
+ * \return Zero for success, and negative values for failure.
+ *
+ * \retval 0 Success.
+ * \retval OV_EFAULT Internal logic fault; indicates a bug or heap/stack corruption.
+ *
+ * \retval OV_EINVAL Attempt to use vorbis_encode_setup_init() without first
+ * calling one of vorbis_encode_setup_managed() or vorbis_encode_setup_vbr() to
+ * initialize the high-level encoding setup
+ *
+ */
+extern int vorbis_encode_setup_init(vorbis_info *vi);
+
+/**
+ * This function implements a generic interface to miscellaneous encoder
+ * settings similar to the classic UNIX 'ioctl()' system call. Applications
+ * may use vorbis_encode_ctl() to query or set bitrate management or quality
+ * mode details by using one of several \e request arguments detailed below.
+ * vorbis_encode_ctl() must be called after one of
+ * vorbis_encode_setup_managed() or vorbis_encode_setup_vbr(). When used
+ * to modify settings, \ref vorbis_encode_ctl() must be called before \ref
+ * vorbis_encode_setup_init().
+ *
+ * \param vi Pointer to an initialized vorbis_info struct.
+ *
+ * \param number Specifies the desired action; See \ref encctlcodes "the list
+ * of available requests".
+ *
+ * \param arg void * pointing to a data structure matching the request
+ * argument.
+ *
+ * \retval 0 Success. Any further return information (such as the result of a
+ * query) is placed into the storage pointed to by *arg.
+ *
+ * \retval OV_EINVAL Invalid argument, or an attempt to modify a setting after
+ * calling vorbis_encode_setup_init().
+ *
+ * \retval OV_EIMPL Unimplemented or unknown request
+ */
+extern int vorbis_encode_ctl(vorbis_info *vi,int number,void *arg);
+
+/**
+ * \deprecated This is a deprecated interface. Please use vorbis_encode_ctl()
+ * with the \ref ovectl_ratemanage2_arg struct and \ref
+ * OV_ECTL_RATEMANAGE2_GET and \ref OV_ECTL_RATEMANAGE2_SET calls in new code.
+ *
+ * The \ref ovectl_ratemanage_arg structure is used with vorbis_encode_ctl()
+ * and the \ref OV_ECTL_RATEMANAGE_GET, \ref OV_ECTL_RATEMANAGE_SET, \ref
+ * OV_ECTL_RATEMANAGE_AVG, \ref OV_ECTL_RATEMANAGE_HARD calls in order to
+ * query and modify specifics of the encoder's bitrate management
+ * configuration.
+*/
+struct ovectl_ratemanage_arg {
+ int management_active; /**< nonzero if bitrate management is active*/
+/** hard lower limit (in kilobits per second) below which the stream bitrate
+ will never be allowed for any given bitrate_hard_window seconds of time.*/
+ long bitrate_hard_min;
+/** hard upper limit (in kilobits per second) above which the stream bitrate
+ will never be allowed for any given bitrate_hard_window seconds of time.*/
+ long bitrate_hard_max;
+/** the window period (in seconds) used to regulate the hard bitrate minimum
+ and maximum*/
+ double bitrate_hard_window;
+/** soft lower limit (in kilobits per second) below which the average bitrate
+ tracker will start nudging the bitrate higher.*/
+ long bitrate_av_lo;
+/** soft upper limit (in kilobits per second) above which the average bitrate
+ tracker will start nudging the bitrate lower.*/
+ long bitrate_av_hi;
+/** the window period (in seconds) used to regulate the average bitrate
+ minimum and maximum.*/
+ double bitrate_av_window;
+/** Regulates the relative centering of the average and hard windows; in
+ libvorbis 1.0 and 1.0.1, the hard window regulation overlapped but
+ followed the average window regulation. In libvorbis 1.1 a bit-reservoir
+ interface replaces the old windowing interface; the older windowing
+ interface is simulated and this field has no effect.*/
+ double bitrate_av_window_center;
+};
+
+/**
+ * \name struct ovectl_ratemanage2_arg
+ *
+ * The ovectl_ratemanage2_arg structure is used with vorbis_encode_ctl() and
+ * the OV_ECTL_RATEMANAGE2_GET and OV_ECTL_RATEMANAGE2_SET calls in order to
+ * query and modify specifics of the encoder's bitrate management
+ * configuration.
+ *
+*/
+struct ovectl_ratemanage2_arg {
+ int management_active; /**< nonzero if bitrate management is active */
+/** Lower allowed bitrate limit in kilobits per second */
+ long bitrate_limit_min_kbps;
+/** Upper allowed bitrate limit in kilobits per second */
+ long bitrate_limit_max_kbps;
+ long bitrate_limit_reservoir_bits; /**<Size of the bitrate reservoir in bits */
+/** Regulates the bitrate reservoir's preferred fill level in a range from 0.0
+ * to 1.0; 0.0 tries to bank bits to buffer against future bitrate spikes, 1.0
+ * buffers against future sudden drops in instantaneous bitrate. Default is
+ * 0.1
+ */
+ double bitrate_limit_reservoir_bias;
+/** Average bitrate setting in kilobits per second */
+ long bitrate_average_kbps;
+/** Slew rate limit setting for average bitrate adjustment; sets the minimum
+ * time in seconds the bitrate tracker may swing from one extreme to the
+ * other when boosting or damping average bitrate.
+ */
+ double bitrate_average_damping;
+};
+
+
+/**
+ * \name vorbis_encode_ctl() codes
+ *
+ * \anchor encctlcodes
+ *
+ * These values are passed as the \c number parameter of vorbis_encode_ctl().
+ * The type of the referent of that function's \c arg pointer depends on these
+ * codes.
+ */
+/*@{*/
+
+/**
+ * Query the current encoder bitrate management setting.
+ *
+ *Argument: <tt>struct ovectl_ratemanage2_arg *</tt>
+ *
+ * Used to query the current encoder bitrate management setting. Also used to
+ * initialize fields of an ovectl_ratemanage2_arg structure for use with
+ * \ref OV_ECTL_RATEMANAGE2_SET.
+ */
+#define OV_ECTL_RATEMANAGE2_GET 0x14
+
+/**
+ * Set the current encoder bitrate management settings.
+ *
+ * Argument: <tt>struct ovectl_ratemanage2_arg *</tt>
+ *
+ * Used to set the current encoder bitrate management settings to the values
+ * listed in the ovectl_ratemanage2_arg. Passing a NULL pointer will disable
+ * bitrate management.
+*/
+#define OV_ECTL_RATEMANAGE2_SET 0x15
+
+/**
+ * Returns the current encoder hard-lowpass setting (kHz) in the double
+ * pointed to by arg.
+ *
+ * Argument: <tt>double *</tt>
+*/
+#define OV_ECTL_LOWPASS_GET 0x20
+
+/**
+ * Sets the encoder hard-lowpass to the value (kHz) pointed to by arg. Valid
+ * lowpass settings range from 2 to 99.
+ *
+ * Argument: <tt>double *</tt>
+*/
+#define OV_ECTL_LOWPASS_SET 0x21
+
+/**
+ * Returns the current encoder impulse block setting in the double pointed
+ * to by arg.
+ *
+ * Argument: <tt>double *</tt>
+*/
+#define OV_ECTL_IBLOCK_GET 0x30
+
+/**
+ * Sets the impulse block bias to the the value pointed to by arg.
+ *
+ * Argument: <tt>double *</tt>
+ *
+ * Valid range is -15.0 to 0.0 [default]. A negative impulse block bias will
+ * direct to encoder to use more bits when incoding short blocks that contain
+ * strong impulses, thus improving the accuracy of impulse encoding.
+ */
+#define OV_ECTL_IBLOCK_SET 0x31
+
+/**
+ * Returns the current encoder coupling setting in the int pointed
+ * to by arg.
+ *
+ * Argument: <tt>int *</tt>
+*/
+#define OV_ECTL_COUPLING_GET 0x40
+
+/**
+ * Enables/disables channel coupling in multichannel encoding according to arg.
+ *
+ * Argument: <tt>int *</tt>
+ *
+ * Zero disables channel coupling for multichannel inputs, nonzer enables
+ * channel coupling. Setting has no effect on monophonic encoding or
+ * multichannel counts that do not offer coupling. At present, coupling is
+ * available for stereo and 5.1 encoding.
+ */
+#define OV_ECTL_COUPLING_SET 0x41
+
+ /* deprecated rate management supported only for compatibility */
+
+/**
+ * Old interface to querying bitrate management settings.
+ *
+ * Deprecated after move to bit-reservoir style management in 1.1 rendered
+ * this interface partially obsolete.
+
+ * \deprecated Please use \ref OV_ECTL_RATEMANAGE2_GET instead.
+ *
+ * Argument: <tt>struct ovectl_ratemanage_arg *</tt>
+ */
+#define OV_ECTL_RATEMANAGE_GET 0x10
+/**
+ * Old interface to modifying bitrate management settings.
+ *
+ * deprecated after move to bit-reservoir style management in 1.1 rendered
+ * this interface partially obsolete.
+ *
+ * \deprecated Please use \ref OV_ECTL_RATEMANAGE2_SET instead.
+ *
+ * Argument: <tt>struct ovectl_ratemanage_arg *</tt>
+ */
+#define OV_ECTL_RATEMANAGE_SET 0x11
+/**
+ * Old interface to setting average-bitrate encoding mode.
+ *
+ * Deprecated after move to bit-reservoir style management in 1.1 rendered
+ * this interface partially obsolete.
+ *
+ * \deprecated Please use \ref OV_ECTL_RATEMANAGE2_SET instead.
+ *
+ * Argument: <tt>struct ovectl_ratemanage_arg *</tt>
+ */
+#define OV_ECTL_RATEMANAGE_AVG 0x12
+/**
+ * Old interface to setting bounded-bitrate encoding modes.
+ *
+ * deprecated after move to bit-reservoir style management in 1.1 rendered
+ * this interface partially obsolete.
+ *
+ * \deprecated Please use \ref OV_ECTL_RATEMANAGE2_SET instead.
+ *
+ * Argument: <tt>struct ovectl_ratemanage_arg *</tt>
+ */
+#define OV_ECTL_RATEMANAGE_HARD 0x13
+
+/*@}*/
+
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: stdio-based convenience library for opening/seeking/decoding
+ last mod: $Id: vorbisfile.c 17573 2010-10-27 14:53:59Z xiphmont $
+
+ ********************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <math.h>
+
+#include "vorbis/codec.h"
+
+/* we don't need or want the static callback symbols here */
+#define OV_EXCLUDE_STATIC_CALLBACKS
+#include "vorbis/vorbisfile.h"
+
+#include "os.h"
+#include "misc.h"
+
+/* A 'chained bitstream' is a Vorbis bitstream that contains more than
+ one logical bitstream arranged end to end (the only form of Ogg
+ multiplexing allowed in a Vorbis bitstream; grouping [parallel
+ multiplexing] is not allowed in Vorbis) */
+
+/* A Vorbis file can be played beginning to end (streamed) without
+ worrying ahead of time about chaining (see decoder_example.c). If
+ we have the whole file, however, and want random access
+ (seeking/scrubbing) or desire to know the total length/time of a
+ file, we need to account for the possibility of chaining. */
+
+/* We can handle things a number of ways; we can determine the entire
+ bitstream structure right off the bat, or find pieces on demand.
+ This example determines and caches structure for the entire
+ bitstream, but builds a virtual decoder on the fly when moving
+ between links in the chain. */
+
+/* There are also different ways to implement seeking. Enough
+ information exists in an Ogg bitstream to seek to
+ sample-granularity positions in the output. Or, one can seek by
+ picking some portion of the stream roughly in the desired area if
+ we only want coarse navigation through the stream. */
+
+/*************************************************************************
+ * Many, many internal helpers. The intention is not to be confusing;
+ * rampant duplication and monolithic function implementation would be
+ * harder to understand anyway. The high level functions are last. Begin
+ * grokking near the end of the file */
+
+/* read a little more data from the file/pipe into the ogg_sync framer
+*/
+#define CHUNKSIZE 65536 /* greater-than-page-size granularity seeking */
+#define READSIZE 2048 /* a smaller read size is needed for low-rate streaming. */
+
+static long _get_data(OggVorbis_File *vf){
+ errno=0;
+ if(!(vf->callbacks.read_func))return(-1);
+ if(vf->datasource){
+ char *buffer=ogg_sync_buffer(&vf->oy,READSIZE);
+ long bytes=(vf->callbacks.read_func)(buffer,1,READSIZE,vf->datasource);
+ if(bytes>0)ogg_sync_wrote(&vf->oy,bytes);
+ if(bytes==0 && errno)return(-1);
+ return(bytes);
+ }else
+ return(0);
+}
+
+/* save a tiny smidge of verbosity to make the code more readable */
+static int _seek_helper(OggVorbis_File *vf,ogg_int64_t offset){
+ if(vf->datasource){
+ if(!(vf->callbacks.seek_func)||
+ (vf->callbacks.seek_func)(vf->datasource, offset, SEEK_SET) == -1)
+ return OV_EREAD;
+ vf->offset=offset;
+ ogg_sync_reset(&vf->oy);
+ }else{
+ /* shouldn't happen unless someone writes a broken callback */
+ return OV_EFAULT;
+ }
+ return 0;
+}
+
+/* The read/seek functions track absolute position within the stream */
+
+/* from the head of the stream, get the next page. boundary specifies
+ if the function is allowed to fetch more data from the stream (and
+ how much) or only use internally buffered data.
+
+ boundary: -1) unbounded search
+ 0) read no additional data; use cached only
+ n) search for a new page beginning for n bytes
+
+ return: <0) did not find a page (OV_FALSE, OV_EOF, OV_EREAD)
+ n) found a page at absolute offset n */
+
+static ogg_int64_t _get_next_page(OggVorbis_File *vf,ogg_page *og,
+ ogg_int64_t boundary){
+ if(boundary>0)boundary+=vf->offset;
+ while(1){
+ long more;
+
+ if(boundary>0 && vf->offset>=boundary)return(OV_FALSE);
+ more=ogg_sync_pageseek(&vf->oy,og);
+
+ if(more<0){
+ /* skipped n bytes */
+ vf->offset-=more;
+ }else{
+ if(more==0){
+ /* send more paramedics */
+ if(!boundary)return(OV_FALSE);
+ {
+ long ret=_get_data(vf);
+ if(ret==0)return(OV_EOF);
+ if(ret<0)return(OV_EREAD);
+ }
+ }else{
+ /* got a page. Return the offset at the page beginning,
+ advance the internal offset past the page end */
+ ogg_int64_t ret=vf->offset;
+ vf->offset+=more;
+ return(ret);
+
+ }
+ }
+ }
+}
+
+/* find the latest page beginning before the current stream cursor
+ position. Much dirtier than the above as Ogg doesn't have any
+ backward search linkage. no 'readp' as it will certainly have to
+ read. */
+/* returns offset or OV_EREAD, OV_FAULT */
+static ogg_int64_t _get_prev_page(OggVorbis_File *vf,ogg_page *og){
+ ogg_int64_t begin=vf->offset;
+ ogg_int64_t end=begin;
+ ogg_int64_t ret;
+ ogg_int64_t offset=-1;
+
+ while(offset==-1){
+ begin-=CHUNKSIZE;
+ if(begin<0)
+ begin=0;
+
+ ret=_seek_helper(vf,begin);
+ if(ret)return(ret);
+
+ while(vf->offset<end){
+ memset(og,0,sizeof(*og));
+ ret=_get_next_page(vf,og,end-vf->offset);
+ if(ret==OV_EREAD)return(OV_EREAD);
+ if(ret<0){
+ break;
+ }else{
+ offset=ret;
+ }
+ }
+ }
+
+ /* In a fully compliant, non-multiplexed stream, we'll still be
+ holding the last page. In multiplexed (or noncompliant streams),
+ we will probably have to re-read the last page we saw */
+ if(og->header_len==0){
+ ret=_seek_helper(vf,offset);
+ if(ret)return(ret);
+
+ ret=_get_next_page(vf,og,CHUNKSIZE);
+ if(ret<0)
+ /* this shouldn't be possible */
+ return(OV_EFAULT);
+ }
+
+ return(offset);
+}
+
+static void _add_serialno(ogg_page *og,long **serialno_list, int *n){
+ long s = ogg_page_serialno(og);
+ (*n)++;
+
+ if(*serialno_list){
+ *serialno_list = _ogg_realloc(*serialno_list, sizeof(**serialno_list)*(*n));
+ }else{
+ *serialno_list = _ogg_malloc(sizeof(**serialno_list));
+ }
+
+ (*serialno_list)[(*n)-1] = s;
+}
+
+/* returns nonzero if found */
+static int _lookup_serialno(long s, long *serialno_list, int n){
+ if(serialno_list){
+ while(n--){
+ if(*serialno_list == s) return 1;
+ serialno_list++;
+ }
+ }
+ return 0;
+}
+
+static int _lookup_page_serialno(ogg_page *og, long *serialno_list, int n){
+ long s = ogg_page_serialno(og);
+ return _lookup_serialno(s,serialno_list,n);
+}
+
+/* performs the same search as _get_prev_page, but prefers pages of
+ the specified serial number. If a page of the specified serialno is
+ spotted during the seek-back-and-read-forward, it will return the
+ info of last page of the matching serial number instead of the very
+ last page. If no page of the specified serialno is seen, it will
+ return the info of last page and alter *serialno. */
+static ogg_int64_t _get_prev_page_serial(OggVorbis_File *vf,
+ long *serial_list, int serial_n,
+ int *serialno, ogg_int64_t *granpos){
+ ogg_page og;
+ ogg_int64_t begin=vf->offset;
+ ogg_int64_t end=begin;
+ ogg_int64_t ret;
+
+ ogg_int64_t prefoffset=-1;
+ ogg_int64_t offset=-1;
+ ogg_int64_t ret_serialno=-1;
+ ogg_int64_t ret_gran=-1;
+
+ while(offset==-1){
+ begin-=CHUNKSIZE;
+ if(begin<0)
+ begin=0;
+
+ ret=_seek_helper(vf,begin);
+ if(ret)return(ret);
+
+ while(vf->offset<end){
+ ret=_get_next_page(vf,&og,end-vf->offset);
+ if(ret==OV_EREAD)return(OV_EREAD);
+ if(ret<0){
+ break;
+ }else{
+ ret_serialno=ogg_page_serialno(&og);
+ ret_gran=ogg_page_granulepos(&og);
+ offset=ret;
+
+ if(ret_serialno == *serialno){
+ prefoffset=ret;
+ *granpos=ret_gran;
+ }
+
+ if(!_lookup_serialno(ret_serialno,serial_list,serial_n)){
+ /* we fell off the end of the link, which means we seeked
+ back too far and shouldn't have been looking in that link
+ to begin with. If we found the preferred serial number,
+ forget that we saw it. */
+ prefoffset=-1;
+ }
+ }
+ }
+ }
+
+ /* we're not interested in the page... just the serialno and granpos. */
+ if(prefoffset>=0)return(prefoffset);
+
+ *serialno = ret_serialno;
+ *granpos = ret_gran;
+ return(offset);
+
+}
+
+/* uses the local ogg_stream storage in vf; this is important for
+ non-streaming input sources */
+static int _fetch_headers(OggVorbis_File *vf,vorbis_info *vi,vorbis_comment *vc,
+ long **serialno_list, int *serialno_n,
+ ogg_page *og_ptr){
+ ogg_page og;
+ ogg_packet op;
+ int i,ret;
+ int allbos=0;
+
+ if(!og_ptr){
+ ogg_int64_t llret=_get_next_page(vf,&og,CHUNKSIZE);
+ if(llret==OV_EREAD)return(OV_EREAD);
+ if(llret<0)return(OV_ENOTVORBIS);
+ og_ptr=&og;
+ }
+
+ vorbis_info_init(vi);
+ vorbis_comment_init(vc);
+ vf->ready_state=OPENED;
+
+ /* extract the serialnos of all BOS pages + the first set of vorbis
+ headers we see in the link */
+
+ while(ogg_page_bos(og_ptr)){
+ if(serialno_list){
+ if(_lookup_page_serialno(og_ptr,*serialno_list,*serialno_n)){
+ /* a dupe serialnumber in an initial header packet set == invalid stream */
+ if(*serialno_list)_ogg_free(*serialno_list);
+ *serialno_list=0;
+ *serialno_n=0;
+ ret=OV_EBADHEADER;
+ goto bail_header;
+ }
+
+ _add_serialno(og_ptr,serialno_list,serialno_n);
+ }
+
+ if(vf->ready_state<STREAMSET){
+ /* we don't have a vorbis stream in this link yet, so begin
+ prospective stream setup. We need a stream to get packets */
+ ogg_stream_reset_serialno(&vf->os,ogg_page_serialno(og_ptr));
+ ogg_stream_pagein(&vf->os,og_ptr);
+
+ if(ogg_stream_packetout(&vf->os,&op) > 0 &&
+ vorbis_synthesis_idheader(&op)){
+ /* vorbis header; continue setup */
+ vf->ready_state=STREAMSET;
+ if((ret=vorbis_synthesis_headerin(vi,vc,&op))){
+ ret=OV_EBADHEADER;
+ goto bail_header;
+ }
+ }
+ }
+
+ /* get next page */
+ {
+ ogg_int64_t llret=_get_next_page(vf,og_ptr,CHUNKSIZE);
+ if(llret==OV_EREAD){
+ ret=OV_EREAD;
+ goto bail_header;
+ }
+ if(llret<0){
+ ret=OV_ENOTVORBIS;
+ goto bail_header;
+ }
+
+ /* if this page also belongs to our vorbis stream, submit it and break */
+ if(vf->ready_state==STREAMSET &&
+ vf->os.serialno == ogg_page_serialno(og_ptr)){
+ ogg_stream_pagein(&vf->os,og_ptr);
+ break;
+ }
+ }
+ }
+
+ if(vf->ready_state!=STREAMSET){
+ ret = OV_ENOTVORBIS;
+ goto bail_header;
+ }
+
+ while(1){
+
+ i=0;
+ while(i<2){ /* get a page loop */
+
+ while(i<2){ /* get a packet loop */
+
+ int result=ogg_stream_packetout(&vf->os,&op);
+ if(result==0)break;
+ if(result==-1){
+ ret=OV_EBADHEADER;
+ goto bail_header;
+ }
+
+ if((ret=vorbis_synthesis_headerin(vi,vc,&op)))
+ goto bail_header;
+
+ i++;
+ }
+
+ while(i<2){
+ if(_get_next_page(vf,og_ptr,CHUNKSIZE)<0){
+ ret=OV_EBADHEADER;
+ goto bail_header;
+ }
+
+ /* if this page belongs to the correct stream, go parse it */
+ if(vf->os.serialno == ogg_page_serialno(og_ptr)){
+ ogg_stream_pagein(&vf->os,og_ptr);
+ break;
+ }
+
+ /* if we never see the final vorbis headers before the link
+ ends, abort */
+ if(ogg_page_bos(og_ptr)){
+ if(allbos){
+ ret = OV_EBADHEADER;
+ goto bail_header;
+ }else
+ allbos=1;
+ }
+
+ /* otherwise, keep looking */
+ }
+ }
+
+ return 0;
+ }
+
+ bail_header:
+ vorbis_info_clear(vi);
+ vorbis_comment_clear(vc);
+ vf->ready_state=OPENED;
+
+ return ret;
+}
+
+/* Starting from current cursor position, get initial PCM offset of
+ next page. Consumes the page in the process without decoding
+ audio, however this is only called during stream parsing upon
+ seekable open. */
+static ogg_int64_t _initial_pcmoffset(OggVorbis_File *vf, vorbis_info *vi){
+ ogg_page og;
+ ogg_int64_t accumulated=0;
+ long lastblock=-1;
+ int result;
+ int serialno = vf->os.serialno;
+
+ while(1){
+ ogg_packet op;
+ if(_get_next_page(vf,&og,-1)<0)
+ break; /* should not be possible unless the file is truncated/mangled */
+
+ if(ogg_page_bos(&og)) break;
+ if(ogg_page_serialno(&og)!=serialno) continue;
+
+ /* count blocksizes of all frames in the page */
+ ogg_stream_pagein(&vf->os,&og);
+ while((result=ogg_stream_packetout(&vf->os,&op))){
+ if(result>0){ /* ignore holes */
+ long thisblock=vorbis_packet_blocksize(vi,&op);
+ if(lastblock!=-1)
+ accumulated+=(lastblock+thisblock)>>2;
+ lastblock=thisblock;
+ }
+ }
+
+ if(ogg_page_granulepos(&og)!=-1){
+ /* pcm offset of last packet on the first audio page */
+ accumulated= ogg_page_granulepos(&og)-accumulated;
+ break;
+ }
+ }
+
+ /* less than zero? Either a corrupt file or a stream with samples
+ trimmed off the beginning, a normal occurrence; in both cases set
+ the offset to zero */
+ if(accumulated<0)accumulated=0;
+
+ return accumulated;
+}
+
+/* finds each bitstream link one at a time using a bisection search
+ (has to begin by knowing the offset of the lb's initial page).
+ Recurses for each link so it can alloc the link storage after
+ finding them all, then unroll and fill the cache at the same time */
+static int _bisect_forward_serialno(OggVorbis_File *vf,
+ ogg_int64_t begin,
+ ogg_int64_t searched,
+ ogg_int64_t end,
+ ogg_int64_t endgran,
+ int endserial,
+ long *currentno_list,
+ int currentnos,
+ long m){
+ ogg_int64_t pcmoffset;
+ ogg_int64_t dataoffset=searched;
+ ogg_int64_t endsearched=end;
+ ogg_int64_t next=end;
+ ogg_int64_t searchgran=-1;
+ ogg_page og;
+ ogg_int64_t ret,last;
+ int serialno = vf->os.serialno;
+
+ /* invariants:
+ we have the headers and serialnos for the link beginning at 'begin'
+ we have the offset and granpos of the last page in the file (potentially
+ not a page we care about)
+ */
+
+ /* Is the last page in our list of current serialnumbers? */
+ if(_lookup_serialno(endserial,currentno_list,currentnos)){
+
+ /* last page is in the starting serialno list, so we've bisected
+ down to (or just started with) a single link. Now we need to
+ find the last vorbis page belonging to the first vorbis stream
+ for this link. */
+
+ while(endserial != serialno){
+ endserial = serialno;
+ vf->offset=_get_prev_page_serial(vf,currentno_list,currentnos,&endserial,&endgran);
+ }
+
+ vf->links=m+1;
+ if(vf->offsets)_ogg_free(vf->offsets);
+ if(vf->serialnos)_ogg_free(vf->serialnos);
+ if(vf->dataoffsets)_ogg_free(vf->dataoffsets);
+
+ vf->offsets=_ogg_malloc((vf->links+1)*sizeof(*vf->offsets));
+ vf->vi=_ogg_realloc(vf->vi,vf->links*sizeof(*vf->vi));
+ vf->vc=_ogg_realloc(vf->vc,vf->links*sizeof(*vf->vc));
+ vf->serialnos=_ogg_malloc(vf->links*sizeof(*vf->serialnos));
+ vf->dataoffsets=_ogg_malloc(vf->links*sizeof(*vf->dataoffsets));
+ vf->pcmlengths=_ogg_malloc(vf->links*2*sizeof(*vf->pcmlengths));
+
+ vf->offsets[m+1]=end;
+ vf->offsets[m]=begin;
+ vf->pcmlengths[m*2+1]=(endgran<0?0:endgran);
+
+ }else{
+
+ long *next_serialno_list=NULL;
+ int next_serialnos=0;
+ vorbis_info vi;
+ vorbis_comment vc;
+
+ /* the below guards against garbage seperating the last and
+ first pages of two links. */
+ while(searched<endsearched){
+ ogg_int64_t bisect;
+
+ if(endsearched-searched<CHUNKSIZE){
+ bisect=searched;
+ }else{
+ bisect=(searched+endsearched)/2;
+ }
+
+ if(bisect != vf->offset){
+ ret=_seek_helper(vf,bisect);
+ if(ret)return(ret);
+ }
+
+ last=_get_next_page(vf,&og,-1);
+ if(last==OV_EREAD)return(OV_EREAD);
+ if(last<0 || !_lookup_page_serialno(&og,currentno_list,currentnos)){
+ endsearched=bisect;
+ if(last>=0)next=last;
+ }else{
+ searched=vf->offset;
+ }
+ }
+
+ /* Bisection point found */
+
+ /* for the time being, fetch end PCM offset the simple way */
+ {
+ int testserial = serialno+1;
+ vf->offset = next;
+ while(testserial != serialno){
+ testserial = serialno;
+ vf->offset=_get_prev_page_serial(vf,currentno_list,currentnos,&testserial,&searchgran);
+ }
+ }
+
+ if(vf->offset!=next){
+ ret=_seek_helper(vf,next);
+ if(ret)return(ret);
+ }
+
+ ret=_fetch_headers(vf,&vi,&vc,&next_serialno_list,&next_serialnos,NULL);
+ if(ret)return(ret);
+ serialno = vf->os.serialno;
+ dataoffset = vf->offset;
+
+ /* this will consume a page, however the next bistection always
+ starts with a raw seek */
+ pcmoffset = _initial_pcmoffset(vf,&vi);
+
+ ret=_bisect_forward_serialno(vf,next,vf->offset,end,endgran,endserial,
+ next_serialno_list,next_serialnos,m+1);
+ if(ret)return(ret);
+
+ if(next_serialno_list)_ogg_free(next_serialno_list);
+
+ vf->offsets[m+1]=next;
+ vf->serialnos[m+1]=serialno;
+ vf->dataoffsets[m+1]=dataoffset;
+
+ vf->vi[m+1]=vi;
+ vf->vc[m+1]=vc;
+
+ vf->pcmlengths[m*2+1]=searchgran;
+ vf->pcmlengths[m*2+2]=pcmoffset;
+ vf->pcmlengths[m*2+3]-=pcmoffset;
+ if(vf->pcmlengths[m*2+3]<0)vf->pcmlengths[m*2+3]=0;
+ }
+ return(0);
+}
+
+static int _make_decode_ready(OggVorbis_File *vf){
+ if(vf->ready_state>STREAMSET)return 0;
+ if(vf->ready_state<STREAMSET)return OV_EFAULT;
+ if(vf->seekable){
+ if(vorbis_synthesis_init(&vf->vd,vf->vi+vf->current_link))
+ return OV_EBADLINK;
+ }else{
+ if(vorbis_synthesis_init(&vf->vd,vf->vi))
+ return OV_EBADLINK;
+ }
+ vorbis_block_init(&vf->vd,&vf->vb);
+ vf->ready_state=INITSET;
+ vf->bittrack=0.f;
+ vf->samptrack=0.f;
+ return 0;
+}
+
+static int _open_seekable2(OggVorbis_File *vf){
+ ogg_int64_t dataoffset=vf->dataoffsets[0],end,endgran=-1;
+ int endserial=vf->os.serialno;
+ int serialno=vf->os.serialno;
+
+ /* we're partially open and have a first link header state in
+ storage in vf */
+
+ /* fetch initial PCM offset */
+ ogg_int64_t pcmoffset = _initial_pcmoffset(vf,vf->vi);
+
+ /* we can seek, so set out learning all about this file */
+ if(vf->callbacks.seek_func && vf->callbacks.tell_func){
+ (vf->callbacks.seek_func)(vf->datasource,0,SEEK_END);
+ vf->offset=vf->end=(vf->callbacks.tell_func)(vf->datasource);
+ }else{
+ vf->offset=vf->end=-1;
+ }
+
+ /* If seek_func is implemented, tell_func must also be implemented */
+ if(vf->end==-1) return(OV_EINVAL);
+
+ /* Get the offset of the last page of the physical bitstream, or, if
+ we're lucky the last vorbis page of this link as most OggVorbis
+ files will contain a single logical bitstream */
+ end=_get_prev_page_serial(vf,vf->serialnos+2,vf->serialnos[1],&endserial,&endgran);
+ if(end<0)return(end);
+
+ /* now determine bitstream structure recursively */
+ if(_bisect_forward_serialno(vf,0,dataoffset,vf->offset,endgran,endserial,
+ vf->serialnos+2,vf->serialnos[1],0)<0)return(OV_EREAD);
+
+ vf->offsets[0]=0;
+ vf->serialnos[0]=serialno;
+ vf->dataoffsets[0]=dataoffset;
+ vf->pcmlengths[0]=pcmoffset;
+ vf->pcmlengths[1]-=pcmoffset;
+ if(vf->pcmlengths[1]<0)vf->pcmlengths[1]=0;
+
+ return(ov_raw_seek(vf,dataoffset));
+}
+
+/* clear out the current logical bitstream decoder */
+static void _decode_clear(OggVorbis_File *vf){
+ vorbis_dsp_clear(&vf->vd);
+ vorbis_block_clear(&vf->vb);
+ vf->ready_state=OPENED;
+}
+
+/* fetch and process a packet. Handles the case where we're at a
+ bitstream boundary and dumps the decoding machine. If the decoding
+ machine is unloaded, it loads it. It also keeps pcm_offset up to
+ date (seek and read both use this. seek uses a special hack with
+ readp).
+
+ return: <0) error, OV_HOLE (lost packet) or OV_EOF
+ 0) need more data (only if readp==0)
+ 1) got a packet
+*/
+
+static int _fetch_and_process_packet(OggVorbis_File *vf,
+ ogg_packet *op_in,
+ int readp,
+ int spanp){
+ ogg_page og;
+
+ /* handle one packet. Try to fetch it from current stream state */
+ /* extract packets from page */
+ while(1){
+
+ if(vf->ready_state==STREAMSET){
+ int ret=_make_decode_ready(vf);
+ if(ret<0)return ret;
+ }
+
+ /* process a packet if we can. */
+
+ if(vf->ready_state==INITSET){
+ int hs=vorbis_synthesis_halfrate_p(vf->vi);
+
+ while(1) {
+ ogg_packet op;
+ ogg_packet *op_ptr=(op_in?op_in:&op);
+ int result=ogg_stream_packetout(&vf->os,op_ptr);
+ ogg_int64_t granulepos;
+
+ op_in=NULL;
+ if(result==-1)return(OV_HOLE); /* hole in the data. */
+ if(result>0){
+ /* got a packet. process it */
+ granulepos=op_ptr->granulepos;
+ if(!vorbis_synthesis(&vf->vb,op_ptr)){ /* lazy check for lazy
+ header handling. The
+ header packets aren't
+ audio, so if/when we
+ submit them,
+ vorbis_synthesis will
+ reject them */
+
+ /* suck in the synthesis data and track bitrate */
+ {
+ int oldsamples=vorbis_synthesis_pcmout(&vf->vd,NULL);
+ /* for proper use of libvorbis within libvorbisfile,
+ oldsamples will always be zero. */
+ if(oldsamples)return(OV_EFAULT);
+
+ vorbis_synthesis_blockin(&vf->vd,&vf->vb);
+ vf->samptrack+=(vorbis_synthesis_pcmout(&vf->vd,NULL)<<hs);
+ vf->bittrack+=op_ptr->bytes*8;
+ }
+
+ /* update the pcm offset. */
+ if(granulepos!=-1 && !op_ptr->e_o_s){
+ int link=(vf->seekable?vf->current_link:0);
+ int i,samples;
+
+ /* this packet has a pcm_offset on it (the last packet
+ completed on a page carries the offset) After processing
+ (above), we know the pcm position of the *last* sample
+ ready to be returned. Find the offset of the *first*
+
+ As an aside, this trick is inaccurate if we begin
+ reading anew right at the last page; the end-of-stream
+ granulepos declares the last frame in the stream, and the
+ last packet of the last page may be a partial frame.
+ So, we need a previous granulepos from an in-sequence page
+ to have a reference point. Thus the !op_ptr->e_o_s clause
+ above */
+
+ if(vf->seekable && link>0)
+ granulepos-=vf->pcmlengths[link*2];
+ if(granulepos<0)granulepos=0; /* actually, this
+ shouldn't be possible
+ here unless the stream
+ is very broken */
+
+ samples=(vorbis_synthesis_pcmout(&vf->vd,NULL)<<hs);
+
+ granulepos-=samples;
+ for(i=0;i<link;i++)
+ granulepos+=vf->pcmlengths[i*2+1];
+ vf->pcm_offset=granulepos;
+ }
+ return(1);
+ }
+ }
+ else
+ break;
+ }
+ }
+
+ if(vf->ready_state>=OPENED){
+ ogg_int64_t ret;
+
+ while(1){
+ /* the loop is not strictly necessary, but there's no sense in
+ doing the extra checks of the larger loop for the common
+ case in a multiplexed bistream where the page is simply
+ part of a different logical bitstream; keep reading until
+ we get one with the correct serialno */
+
+ if(!readp)return(0);
+ if((ret=_get_next_page(vf,&og,-1))<0){
+ return(OV_EOF); /* eof. leave unitialized */
+ }
+
+ /* bitrate tracking; add the header's bytes here, the body bytes
+ are done by packet above */
+ vf->bittrack+=og.header_len*8;
+
+ if(vf->ready_state==INITSET){
+ if(vf->current_serialno!=ogg_page_serialno(&og)){
+
+ /* two possibilities:
+ 1) our decoding just traversed a bitstream boundary
+ 2) another stream is multiplexed into this logical section */
+
+ if(ogg_page_bos(&og)){
+ /* boundary case */
+ if(!spanp)
+ return(OV_EOF);
+
+ _decode_clear(vf);
+
+ if(!vf->seekable){
+ vorbis_info_clear(vf->vi);
+ vorbis_comment_clear(vf->vc);
+ }
+ break;
+
+ }else
+ continue; /* possibility #2 */
+ }
+ }
+
+ break;
+ }
+ }
+
+ /* Do we need to load a new machine before submitting the page? */
+ /* This is different in the seekable and non-seekable cases.
+
+ In the seekable case, we already have all the header
+ information loaded and cached; we just initialize the machine
+ with it and continue on our merry way.
+
+ In the non-seekable (streaming) case, we'll only be at a
+ boundary if we just left the previous logical bitstream and
+ we're now nominally at the header of the next bitstream
+ */
+
+ if(vf->ready_state!=INITSET){
+ int link;
+
+ if(vf->ready_state<STREAMSET){
+ if(vf->seekable){
+ long serialno = ogg_page_serialno(&og);
+
+ /* match the serialno to bitstream section. We use this rather than
+ offset positions to avoid problems near logical bitstream
+ boundaries */
+
+ for(link=0;link<vf->links;link++)
+ if(vf->serialnos[link]==serialno)break;
+
+ if(link==vf->links) continue; /* not the desired Vorbis
+ bitstream section; keep
+ trying */
+
+ vf->current_serialno=serialno;
+ vf->current_link=link;
+
+ ogg_stream_reset_serialno(&vf->os,vf->current_serialno);
+ vf->ready_state=STREAMSET;
+
+ }else{
+ /* we're streaming */
+ /* fetch the three header packets, build the info struct */
+
+ int ret=_fetch_headers(vf,vf->vi,vf->vc,NULL,NULL,&og);
+ if(ret)return(ret);
+ vf->current_serialno=vf->os.serialno;
+ vf->current_link++;
+ link=0;
+ }
+ }
+ }
+
+ /* the buffered page is the data we want, and we're ready for it;
+ add it to the stream state */
+ ogg_stream_pagein(&vf->os,&og);
+
+ }
+}
+
+/* if, eg, 64 bit stdio is configured by default, this will build with
+ fseek64 */
+static int _fseek64_wrap(FILE *f,ogg_int64_t off,int whence){
+ if(f==NULL)return(-1);
+ return fseek(f,off,whence);
+}
+
+static int _ov_open1(void *f,OggVorbis_File *vf,const char *initial,
+ long ibytes, ov_callbacks callbacks){
+ int offsettest=((f && callbacks.seek_func)?callbacks.seek_func(f,0,SEEK_CUR):-1);
+ long *serialno_list=NULL;
+ int serialno_list_size=0;
+ int ret;
+
+ memset(vf,0,sizeof(*vf));
+ vf->datasource=f;
+ vf->callbacks = callbacks;
+
+ /* init the framing state */
+ ogg_sync_init(&vf->oy);
+
+ /* perhaps some data was previously read into a buffer for testing
+ against other stream types. Allow initialization from this
+ previously read data (especially as we may be reading from a
+ non-seekable stream) */
+ if(initial){
+ char *buffer=ogg_sync_buffer(&vf->oy,ibytes);
+ memcpy(buffer,initial,ibytes);
+ ogg_sync_wrote(&vf->oy,ibytes);
+ }
+
+ /* can we seek? Stevens suggests the seek test was portable */
+ if(offsettest!=-1)vf->seekable=1;
+
+ /* No seeking yet; Set up a 'single' (current) logical bitstream
+ entry for partial open */
+ vf->links=1;
+ vf->vi=_ogg_calloc(vf->links,sizeof(*vf->vi));
+ vf->vc=_ogg_calloc(vf->links,sizeof(*vf->vc));
+ ogg_stream_init(&vf->os,-1); /* fill in the serialno later */
+
+ /* Fetch all BOS pages, store the vorbis header and all seen serial
+ numbers, load subsequent vorbis setup headers */
+ if((ret=_fetch_headers(vf,vf->vi,vf->vc,&serialno_list,&serialno_list_size,NULL))<0){
+ vf->datasource=NULL;
+ ov_clear(vf);
+ }else{
+ /* serial number list for first link needs to be held somewhere
+ for second stage of seekable stream open; this saves having to
+ seek/reread first link's serialnumber data then. */
+ vf->serialnos=_ogg_calloc(serialno_list_size+2,sizeof(*vf->serialnos));
+ vf->serialnos[0]=vf->current_serialno=vf->os.serialno;
+ vf->serialnos[1]=serialno_list_size;
+ memcpy(vf->serialnos+2,serialno_list,serialno_list_size*sizeof(*vf->serialnos));
+
+ vf->offsets=_ogg_calloc(1,sizeof(*vf->offsets));
+ vf->dataoffsets=_ogg_calloc(1,sizeof(*vf->dataoffsets));
+ vf->offsets[0]=0;
+ vf->dataoffsets[0]=vf->offset;
+
+ vf->ready_state=PARTOPEN;
+ }
+ if(serialno_list)_ogg_free(serialno_list);
+ return(ret);
+}
+
+static int _ov_open2(OggVorbis_File *vf){
+ if(vf->ready_state != PARTOPEN) return OV_EINVAL;
+ vf->ready_state=OPENED;
+ if(vf->seekable){
+ int ret=_open_seekable2(vf);
+ if(ret){
+ vf->datasource=NULL;
+ ov_clear(vf);
+ }
+ return(ret);
+ }else
+ vf->ready_state=STREAMSET;
+
+ return 0;
+}
+
+
+/* clear out the OggVorbis_File struct */
+int ov_clear(OggVorbis_File *vf){
+ if(vf){
+ vorbis_block_clear(&vf->vb);
+ vorbis_dsp_clear(&vf->vd);
+ ogg_stream_clear(&vf->os);
+
+ if(vf->vi && vf->links){
+ int i;
+ for(i=0;i<vf->links;i++){
+ vorbis_info_clear(vf->vi+i);
+ vorbis_comment_clear(vf->vc+i);
+ }
+ _ogg_free(vf->vi);
+ _ogg_free(vf->vc);
+ }
+ if(vf->dataoffsets)_ogg_free(vf->dataoffsets);
+ if(vf->pcmlengths)_ogg_free(vf->pcmlengths);
+ if(vf->serialnos)_ogg_free(vf->serialnos);
+ if(vf->offsets)_ogg_free(vf->offsets);
+ ogg_sync_clear(&vf->oy);
+ if(vf->datasource && vf->callbacks.close_func)
+ (vf->callbacks.close_func)(vf->datasource);
+ memset(vf,0,sizeof(*vf));
+ }
+#ifdef DEBUG_LEAKS
+ _VDBG_dump();
+#endif
+ return(0);
+}
+
+/* inspects the OggVorbis file and finds/documents all the logical
+ bitstreams contained in it. Tries to be tolerant of logical
+ bitstream sections that are truncated/woogie.
+
+ return: -1) error
+ 0) OK
+*/
+
+int ov_open_callbacks(void *f,OggVorbis_File *vf,
+ const char *initial,long ibytes,ov_callbacks callbacks){
+ int ret=_ov_open1(f,vf,initial,ibytes,callbacks);
+ if(ret)return ret;
+ return _ov_open2(vf);
+}
+
+int ov_open(FILE *f,OggVorbis_File *vf,const char *initial,long ibytes){
+ ov_callbacks callbacks = {
+ (size_t (*)(void *, size_t, size_t, void *)) fread,
+ (int (*)(void *, ogg_int64_t, int)) _fseek64_wrap,
+ (int (*)(void *)) fclose,
+ (long (*)(void *)) ftell
+ };
+
+ return ov_open_callbacks((void *)f, vf, initial, ibytes, callbacks);
+}
+
+int ov_fopen(const char *path,OggVorbis_File *vf){
+ int ret;
+ FILE *f = fopen(path,"rb");
+ if(!f) return -1;
+
+ ret = ov_open(f,vf,NULL,0);
+ if(ret) fclose(f);
+ return ret;
+}
+
+
+/* cheap hack for game usage where downsampling is desirable; there's
+ no need for SRC as we can just do it cheaply in libvorbis. */
+
+int ov_halfrate(OggVorbis_File *vf,int flag){
+ int i;
+ if(vf->vi==NULL)return OV_EINVAL;
+ if(vf->ready_state>STREAMSET){
+ /* clear out stream state; dumping the decode machine is needed to
+ reinit the MDCT lookups. */
+ vorbis_dsp_clear(&vf->vd);
+ vorbis_block_clear(&vf->vb);
+ vf->ready_state=STREAMSET;
+ if(vf->pcm_offset>=0){
+ ogg_int64_t pos=vf->pcm_offset;
+ vf->pcm_offset=-1; /* make sure the pos is dumped if unseekable */
+ ov_pcm_seek(vf,pos);
+ }
+ }
+
+ for(i=0;i<vf->links;i++){
+ if(vorbis_synthesis_halfrate(vf->vi+i,flag)){
+ if(flag) ov_halfrate(vf,0);
+ return OV_EINVAL;
+ }
+ }
+ return 0;
+}
+
+int ov_halfrate_p(OggVorbis_File *vf){
+ if(vf->vi==NULL)return OV_EINVAL;
+ return vorbis_synthesis_halfrate_p(vf->vi);
+}
+
+/* Only partially open the vorbis file; test for Vorbisness, and load
+ the headers for the first chain. Do not seek (although test for
+ seekability). Use ov_test_open to finish opening the file, else
+ ov_clear to close/free it. Same return codes as open. */
+
+int ov_test_callbacks(void *f,OggVorbis_File *vf,
+ const char *initial,long ibytes,ov_callbacks callbacks)
+{
+ return _ov_open1(f,vf,initial,ibytes,callbacks);
+}
+
+int ov_test(FILE *f,OggVorbis_File *vf,const char *initial,long ibytes){
+ ov_callbacks callbacks = {
+ (size_t (*)(void *, size_t, size_t, void *)) fread,
+ (int (*)(void *, ogg_int64_t, int)) _fseek64_wrap,
+ (int (*)(void *)) fclose,
+ (long (*)(void *)) ftell
+ };
+
+ return ov_test_callbacks((void *)f, vf, initial, ibytes, callbacks);
+}
+
+int ov_test_open(OggVorbis_File *vf){
+ if(vf->ready_state!=PARTOPEN)return(OV_EINVAL);
+ return _ov_open2(vf);
+}
+
+/* How many logical bitstreams in this physical bitstream? */
+long ov_streams(OggVorbis_File *vf){
+ return vf->links;
+}
+
+/* Is the FILE * associated with vf seekable? */
+long ov_seekable(OggVorbis_File *vf){
+ return vf->seekable;
+}
+
+/* returns the bitrate for a given logical bitstream or the entire
+ physical bitstream. If the file is open for random access, it will
+ find the *actual* average bitrate. If the file is streaming, it
+ returns the nominal bitrate (if set) else the average of the
+ upper/lower bounds (if set) else -1 (unset).
+
+ If you want the actual bitrate field settings, get them from the
+ vorbis_info structs */
+
+long ov_bitrate(OggVorbis_File *vf,int i){
+ if(vf->ready_state<OPENED)return(OV_EINVAL);
+ if(i>=vf->links)return(OV_EINVAL);
+ if(!vf->seekable && i!=0)return(ov_bitrate(vf,0));
+ if(i<0){
+ ogg_int64_t bits=0;
+ int i;
+ float br;
+ for(i=0;i<vf->links;i++)
+ bits+=(vf->offsets[i+1]-vf->dataoffsets[i])*8;
+ /* This once read: return(rint(bits/ov_time_total(vf,-1)));
+ * gcc 3.x on x86 miscompiled this at optimisation level 2 and above,
+ * so this is slightly transformed to make it work.
+ */
+ br = bits/ov_time_total(vf,-1);
+ return(rint(br));
+ }else{
+ if(vf->seekable){
+ /* return the actual bitrate */
+ return(rint((vf->offsets[i+1]-vf->dataoffsets[i])*8/ov_time_total(vf,i)));
+ }else{
+ /* return nominal if set */
+ if(vf->vi[i].bitrate_nominal>0){
+ return vf->vi[i].bitrate_nominal;
+ }else{
+ if(vf->vi[i].bitrate_upper>0){
+ if(vf->vi[i].bitrate_lower>0){
+ return (vf->vi[i].bitrate_upper+vf->vi[i].bitrate_lower)/2;
+ }else{
+ return vf->vi[i].bitrate_upper;
+ }
+ }
+ return(OV_FALSE);
+ }
+ }
+ }
+}
+
+/* returns the actual bitrate since last call. returns -1 if no
+ additional data to offer since last call (or at beginning of stream),
+ EINVAL if stream is only partially open
+*/
+long ov_bitrate_instant(OggVorbis_File *vf){
+ int link=(vf->seekable?vf->current_link:0);
+ long ret;
+ if(vf->ready_state<OPENED)return(OV_EINVAL);
+ if(vf->samptrack==0)return(OV_FALSE);
+ ret=vf->bittrack/vf->samptrack*vf->vi[link].rate+.5;
+ vf->bittrack=0.f;
+ vf->samptrack=0.f;
+ return(ret);
+}
+
+/* Guess */
+long ov_serialnumber(OggVorbis_File *vf,int i){
+ if(i>=vf->links)return(ov_serialnumber(vf,vf->links-1));
+ if(!vf->seekable && i>=0)return(ov_serialnumber(vf,-1));
+ if(i<0){
+ return(vf->current_serialno);
+ }else{
+ return(vf->serialnos[i]);
+ }
+}
+
+/* returns: total raw (compressed) length of content if i==-1
+ raw (compressed) length of that logical bitstream for i==0 to n
+ OV_EINVAL if the stream is not seekable (we can't know the length)
+ or if stream is only partially open
+*/
+ogg_int64_t ov_raw_total(OggVorbis_File *vf,int i){
+ if(vf->ready_state<OPENED)return(OV_EINVAL);
+ if(!vf->seekable || i>=vf->links)return(OV_EINVAL);
+ if(i<0){
+ ogg_int64_t acc=0;
+ int i;
+ for(i=0;i<vf->links;i++)
+ acc+=ov_raw_total(vf,i);
+ return(acc);
+ }else{
+ return(vf->offsets[i+1]-vf->offsets[i]);
+ }
+}
+
+/* returns: total PCM length (samples) of content if i==-1 PCM length
+ (samples) of that logical bitstream for i==0 to n
+ OV_EINVAL if the stream is not seekable (we can't know the
+ length) or only partially open
+*/
+ogg_int64_t ov_pcm_total(OggVorbis_File *vf,int i){
+ if(vf->ready_state<OPENED)return(OV_EINVAL);
+ if(!vf->seekable || i>=vf->links)return(OV_EINVAL);
+ if(i<0){
+ ogg_int64_t acc=0;
+ int i;
+ for(i=0;i<vf->links;i++)
+ acc+=ov_pcm_total(vf,i);
+ return(acc);
+ }else{
+ return(vf->pcmlengths[i*2+1]);
+ }
+}
+
+/* returns: total seconds of content if i==-1
+ seconds in that logical bitstream for i==0 to n
+ OV_EINVAL if the stream is not seekable (we can't know the
+ length) or only partially open
+*/
+double ov_time_total(OggVorbis_File *vf,int i){
+ if(vf->ready_state<OPENED)return(OV_EINVAL);
+ if(!vf->seekable || i>=vf->links)return(OV_EINVAL);
+ if(i<0){
+ double acc=0;
+ int i;
+ for(i=0;i<vf->links;i++)
+ acc+=ov_time_total(vf,i);
+ return(acc);
+ }else{
+ return((double)(vf->pcmlengths[i*2+1])/vf->vi[i].rate);
+ }
+}
+
+/* seek to an offset relative to the *compressed* data. This also
+ scans packets to update the PCM cursor. It will cross a logical
+ bitstream boundary, but only if it can't get any packets out of the
+ tail of the bitstream we seek to (so no surprises).
+
+ returns zero on success, nonzero on failure */
+
+int ov_raw_seek(OggVorbis_File *vf,ogg_int64_t pos){
+ ogg_stream_state work_os;
+ int ret;
+
+ if(vf->ready_state<OPENED)return(OV_EINVAL);
+ if(!vf->seekable)
+ return(OV_ENOSEEK); /* don't dump machine if we can't seek */
+
+ if(pos<0 || pos>vf->end)return(OV_EINVAL);
+
+ /* is the seek position outside our current link [if any]? */
+ if(vf->ready_state>=STREAMSET){
+ if(pos<vf->offsets[vf->current_link] || pos>=vf->offsets[vf->current_link+1])
+ _decode_clear(vf); /* clear out stream state */
+ }
+
+ /* don't yet clear out decoding machine (if it's initialized), in
+ the case we're in the same link. Restart the decode lapping, and
+ let _fetch_and_process_packet deal with a potential bitstream
+ boundary */
+ vf->pcm_offset=-1;
+ ogg_stream_reset_serialno(&vf->os,
+ vf->current_serialno); /* must set serialno */
+ vorbis_synthesis_restart(&vf->vd);
+
+ ret=_seek_helper(vf,pos);
+ if(ret)goto seek_error;
+
+ /* we need to make sure the pcm_offset is set, but we don't want to
+ advance the raw cursor past good packets just to get to the first
+ with a granulepos. That's not equivalent behavior to beginning
+ decoding as immediately after the seek position as possible.
+
+ So, a hack. We use two stream states; a local scratch state and
+ the shared vf->os stream state. We use the local state to
+ scan, and the shared state as a buffer for later decode.
+
+ Unfortuantely, on the last page we still advance to last packet
+ because the granulepos on the last page is not necessarily on a
+ packet boundary, and we need to make sure the granpos is
+ correct.
+ */
+
+ {
+ ogg_page og;
+ ogg_packet op;
+ int lastblock=0;
+ int accblock=0;
+ int thisblock=0;
+ int lastflag=0;
+ int firstflag=0;
+ ogg_int64_t pagepos=-1;
+
+ ogg_stream_init(&work_os,vf->current_serialno); /* get the memory ready */
+ ogg_stream_reset(&work_os); /* eliminate the spurious OV_HOLE
+ return from not necessarily
+ starting from the beginning */
+
+ while(1){
+ if(vf->ready_state>=STREAMSET){
+ /* snarf/scan a packet if we can */
+ int result=ogg_stream_packetout(&work_os,&op);
+
+ if(result>0){
+
+ if(vf->vi[vf->current_link].codec_setup){
+ thisblock=vorbis_packet_blocksize(vf->vi+vf->current_link,&op);
+ if(thisblock<0){
+ ogg_stream_packetout(&vf->os,NULL);
+ thisblock=0;
+ }else{
+
+ /* We can't get a guaranteed correct pcm position out of the
+ last page in a stream because it might have a 'short'
+ granpos, which can only be detected in the presence of a
+ preceding page. However, if the last page is also the first
+ page, the granpos rules of a first page take precedence. Not
+ only that, but for first==last, the EOS page must be treated
+ as if its a normal first page for the stream to open/play. */
+ if(lastflag && !firstflag)
+ ogg_stream_packetout(&vf->os,NULL);
+ else
+ if(lastblock)accblock+=(lastblock+thisblock)>>2;
+ }
+
+ if(op.granulepos!=-1){
+ int i,link=vf->current_link;
+ ogg_int64_t granulepos=op.granulepos-vf->pcmlengths[link*2];
+ if(granulepos<0)granulepos=0;
+
+ for(i=0;i<link;i++)
+ granulepos+=vf->pcmlengths[i*2+1];
+ vf->pcm_offset=granulepos-accblock;
+ if(vf->pcm_offset<0)vf->pcm_offset=0;
+ break;
+ }
+ lastblock=thisblock;
+ continue;
+ }else
+ ogg_stream_packetout(&vf->os,NULL);
+ }
+ }
+
+ if(!lastblock){
+ pagepos=_get_next_page(vf,&og,-1);
+ if(pagepos<0){
+ vf->pcm_offset=ov_pcm_total(vf,-1);
+ break;
+ }
+ }else{
+ /* huh? Bogus stream with packets but no granulepos */
+ vf->pcm_offset=-1;
+ break;
+ }
+
+ /* has our decoding just traversed a bitstream boundary? */
+ if(vf->ready_state>=STREAMSET){
+ if(vf->current_serialno!=ogg_page_serialno(&og)){
+
+ /* two possibilities:
+ 1) our decoding just traversed a bitstream boundary
+ 2) another stream is multiplexed into this logical section? */
+
+ if(ogg_page_bos(&og)){
+ /* we traversed */
+ _decode_clear(vf); /* clear out stream state */
+ ogg_stream_clear(&work_os);
+ } /* else, do nothing; next loop will scoop another page */
+ }
+ }
+
+ if(vf->ready_state<STREAMSET){
+ int link;
+ long serialno = ogg_page_serialno(&og);
+
+ for(link=0;link<vf->links;link++)
+ if(vf->serialnos[link]==serialno)break;
+
+ if(link==vf->links) continue; /* not the desired Vorbis
+ bitstream section; keep
+ trying */
+ vf->current_link=link;
+ vf->current_serialno=serialno;
+ ogg_stream_reset_serialno(&vf->os,serialno);
+ ogg_stream_reset_serialno(&work_os,serialno);
+ vf->ready_state=STREAMSET;
+ firstflag=(pagepos<=vf->dataoffsets[link]);
+ }
+
+ ogg_stream_pagein(&vf->os,&og);
+ ogg_stream_pagein(&work_os,&og);
+ lastflag=ogg_page_eos(&og);
+
+ }
+ }
+
+ ogg_stream_clear(&work_os);
+ vf->bittrack=0.f;
+ vf->samptrack=0.f;
+ return(0);
+
+ seek_error:
+ /* dump the machine so we're in a known state */
+ vf->pcm_offset=-1;
+ ogg_stream_clear(&work_os);
+ _decode_clear(vf);
+ return OV_EBADLINK;
+}
+
+/* Page granularity seek (faster than sample granularity because we
+ don't do the last bit of decode to find a specific sample).
+
+ Seek to the last [granule marked] page preceding the specified pos
+ location, such that decoding past the returned point will quickly
+ arrive at the requested position. */
+int ov_pcm_seek_page(OggVorbis_File *vf,ogg_int64_t pos){
+ int link=-1;
+ ogg_int64_t result=0;
+ ogg_int64_t total=ov_pcm_total(vf,-1);
+
+ if(vf->ready_state<OPENED)return(OV_EINVAL);
+ if(!vf->seekable)return(OV_ENOSEEK);
+
+ if(pos<0 || pos>total)return(OV_EINVAL);
+
+ /* which bitstream section does this pcm offset occur in? */
+ for(link=vf->links-1;link>=0;link--){
+ total-=vf->pcmlengths[link*2+1];
+ if(pos>=total)break;
+ }
+
+ /* search within the logical bitstream for the page with the highest
+ pcm_pos preceding (or equal to) pos. There is a danger here;
+ missing pages or incorrect frame number information in the
+ bitstream could make our task impossible. Account for that (it
+ would be an error condition) */
+
+ /* new search algorithm by HB (Nicholas Vinen) */
+ {
+ ogg_int64_t end=vf->offsets[link+1];
+ ogg_int64_t begin=vf->offsets[link];
+ ogg_int64_t begintime = vf->pcmlengths[link*2];
+ ogg_int64_t endtime = vf->pcmlengths[link*2+1]+begintime;
+ ogg_int64_t target=pos-total+begintime;
+ ogg_int64_t best=begin;
+
+ ogg_page og;
+ while(begin<end){
+ ogg_int64_t bisect;
+
+ if(end-begin<CHUNKSIZE){
+ bisect=begin;
+ }else{
+ /* take a (pretty decent) guess. */
+ bisect=begin +
+ (ogg_int64_t)((double)(target-begintime)*(end-begin)/(endtime-begintime))
+ - CHUNKSIZE;
+ if(bisect<begin+CHUNKSIZE)
+ bisect=begin;
+ }
+
+ if(bisect!=vf->offset){
+ result=_seek_helper(vf,bisect);
+ if(result) goto seek_error;
+ }
+
+ while(begin<end){
+ result=_get_next_page(vf,&og,end-vf->offset);
+ if(result==OV_EREAD) goto seek_error;
+ if(result<0){
+ if(bisect<=begin+1)
+ end=begin; /* found it */
+ else{
+ if(bisect==0) goto seek_error;
+ bisect-=CHUNKSIZE;
+ if(bisect<=begin)bisect=begin+1;
+ result=_seek_helper(vf,bisect);
+ if(result) goto seek_error;
+ }
+ }else{
+ ogg_int64_t granulepos;
+
+ if(ogg_page_serialno(&og)!=vf->serialnos[link])
+ continue;
+
+ granulepos=ogg_page_granulepos(&og);
+ if(granulepos==-1)continue;
+
+ if(granulepos<target){
+ best=result; /* raw offset of packet with granulepos */
+ begin=vf->offset; /* raw offset of next page */
+ begintime=granulepos;
+
+ if(target-begintime>44100)break;
+ bisect=begin; /* *not* begin + 1 */
+ }else{
+ if(bisect<=begin+1)
+ end=begin; /* found it */
+ else{
+ if(end==vf->offset){ /* we're pretty close - we'd be stuck in */
+ end=result;
+ bisect-=CHUNKSIZE; /* an endless loop otherwise. */
+ if(bisect<=begin)bisect=begin+1;
+ result=_seek_helper(vf,bisect);
+ if(result) goto seek_error;
+ }else{
+ end=bisect;
+ endtime=granulepos;
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ /* found our page. seek to it, update pcm offset. Easier case than
+ raw_seek, don't keep packets preceding granulepos. */
+ {
+ ogg_page og;
+ ogg_packet op;
+
+ /* seek */
+ result=_seek_helper(vf,best);
+ vf->pcm_offset=-1;
+ if(result) goto seek_error;
+ result=_get_next_page(vf,&og,-1);
+ if(result<0) goto seek_error;
+
+ if(link!=vf->current_link){
+ /* Different link; dump entire decode machine */
+ _decode_clear(vf);
+
+ vf->current_link=link;
+ vf->current_serialno=vf->serialnos[link];
+ vf->ready_state=STREAMSET;
+
+ }else{
+ vorbis_synthesis_restart(&vf->vd);
+ }
+
+ ogg_stream_reset_serialno(&vf->os,vf->current_serialno);
+ ogg_stream_pagein(&vf->os,&og);
+
+ /* pull out all but last packet; the one with granulepos */
+ while(1){
+ result=ogg_stream_packetpeek(&vf->os,&op);
+ if(result==0){
+ /* !!! the packet finishing this page originated on a
+ preceding page. Keep fetching previous pages until we
+ get one with a granulepos or without the 'continued' flag
+ set. Then just use raw_seek for simplicity. */
+
+ result=_seek_helper(vf,best);
+ if(result<0) goto seek_error;
+
+ while(1){
+ result=_get_prev_page(vf,&og);
+ if(result<0) goto seek_error;
+ if(ogg_page_serialno(&og)==vf->current_serialno &&
+ (ogg_page_granulepos(&og)>-1 ||
+ !ogg_page_continued(&og))){
+ return ov_raw_seek(vf,result);
+ }
+ vf->offset=result;
+ }
+ }
+ if(result<0){
+ result = OV_EBADPACKET;
+ goto seek_error;
+ }
+ if(op.granulepos!=-1){
+ vf->pcm_offset=op.granulepos-vf->pcmlengths[vf->current_link*2];
+ if(vf->pcm_offset<0)vf->pcm_offset=0;
+ vf->pcm_offset+=total;
+ break;
+ }else
+ result=ogg_stream_packetout(&vf->os,NULL);
+ }
+ }
+ }
+
+ /* verify result */
+ if(vf->pcm_offset>pos || pos>ov_pcm_total(vf,-1)){
+ result=OV_EFAULT;
+ goto seek_error;
+ }
+ vf->bittrack=0.f;
+ vf->samptrack=0.f;
+ return(0);
+
+ seek_error:
+ /* dump machine so we're in a known state */
+ vf->pcm_offset=-1;
+ _decode_clear(vf);
+ return (int)result;
+}
+
+/* seek to a sample offset relative to the decompressed pcm stream
+ returns zero on success, nonzero on failure */
+
+int ov_pcm_seek(OggVorbis_File *vf,ogg_int64_t pos){
+ int thisblock,lastblock=0;
+ int ret=ov_pcm_seek_page(vf,pos);
+ if(ret<0)return(ret);
+ if((ret=_make_decode_ready(vf)))return ret;
+
+ /* discard leading packets we don't need for the lapping of the
+ position we want; don't decode them */
+
+ while(1){
+ ogg_packet op;
+ ogg_page og;
+
+ int ret=ogg_stream_packetpeek(&vf->os,&op);
+ if(ret>0){
+ thisblock=vorbis_packet_blocksize(vf->vi+vf->current_link,&op);
+ if(thisblock<0){
+ ogg_stream_packetout(&vf->os,NULL);
+ continue; /* non audio packet */
+ }
+ if(lastblock)vf->pcm_offset+=(lastblock+thisblock)>>2;
+
+ if(vf->pcm_offset+((thisblock+
+ vorbis_info_blocksize(vf->vi,1))>>2)>=pos)break;
+
+ /* remove the packet from packet queue and track its granulepos */
+ ogg_stream_packetout(&vf->os,NULL);
+ vorbis_synthesis_trackonly(&vf->vb,&op); /* set up a vb with
+ only tracking, no
+ pcm_decode */
+ vorbis_synthesis_blockin(&vf->vd,&vf->vb);
+
+ /* end of logical stream case is hard, especially with exact
+ length positioning. */
+
+ if(op.granulepos>-1){
+ int i;
+ /* always believe the stream markers */
+ vf->pcm_offset=op.granulepos-vf->pcmlengths[vf->current_link*2];
+ if(vf->pcm_offset<0)vf->pcm_offset=0;
+ for(i=0;i<vf->current_link;i++)
+ vf->pcm_offset+=vf->pcmlengths[i*2+1];
+ }
+
+ lastblock=thisblock;
+
+ }else{
+ if(ret<0 && ret!=OV_HOLE)break;
+
+ /* suck in a new page */
+ if(_get_next_page(vf,&og,-1)<0)break;
+ if(ogg_page_bos(&og))_decode_clear(vf);
+
+ if(vf->ready_state<STREAMSET){
+ long serialno=ogg_page_serialno(&og);
+ int link;
+
+ for(link=0;link<vf->links;link++)
+ if(vf->serialnos[link]==serialno)break;
+ if(link==vf->links) continue;
+ vf->current_link=link;
+
+ vf->ready_state=STREAMSET;
+ vf->current_serialno=ogg_page_serialno(&og);
+ ogg_stream_reset_serialno(&vf->os,serialno);
+ ret=_make_decode_ready(vf);
+ if(ret)return ret;
+ lastblock=0;
+ }
+
+ ogg_stream_pagein(&vf->os,&og);
+ }
+ }
+
+ vf->bittrack=0.f;
+ vf->samptrack=0.f;
+ /* discard samples until we reach the desired position. Crossing a
+ logical bitstream boundary with abandon is OK. */
+ {
+ /* note that halfrate could be set differently in each link, but
+ vorbisfile encoforces all links are set or unset */
+ int hs=vorbis_synthesis_halfrate_p(vf->vi);
+ while(vf->pcm_offset<((pos>>hs)<<hs)){
+ ogg_int64_t target=(pos-vf->pcm_offset)>>hs;
+ long samples=vorbis_synthesis_pcmout(&vf->vd,NULL);
+
+ if(samples>target)samples=target;
+ vorbis_synthesis_read(&vf->vd,samples);
+ vf->pcm_offset+=samples<<hs;
+
+ if(samples<target)
+ if(_fetch_and_process_packet(vf,NULL,1,1)<=0)
+ vf->pcm_offset=ov_pcm_total(vf,-1); /* eof */
+ }
+ }
+ return 0;
+}
+
+/* seek to a playback time relative to the decompressed pcm stream
+ returns zero on success, nonzero on failure */
+int ov_time_seek(OggVorbis_File *vf,double seconds){
+ /* translate time to PCM position and call ov_pcm_seek */
+
+ int link=-1;
+ ogg_int64_t pcm_total=0;
+ double time_total=0.;
+
+ if(vf->ready_state<OPENED)return(OV_EINVAL);
+ if(!vf->seekable)return(OV_ENOSEEK);
+ if(seconds<0)return(OV_EINVAL);
+
+ /* which bitstream section does this time offset occur in? */
+ for(link=0;link<vf->links;link++){
+ double addsec = ov_time_total(vf,link);
+ if(seconds<time_total+addsec)break;
+ time_total+=addsec;
+ pcm_total+=vf->pcmlengths[link*2+1];
+ }
+
+ if(link==vf->links)return(OV_EINVAL);
+
+ /* enough information to convert time offset to pcm offset */
+ {
+ ogg_int64_t target=pcm_total+(seconds-time_total)*vf->vi[link].rate;
+ return(ov_pcm_seek(vf,target));
+ }
+}
+
+/* page-granularity version of ov_time_seek
+ returns zero on success, nonzero on failure */
+int ov_time_seek_page(OggVorbis_File *vf,double seconds){
+ /* translate time to PCM position and call ov_pcm_seek */
+
+ int link=-1;
+ ogg_int64_t pcm_total=0;
+ double time_total=0.;
+
+ if(vf->ready_state<OPENED)return(OV_EINVAL);
+ if(!vf->seekable)return(OV_ENOSEEK);
+ if(seconds<0)return(OV_EINVAL);
+
+ /* which bitstream section does this time offset occur in? */
+ for(link=0;link<vf->links;link++){
+ double addsec = ov_time_total(vf,link);
+ if(seconds<time_total+addsec)break;
+ time_total+=addsec;
+ pcm_total+=vf->pcmlengths[link*2+1];
+ }
+
+ if(link==vf->links)return(OV_EINVAL);
+
+ /* enough information to convert time offset to pcm offset */
+ {
+ ogg_int64_t target=pcm_total+(seconds-time_total)*vf->vi[link].rate;
+ return(ov_pcm_seek_page(vf,target));
+ }
+}
+
+/* tell the current stream offset cursor. Note that seek followed by
+ tell will likely not give the set offset due to caching */
+ogg_int64_t ov_raw_tell(OggVorbis_File *vf){
+ if(vf->ready_state<OPENED)return(OV_EINVAL);
+ return(vf->offset);
+}
+
+/* return PCM offset (sample) of next PCM sample to be read */
+ogg_int64_t ov_pcm_tell(OggVorbis_File *vf){
+ if(vf->ready_state<OPENED)return(OV_EINVAL);
+ return(vf->pcm_offset);
+}
+
+/* return time offset (seconds) of next PCM sample to be read */
+double ov_time_tell(OggVorbis_File *vf){
+ int link=0;
+ ogg_int64_t pcm_total=0;
+ double time_total=0.f;
+
+ if(vf->ready_state<OPENED)return(OV_EINVAL);
+ if(vf->seekable){
+ pcm_total=ov_pcm_total(vf,-1);
+ time_total=ov_time_total(vf,-1);
+
+ /* which bitstream section does this time offset occur in? */
+ for(link=vf->links-1;link>=0;link--){
+ pcm_total-=vf->pcmlengths[link*2+1];
+ time_total-=ov_time_total(vf,link);
+ if(vf->pcm_offset>=pcm_total)break;
+ }
+ }
+
+ return((double)time_total+(double)(vf->pcm_offset-pcm_total)/vf->vi[link].rate);
+}
+
+/* link: -1) return the vorbis_info struct for the bitstream section
+ currently being decoded
+ 0-n) to request information for a specific bitstream section
+
+ In the case of a non-seekable bitstream, any call returns the
+ current bitstream. NULL in the case that the machine is not
+ initialized */
+
+vorbis_info *ov_info(OggVorbis_File *vf,int link){
+ if(vf->seekable){
+ if(link<0)
+ if(vf->ready_state>=STREAMSET)
+ return vf->vi+vf->current_link;
+ else
+ return vf->vi;
+ else
+ if(link>=vf->links)
+ return NULL;
+ else
+ return vf->vi+link;
+ }else{
+ return vf->vi;
+ }
+}
+
+/* grr, strong typing, grr, no templates/inheritence, grr */
+vorbis_comment *ov_comment(OggVorbis_File *vf,int link){
+ if(vf->seekable){
+ if(link<0)
+ if(vf->ready_state>=STREAMSET)
+ return vf->vc+vf->current_link;
+ else
+ return vf->vc;
+ else
+ if(link>=vf->links)
+ return NULL;
+ else
+ return vf->vc+link;
+ }else{
+ return vf->vc;
+ }
+}
+
+static int host_is_big_endian() {
+ ogg_int32_t pattern = 0xfeedface; /* deadbeef */
+ unsigned char *bytewise = (unsigned char *)&pattern;
+ if (bytewise[0] == 0xfe) return 1;
+ return 0;
+}
+
+/* up to this point, everything could more or less hide the multiple
+ logical bitstream nature of chaining from the toplevel application
+ if the toplevel application didn't particularly care. However, at
+ the point that we actually read audio back, the multiple-section
+ nature must surface: Multiple bitstream sections do not necessarily
+ have to have the same number of channels or sampling rate.
+
+ ov_read returns the sequential logical bitstream number currently
+ being decoded along with the PCM data in order that the toplevel
+ application can take action on channel/sample rate changes. This
+ number will be incremented even for streamed (non-seekable) streams
+ (for seekable streams, it represents the actual logical bitstream
+ index within the physical bitstream. Note that the accessor
+ functions above are aware of this dichotomy).
+
+ ov_read_filter is exactly the same as ov_read except that it processes
+ the decoded audio data through a filter before packing it into the
+ requested format. This gives greater accuracy than applying a filter
+ after the audio has been converted into integral PCM.
+
+ input values: buffer) a buffer to hold packed PCM data for return
+ length) the byte length requested to be placed into buffer
+ bigendianp) should the data be packed LSB first (0) or
+ MSB first (1)
+ word) word size for output. currently 1 (byte) or
+ 2 (16 bit short)
+
+ return values: <0) error/hole in data (OV_HOLE), partial open (OV_EINVAL)
+ 0) EOF
+ n) number of bytes of PCM actually returned. The
+ below works on a packet-by-packet basis, so the
+ return length is not related to the 'length' passed
+ in, just guaranteed to fit.
+
+ *section) set to the logical bitstream number */
+
+long ov_read_filter(OggVorbis_File *vf,char *buffer,int length,
+ int bigendianp,int word,int sgned,int *bitstream,
+ void (*filter)(float **pcm,long channels,long samples,void *filter_param),void *filter_param){
+ int i,j;
+ int host_endian = host_is_big_endian();
+ int hs;
+
+ float **pcm;
+ long samples;
+
+ if(vf->ready_state<OPENED)return(OV_EINVAL);
+
+ while(1){
+ if(vf->ready_state==INITSET){
+ samples=vorbis_synthesis_pcmout(&vf->vd,&pcm);
+ if(samples)break;
+ }
+
+ /* suck in another packet */
+ {
+ int ret=_fetch_and_process_packet(vf,NULL,1,1);
+ if(ret==OV_EOF)
+ return(0);
+ if(ret<=0)
+ return(ret);
+ }
+
+ }
+
+ if(samples>0){
+
+ /* yay! proceed to pack data into the byte buffer */
+
+ long channels=ov_info(vf,-1)->channels;
+ long bytespersample=word * channels;
+ vorbis_fpu_control fpu;
+ if(samples>length/bytespersample)samples=length/bytespersample;
+
+ if(samples <= 0)
+ return OV_EINVAL;
+
+ /* Here. */
+ if(filter)
+ filter(pcm,channels,samples,filter_param);
+
+ /* a tight loop to pack each size */
+ {
+ int val;
+ if(word==1){
+ int off=(sgned?0:128);
+ vorbis_fpu_setround(&fpu);
+ for(j=0;j<samples;j++)
+ for(i=0;i<channels;i++){
+ val=vorbis_ftoi(pcm[i][j]*128.f);
+ if(val>127)val=127;
+ else if(val<-128)val=-128;
+ *buffer++=val+off;
+ }
+ vorbis_fpu_restore(fpu);
+ }else{
+ int off=(sgned?0:32768);
+
+ if(host_endian==bigendianp){
+ if(sgned){
+
+ vorbis_fpu_setround(&fpu);
+ for(i=0;i<channels;i++) { /* It's faster in this order */
+ float *src=pcm[i];
+ short *dest=((short *)buffer)+i;
+ for(j=0;j<samples;j++) {
+ val=vorbis_ftoi(src[j]*32768.f);
+ if(val>32767)val=32767;
+ else if(val<-32768)val=-32768;
+ *dest=val;
+ dest+=channels;
+ }
+ }
+ vorbis_fpu_restore(fpu);
+
+ }else{
+
+ vorbis_fpu_setround(&fpu);
+ for(i=0;i<channels;i++) {
+ float *src=pcm[i];
+ short *dest=((short *)buffer)+i;
+ for(j=0;j<samples;j++) {
+ val=vorbis_ftoi(src[j]*32768.f);
+ if(val>32767)val=32767;
+ else if(val<-32768)val=-32768;
+ *dest=val+off;
+ dest+=channels;
+ }
+ }
+ vorbis_fpu_restore(fpu);
+
+ }
+ }else if(bigendianp){
+
+ vorbis_fpu_setround(&fpu);
+ for(j=0;j<samples;j++)
+ for(i=0;i<channels;i++){
+ val=vorbis_ftoi(pcm[i][j]*32768.f);
+ if(val>32767)val=32767;
+ else if(val<-32768)val=-32768;
+ val+=off;
+ *buffer++=(val>>8);
+ *buffer++=(val&0xff);
+ }
+ vorbis_fpu_restore(fpu);
+
+ }else{
+ int val;
+ vorbis_fpu_setround(&fpu);
+ for(j=0;j<samples;j++)
+ for(i=0;i<channels;i++){
+ val=vorbis_ftoi(pcm[i][j]*32768.f);
+ if(val>32767)val=32767;
+ else if(val<-32768)val=-32768;
+ val+=off;
+ *buffer++=(val&0xff);
+ *buffer++=(val>>8);
+ }
+ vorbis_fpu_restore(fpu);
+
+ }
+ }
+ }
+
+ vorbis_synthesis_read(&vf->vd,samples);
+ hs=vorbis_synthesis_halfrate_p(vf->vi);
+ vf->pcm_offset+=(samples<<hs);
+ if(bitstream)*bitstream=vf->current_link;
+ return(samples*bytespersample);
+ }else{
+ return(samples);
+ }
+}
+
+long ov_read(OggVorbis_File *vf,char *buffer,int length,
+ int bigendianp,int word,int sgned,int *bitstream){
+ return ov_read_filter(vf, buffer, length, bigendianp, word, sgned, bitstream, NULL, NULL);
+}
+
+/* input values: pcm_channels) a float vector per channel of output
+ length) the sample length being read by the app
+
+ return values: <0) error/hole in data (OV_HOLE), partial open (OV_EINVAL)
+ 0) EOF
+ n) number of samples of PCM actually returned. The
+ below works on a packet-by-packet basis, so the
+ return length is not related to the 'length' passed
+ in, just guaranteed to fit.
+
+ *section) set to the logical bitstream number */
+
+
+
+long ov_read_float(OggVorbis_File *vf,float ***pcm_channels,int length,
+ int *bitstream){
+
+ if(vf->ready_state<OPENED)return(OV_EINVAL);
+
+ while(1){
+ if(vf->ready_state==INITSET){
+ float **pcm;
+ long samples=vorbis_synthesis_pcmout(&vf->vd,&pcm);
+ if(samples){
+ int hs=vorbis_synthesis_halfrate_p(vf->vi);
+ if(pcm_channels)*pcm_channels=pcm;
+ if(samples>length)samples=length;
+ vorbis_synthesis_read(&vf->vd,samples);
+ vf->pcm_offset+=samples<<hs;
+ if(bitstream)*bitstream=vf->current_link;
+ return samples;
+
+ }
+ }
+
+ /* suck in another packet */
+ {
+ int ret=_fetch_and_process_packet(vf,NULL,1,1);
+ if(ret==OV_EOF)return(0);
+ if(ret<=0)return(ret);
+ }
+
+ }
+}
+
+extern float *vorbis_window(vorbis_dsp_state *v,int W);
+
+static void _ov_splice(float **pcm,float **lappcm,
+ int n1, int n2,
+ int ch1, int ch2,
+ float *w1, float *w2){
+ int i,j;
+ float *w=w1;
+ int n=n1;
+
+ if(n1>n2){
+ n=n2;
+ w=w2;
+ }
+
+ /* splice */
+ for(j=0;j<ch1 && j<ch2;j++){
+ float *s=lappcm[j];
+ float *d=pcm[j];
+
+ for(i=0;i<n;i++){
+ float wd=w[i]*w[i];
+ float ws=1.-wd;
+ d[i]=d[i]*wd + s[i]*ws;
+ }
+ }
+ /* window from zero */
+ for(;j<ch2;j++){
+ float *d=pcm[j];
+ for(i=0;i<n;i++){
+ float wd=w[i]*w[i];
+ d[i]=d[i]*wd;
+ }
+ }
+
+}
+
+/* make sure vf is INITSET */
+static int _ov_initset(OggVorbis_File *vf){
+ while(1){
+ if(vf->ready_state==INITSET)break;
+ /* suck in another packet */
+ {
+ int ret=_fetch_and_process_packet(vf,NULL,1,0);
+ if(ret<0 && ret!=OV_HOLE)return(ret);
+ }
+ }
+ return 0;
+}
+
+/* make sure vf is INITSET and that we have a primed buffer; if
+ we're crosslapping at a stream section boundary, this also makes
+ sure we're sanity checking against the right stream information */
+static int _ov_initprime(OggVorbis_File *vf){
+ vorbis_dsp_state *vd=&vf->vd;
+ while(1){
+ if(vf->ready_state==INITSET)
+ if(vorbis_synthesis_pcmout(vd,NULL))break;
+
+ /* suck in another packet */
+ {
+ int ret=_fetch_and_process_packet(vf,NULL,1,0);
+ if(ret<0 && ret!=OV_HOLE)return(ret);
+ }
+ }
+ return 0;
+}
+
+/* grab enough data for lapping from vf; this may be in the form of
+ unreturned, already-decoded pcm, remaining PCM we will need to
+ decode, or synthetic postextrapolation from last packets. */
+static void _ov_getlap(OggVorbis_File *vf,vorbis_info *vi,vorbis_dsp_state *vd,
+ float **lappcm,int lapsize){
+ int lapcount=0,i;
+ float **pcm;
+
+ /* try first to decode the lapping data */
+ while(lapcount<lapsize){
+ int samples=vorbis_synthesis_pcmout(vd,&pcm);
+ if(samples){
+ if(samples>lapsize-lapcount)samples=lapsize-lapcount;
+ for(i=0;i<vi->channels;i++)
+ memcpy(lappcm[i]+lapcount,pcm[i],sizeof(**pcm)*samples);
+ lapcount+=samples;
+ vorbis_synthesis_read(vd,samples);
+ }else{
+ /* suck in another packet */
+ int ret=_fetch_and_process_packet(vf,NULL,1,0); /* do *not* span */
+ if(ret==OV_EOF)break;
+ }
+ }
+ if(lapcount<lapsize){
+ /* failed to get lapping data from normal decode; pry it from the
+ postextrapolation buffering, or the second half of the MDCT
+ from the last packet */
+ int samples=vorbis_synthesis_lapout(&vf->vd,&pcm);
+ if(samples==0){
+ for(i=0;i<vi->channels;i++)
+ memset(lappcm[i]+lapcount,0,sizeof(**pcm)*lapsize-lapcount);
+ lapcount=lapsize;
+ }else{
+ if(samples>lapsize-lapcount)samples=lapsize-lapcount;
+ for(i=0;i<vi->channels;i++)
+ memcpy(lappcm[i]+lapcount,pcm[i],sizeof(**pcm)*samples);
+ lapcount+=samples;
+ }
+ }
+}
+
+/* this sets up crosslapping of a sample by using trailing data from
+ sample 1 and lapping it into the windowing buffer of sample 2 */
+int ov_crosslap(OggVorbis_File *vf1, OggVorbis_File *vf2){
+ vorbis_info *vi1,*vi2;
+ float **lappcm;
+ float **pcm;
+ float *w1,*w2;
+ int n1,n2,i,ret,hs1,hs2;
+
+ if(vf1==vf2)return(0); /* degenerate case */
+ if(vf1->ready_state<OPENED)return(OV_EINVAL);
+ if(vf2->ready_state<OPENED)return(OV_EINVAL);
+
+ /* the relevant overlap buffers must be pre-checked and pre-primed
+ before looking at settings in the event that priming would cross
+ a bitstream boundary. So, do it now */
+
+ ret=_ov_initset(vf1);
+ if(ret)return(ret);
+ ret=_ov_initprime(vf2);
+ if(ret)return(ret);
+
+ vi1=ov_info(vf1,-1);
+ vi2=ov_info(vf2,-1);
+ hs1=ov_halfrate_p(vf1);
+ hs2=ov_halfrate_p(vf2);
+
+ lappcm=alloca(sizeof(*lappcm)*vi1->channels);
+ n1=vorbis_info_blocksize(vi1,0)>>(1+hs1);
+ n2=vorbis_info_blocksize(vi2,0)>>(1+hs2);
+ w1=vorbis_window(&vf1->vd,0);
+ w2=vorbis_window(&vf2->vd,0);
+
+ for(i=0;i<vi1->channels;i++)
+ lappcm[i]=alloca(sizeof(**lappcm)*n1);
+
+ _ov_getlap(vf1,vi1,&vf1->vd,lappcm,n1);
+
+ /* have a lapping buffer from vf1; now to splice it into the lapping
+ buffer of vf2 */
+ /* consolidate and expose the buffer. */
+ vorbis_synthesis_lapout(&vf2->vd,&pcm);
+
+#if 0
+ _analysis_output_always("pcmL",0,pcm[0],n1*2,0,0,0);
+ _analysis_output_always("pcmR",0,pcm[1],n1*2,0,0,0);
+#endif
+
+ /* splice */
+ _ov_splice(pcm,lappcm,n1,n2,vi1->channels,vi2->channels,w1,w2);
+
+ /* done */
+ return(0);
+}
+
+static int _ov_64_seek_lap(OggVorbis_File *vf,ogg_int64_t pos,
+ int (*localseek)(OggVorbis_File *,ogg_int64_t)){
+ vorbis_info *vi;
+ float **lappcm;
+ float **pcm;
+ float *w1,*w2;
+ int n1,n2,ch1,ch2,hs;
+ int i,ret;
+
+ if(vf->ready_state<OPENED)return(OV_EINVAL);
+ ret=_ov_initset(vf);
+ if(ret)return(ret);
+ vi=ov_info(vf,-1);
+ hs=ov_halfrate_p(vf);
+
+ ch1=vi->channels;
+ n1=vorbis_info_blocksize(vi,0)>>(1+hs);
+ w1=vorbis_window(&vf->vd,0); /* window arrays from libvorbis are
+ persistent; even if the decode state
+ from this link gets dumped, this
+ window array continues to exist */
+
+ lappcm=alloca(sizeof(*lappcm)*ch1);
+ for(i=0;i<ch1;i++)
+ lappcm[i]=alloca(sizeof(**lappcm)*n1);
+ _ov_getlap(vf,vi,&vf->vd,lappcm,n1);
+
+ /* have lapping data; seek and prime the buffer */
+ ret=localseek(vf,pos);
+ if(ret)return ret;
+ ret=_ov_initprime(vf);
+ if(ret)return(ret);
+
+ /* Guard against cross-link changes; they're perfectly legal */
+ vi=ov_info(vf,-1);
+ ch2=vi->channels;
+ n2=vorbis_info_blocksize(vi,0)>>(1+hs);
+ w2=vorbis_window(&vf->vd,0);
+
+ /* consolidate and expose the buffer. */
+ vorbis_synthesis_lapout(&vf->vd,&pcm);
+
+ /* splice */
+ _ov_splice(pcm,lappcm,n1,n2,ch1,ch2,w1,w2);
+
+ /* done */
+ return(0);
+}
+
+int ov_raw_seek_lap(OggVorbis_File *vf,ogg_int64_t pos){
+ return _ov_64_seek_lap(vf,pos,ov_raw_seek);
+}
+
+int ov_pcm_seek_lap(OggVorbis_File *vf,ogg_int64_t pos){
+ return _ov_64_seek_lap(vf,pos,ov_pcm_seek);
+}
+
+int ov_pcm_seek_page_lap(OggVorbis_File *vf,ogg_int64_t pos){
+ return _ov_64_seek_lap(vf,pos,ov_pcm_seek_page);
+}
+
+static int _ov_d_seek_lap(OggVorbis_File *vf,double pos,
+ int (*localseek)(OggVorbis_File *,double)){
+ vorbis_info *vi;
+ float **lappcm;
+ float **pcm;
+ float *w1,*w2;
+ int n1,n2,ch1,ch2,hs;
+ int i,ret;
+
+ if(vf->ready_state<OPENED)return(OV_EINVAL);
+ ret=_ov_initset(vf);
+ if(ret)return(ret);
+ vi=ov_info(vf,-1);
+ hs=ov_halfrate_p(vf);
+
+ ch1=vi->channels;
+ n1=vorbis_info_blocksize(vi,0)>>(1+hs);
+ w1=vorbis_window(&vf->vd,0); /* window arrays from libvorbis are
+ persistent; even if the decode state
+ from this link gets dumped, this
+ window array continues to exist */
+
+ lappcm=alloca(sizeof(*lappcm)*ch1);
+ for(i=0;i<ch1;i++)
+ lappcm[i]=alloca(sizeof(**lappcm)*n1);
+ _ov_getlap(vf,vi,&vf->vd,lappcm,n1);
+
+ /* have lapping data; seek and prime the buffer */
+ ret=localseek(vf,pos);
+ if(ret)return ret;
+ ret=_ov_initprime(vf);
+ if(ret)return(ret);
+
+ /* Guard against cross-link changes; they're perfectly legal */
+ vi=ov_info(vf,-1);
+ ch2=vi->channels;
+ n2=vorbis_info_blocksize(vi,0)>>(1+hs);
+ w2=vorbis_window(&vf->vd,0);
+
+ /* consolidate and expose the buffer. */
+ vorbis_synthesis_lapout(&vf->vd,&pcm);
+
+ /* splice */
+ _ov_splice(pcm,lappcm,n1,n2,ch1,ch2,w1,w2);
+
+ /* done */
+ return(0);
+}
+
+int ov_time_seek_lap(OggVorbis_File *vf,double pos){
+ return _ov_d_seek_lap(vf,pos,ov_time_seek);
+}
+
+int ov_time_seek_page_lap(OggVorbis_File *vf,double pos){
+ return _ov_d_seek_lap(vf,pos,ov_time_seek_page);
+}
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2007 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: stdio-based convenience library for opening/seeking/decoding
+ last mod: $Id: vorbisfile.h 17182 2010-04-29 03:48:32Z xiphmont $
+
+ ********************************************************************/
+
+#ifndef _OV_FILE_H_
+#define _OV_FILE_H_
+
+#define OV_EXCLUDE_STATIC_CALLBACKS
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+#include <stdio.h>
+#include "codec.h"
+
+/* The function prototypes for the callbacks are basically the same as for
+ * the stdio functions fread, fseek, fclose, ftell.
+ * The one difference is that the FILE * arguments have been replaced with
+ * a void * - this is to be used as a pointer to whatever internal data these
+ * functions might need. In the stdio case, it's just a FILE * cast to a void *
+ *
+ * If you use other functions, check the docs for these functions and return
+ * the right values. For seek_func(), you *MUST* return -1 if the stream is
+ * unseekable
+ */
+typedef struct {
+ size_t (*read_func) (void *ptr, size_t size, size_t nmemb, void *datasource);
+ int (*seek_func) (void *datasource, ogg_int64_t offset, int whence);
+ int (*close_func) (void *datasource);
+ long (*tell_func) (void *datasource);
+} ov_callbacks;
+
+#ifndef OV_EXCLUDE_STATIC_CALLBACKS
+
+/* a few sets of convenient callbacks, especially for use under
+ * Windows where ov_open_callbacks() should always be used instead of
+ * ov_open() to avoid problems with incompatible crt.o version linking
+ * issues. */
+
+static int _ov_header_fseek_wrap(FILE *f,ogg_int64_t off,int whence){
+ if(f==NULL)return(-1);
+
+#ifdef __MINGW32__
+ return fseeko64(f,off,whence);
+#elif defined (_WIN32)
+ return _fseeki64(f,off,whence);
+#else
+ return fseek(f,off,whence);
+#endif
+}
+
+/* These structs below (OV_CALLBACKS_DEFAULT etc) are defined here as
+ * static data. That means that every file which includes this header
+ * will get its own copy of these structs whether it uses them or
+ * not unless it #defines OV_EXCLUDE_STATIC_CALLBACKS.
+ * These static symbols are essential on platforms such as Windows on
+ * which several different versions of stdio support may be linked to
+ * by different DLLs, and we need to be certain we know which one
+ * we're using (the same one as the main application).
+ */
+
+static ov_callbacks OV_CALLBACKS_DEFAULT = {
+ (size_t (*)(void *, size_t, size_t, void *)) fread,
+ (int (*)(void *, ogg_int64_t, int)) _ov_header_fseek_wrap,
+ (int (*)(void *)) fclose,
+ (long (*)(void *)) ftell
+};
+
+static ov_callbacks OV_CALLBACKS_NOCLOSE = {
+ (size_t (*)(void *, size_t, size_t, void *)) fread,
+ (int (*)(void *, ogg_int64_t, int)) _ov_header_fseek_wrap,
+ (int (*)(void *)) NULL,
+ (long (*)(void *)) ftell
+};
+
+static ov_callbacks OV_CALLBACKS_STREAMONLY = {
+ (size_t (*)(void *, size_t, size_t, void *)) fread,
+ (int (*)(void *, ogg_int64_t, int)) NULL,
+ (int (*)(void *)) fclose,
+ (long (*)(void *)) NULL
+};
+
+static ov_callbacks OV_CALLBACKS_STREAMONLY_NOCLOSE = {
+ (size_t (*)(void *, size_t, size_t, void *)) fread,
+ (int (*)(void *, ogg_int64_t, int)) NULL,
+ (int (*)(void *)) NULL,
+ (long (*)(void *)) NULL
+};
+
+#endif
+
+#define NOTOPEN 0
+#define PARTOPEN 1
+#define OPENED 2
+#define STREAMSET 3
+#define INITSET 4
+
+typedef struct OggVorbis_File {
+ void *datasource; /* Pointer to a FILE *, etc. */
+ int seekable;
+ ogg_int64_t offset;
+ ogg_int64_t end;
+ ogg_sync_state oy;
+
+ /* If the FILE handle isn't seekable (eg, a pipe), only the current
+ stream appears */
+ int links;
+ ogg_int64_t *offsets;
+ ogg_int64_t *dataoffsets;
+ long *serialnos;
+ ogg_int64_t *pcmlengths; /* overloaded to maintain binary
+ compatibility; x2 size, stores both
+ beginning and end values */
+ vorbis_info *vi;
+ vorbis_comment *vc;
+
+ /* Decoding working state local storage */
+ ogg_int64_t pcm_offset;
+ int ready_state;
+ long current_serialno;
+ int current_link;
+
+ double bittrack;
+ double samptrack;
+
+ ogg_stream_state os; /* take physical pages, weld into a logical
+ stream of packets */
+ vorbis_dsp_state vd; /* central working state for the packet->PCM decoder */
+ vorbis_block vb; /* local working space for packet->PCM decode */
+
+ ov_callbacks callbacks;
+
+} OggVorbis_File;
+
+
+extern int ov_clear(OggVorbis_File *vf);
+extern int ov_fopen(const char *path,OggVorbis_File *vf);
+extern int ov_open(FILE *f,OggVorbis_File *vf,const char *initial,long ibytes);
+extern int ov_open_callbacks(void *datasource, OggVorbis_File *vf,
+ const char *initial, long ibytes, ov_callbacks callbacks);
+
+extern int ov_test(FILE *f,OggVorbis_File *vf,const char *initial,long ibytes);
+extern int ov_test_callbacks(void *datasource, OggVorbis_File *vf,
+ const char *initial, long ibytes, ov_callbacks callbacks);
+extern int ov_test_open(OggVorbis_File *vf);
+
+extern long ov_bitrate(OggVorbis_File *vf,int i);
+extern long ov_bitrate_instant(OggVorbis_File *vf);
+extern long ov_streams(OggVorbis_File *vf);
+extern long ov_seekable(OggVorbis_File *vf);
+extern long ov_serialnumber(OggVorbis_File *vf,int i);
+
+extern ogg_int64_t ov_raw_total(OggVorbis_File *vf,int i);
+extern ogg_int64_t ov_pcm_total(OggVorbis_File *vf,int i);
+extern double ov_time_total(OggVorbis_File *vf,int i);
+
+extern int ov_raw_seek(OggVorbis_File *vf,ogg_int64_t pos);
+extern int ov_pcm_seek(OggVorbis_File *vf,ogg_int64_t pos);
+extern int ov_pcm_seek_page(OggVorbis_File *vf,ogg_int64_t pos);
+extern int ov_time_seek(OggVorbis_File *vf,double pos);
+extern int ov_time_seek_page(OggVorbis_File *vf,double pos);
+
+extern int ov_raw_seek_lap(OggVorbis_File *vf,ogg_int64_t pos);
+extern int ov_pcm_seek_lap(OggVorbis_File *vf,ogg_int64_t pos);
+extern int ov_pcm_seek_page_lap(OggVorbis_File *vf,ogg_int64_t pos);
+extern int ov_time_seek_lap(OggVorbis_File *vf,double pos);
+extern int ov_time_seek_page_lap(OggVorbis_File *vf,double pos);
+
+extern ogg_int64_t ov_raw_tell(OggVorbis_File *vf);
+extern ogg_int64_t ov_pcm_tell(OggVorbis_File *vf);
+extern double ov_time_tell(OggVorbis_File *vf);
+
+extern vorbis_info *ov_info(OggVorbis_File *vf,int link);
+extern vorbis_comment *ov_comment(OggVorbis_File *vf,int link);
+
+extern long ov_read_float(OggVorbis_File *vf,float ***pcm_channels,int samples,
+ int *bitstream);
+extern long ov_read_filter(OggVorbis_File *vf,char *buffer,int length,
+ int bigendianp,int word,int sgned,int *bitstream,
+ void (*filter)(float **pcm,long channels,long samples,void *filter_param),void *filter_param);
+extern long ov_read(OggVorbis_File *vf,char *buffer,int length,
+ int bigendianp,int word,int sgned,int *bitstream);
+extern int ov_crosslap(OggVorbis_File *vf1,OggVorbis_File *vf2);
+
+extern int ov_halfrate(OggVorbis_File *vf,int flag);
+extern int ov_halfrate_p(OggVorbis_File *vf);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif
+
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: window functions
+ last mod: $Id: window.c 16227 2009-07-08 06:58:46Z xiphmont $
+
+ ********************************************************************/
+
+#include <stdlib.h>
+#include <math.h>
+#include "os.h"
+#include "misc.h"
+
+static const float vwin64[32] = {
+ 0.0009460463F, 0.0085006468F, 0.0235352254F, 0.0458950567F,
+ 0.0753351908F, 0.1115073077F, 0.1539457973F, 0.2020557475F,
+ 0.2551056759F, 0.3122276645F, 0.3724270287F, 0.4346027792F,
+ 0.4975789974F, 0.5601459521F, 0.6211085051F, 0.6793382689F,
+ 0.7338252629F, 0.7837245849F, 0.8283939355F, 0.8674186656F,
+ 0.9006222429F, 0.9280614787F, 0.9500073081F, 0.9669131782F,
+ 0.9793740220F, 0.9880792941F, 0.9937636139F, 0.9971582668F,
+ 0.9989462667F, 0.9997230082F, 0.9999638688F, 0.9999995525F,
+};
+
+static const float vwin128[64] = {
+ 0.0002365472F, 0.0021280687F, 0.0059065254F, 0.0115626550F,
+ 0.0190823442F, 0.0284463735F, 0.0396300935F, 0.0526030430F,
+ 0.0673285281F, 0.0837631763F, 0.1018564887F, 0.1215504095F,
+ 0.1427789367F, 0.1654677960F, 0.1895342001F, 0.2148867160F,
+ 0.2414252576F, 0.2690412240F, 0.2976177952F, 0.3270303960F,
+ 0.3571473350F, 0.3878306189F, 0.4189369387F, 0.4503188188F,
+ 0.4818259135F, 0.5133064334F, 0.5446086751F, 0.5755826278F,
+ 0.6060816248F, 0.6359640047F, 0.6650947483F, 0.6933470543F,
+ 0.7206038179F, 0.7467589810F, 0.7717187213F, 0.7954024542F,
+ 0.8177436264F, 0.8386902831F, 0.8582053981F, 0.8762669622F,
+ 0.8928678298F, 0.9080153310F, 0.9217306608F, 0.9340480615F,
+ 0.9450138200F, 0.9546851041F, 0.9631286621F, 0.9704194171F,
+ 0.9766389810F, 0.9818741197F, 0.9862151938F, 0.9897546035F,
+ 0.9925852598F, 0.9947991032F, 0.9964856900F, 0.9977308602F,
+ 0.9986155015F, 0.9992144193F, 0.9995953200F, 0.9998179155F,
+ 0.9999331503F, 0.9999825563F, 0.9999977357F, 0.9999999720F,
+};
+
+static const float vwin256[128] = {
+ 0.0000591390F, 0.0005321979F, 0.0014780301F, 0.0028960636F,
+ 0.0047854363F, 0.0071449926F, 0.0099732775F, 0.0132685298F,
+ 0.0170286741F, 0.0212513119F, 0.0259337111F, 0.0310727950F,
+ 0.0366651302F, 0.0427069140F, 0.0491939614F, 0.0561216907F,
+ 0.0634851102F, 0.0712788035F, 0.0794969160F, 0.0881331402F,
+ 0.0971807028F, 0.1066323515F, 0.1164803426F, 0.1267164297F,
+ 0.1373318534F, 0.1483173323F, 0.1596630553F, 0.1713586755F,
+ 0.1833933062F, 0.1957555184F, 0.2084333404F, 0.2214142599F,
+ 0.2346852280F, 0.2482326664F, 0.2620424757F, 0.2761000481F,
+ 0.2903902813F, 0.3048975959F, 0.3196059553F, 0.3344988887F,
+ 0.3495595160F, 0.3647705766F, 0.3801144597F, 0.3955732382F,
+ 0.4111287047F, 0.4267624093F, 0.4424557009F, 0.4581897696F,
+ 0.4739456913F, 0.4897044744F, 0.5054471075F, 0.5211546088F,
+ 0.5368080763F, 0.5523887395F, 0.5678780103F, 0.5832575361F,
+ 0.5985092508F, 0.6136154277F, 0.6285587300F, 0.6433222619F,
+ 0.6578896175F, 0.6722449294F, 0.6863729144F, 0.7002589187F,
+ 0.7138889597F, 0.7272497662F, 0.7403288154F, 0.7531143679F,
+ 0.7655954985F, 0.7777621249F, 0.7896050322F, 0.8011158947F,
+ 0.8122872932F, 0.8231127294F, 0.8335866365F, 0.8437043850F,
+ 0.8534622861F, 0.8628575905F, 0.8718884835F, 0.8805540765F,
+ 0.8888543947F, 0.8967903616F, 0.9043637797F, 0.9115773078F,
+ 0.9184344360F, 0.9249394562F, 0.9310974312F, 0.9369141608F,
+ 0.9423961446F, 0.9475505439F, 0.9523851406F, 0.9569082947F,
+ 0.9611289005F, 0.9650563408F, 0.9687004405F, 0.9720714191F,
+ 0.9751798427F, 0.9780365753F, 0.9806527301F, 0.9830396204F,
+ 0.9852087111F, 0.9871715701F, 0.9889398207F, 0.9905250941F,
+ 0.9919389832F, 0.9931929973F, 0.9942985174F, 0.9952667537F,
+ 0.9961087037F, 0.9968351119F, 0.9974564312F, 0.9979827858F,
+ 0.9984239359F, 0.9987892441F, 0.9990876435F, 0.9993276081F,
+ 0.9995171241F, 0.9996636648F, 0.9997741654F, 0.9998550016F,
+ 0.9999119692F, 0.9999502656F, 0.9999744742F, 0.9999885497F,
+ 0.9999958064F, 0.9999989077F, 0.9999998584F, 0.9999999983F,
+};
+
+static const float vwin512[256] = {
+ 0.0000147849F, 0.0001330607F, 0.0003695946F, 0.0007243509F,
+ 0.0011972759F, 0.0017882983F, 0.0024973285F, 0.0033242588F,
+ 0.0042689632F, 0.0053312973F, 0.0065110982F, 0.0078081841F,
+ 0.0092223540F, 0.0107533880F, 0.0124010466F, 0.0141650703F,
+ 0.0160451800F, 0.0180410758F, 0.0201524373F, 0.0223789233F,
+ 0.0247201710F, 0.0271757958F, 0.0297453914F, 0.0324285286F,
+ 0.0352247556F, 0.0381335972F, 0.0411545545F, 0.0442871045F,
+ 0.0475306997F, 0.0508847676F, 0.0543487103F, 0.0579219038F,
+ 0.0616036982F, 0.0653934164F, 0.0692903546F, 0.0732937809F,
+ 0.0774029356F, 0.0816170305F, 0.0859352485F, 0.0903567428F,
+ 0.0948806375F, 0.0995060259F, 0.1042319712F, 0.1090575056F,
+ 0.1139816300F, 0.1190033137F, 0.1241214941F, 0.1293350764F,
+ 0.1346429333F, 0.1400439046F, 0.1455367974F, 0.1511203852F,
+ 0.1567934083F, 0.1625545735F, 0.1684025537F, 0.1743359881F,
+ 0.1803534820F, 0.1864536069F, 0.1926349000F, 0.1988958650F,
+ 0.2052349715F, 0.2116506555F, 0.2181413191F, 0.2247053313F,
+ 0.2313410275F, 0.2380467105F, 0.2448206500F, 0.2516610835F,
+ 0.2585662164F, 0.2655342226F, 0.2725632448F, 0.2796513950F,
+ 0.2867967551F, 0.2939973773F, 0.3012512852F, 0.3085564739F,
+ 0.3159109111F, 0.3233125375F, 0.3307592680F, 0.3382489922F,
+ 0.3457795756F, 0.3533488602F, 0.3609546657F, 0.3685947904F,
+ 0.3762670121F, 0.3839690896F, 0.3916987634F, 0.3994537572F,
+ 0.4072317788F, 0.4150305215F, 0.4228476653F, 0.4306808783F,
+ 0.4385278181F, 0.4463861329F, 0.4542534630F, 0.4621274424F,
+ 0.4700057001F, 0.4778858615F, 0.4857655502F, 0.4936423891F,
+ 0.5015140023F, 0.5093780165F, 0.5172320626F, 0.5250737772F,
+ 0.5329008043F, 0.5407107971F, 0.5485014192F, 0.5562703465F,
+ 0.5640152688F, 0.5717338914F, 0.5794239366F, 0.5870831457F,
+ 0.5947092801F, 0.6023001235F, 0.6098534829F, 0.6173671907F,
+ 0.6248391059F, 0.6322671161F, 0.6396491384F, 0.6469831217F,
+ 0.6542670475F, 0.6614989319F, 0.6686768267F, 0.6757988210F,
+ 0.6828630426F, 0.6898676592F, 0.6968108799F, 0.7036909564F,
+ 0.7105061843F, 0.7172549043F, 0.7239355032F, 0.7305464154F,
+ 0.7370861235F, 0.7435531598F, 0.7499461068F, 0.7562635986F,
+ 0.7625043214F, 0.7686670148F, 0.7747504721F, 0.7807535410F,
+ 0.7866751247F, 0.7925141825F, 0.7982697296F, 0.8039408387F,
+ 0.8095266395F, 0.8150263196F, 0.8204391248F, 0.8257643590F,
+ 0.8310013848F, 0.8361496236F, 0.8412085555F, 0.8461777194F,
+ 0.8510567129F, 0.8558451924F, 0.8605428730F, 0.8651495278F,
+ 0.8696649882F, 0.8740891432F, 0.8784219392F, 0.8826633797F,
+ 0.8868135244F, 0.8908724888F, 0.8948404441F, 0.8987176157F,
+ 0.9025042831F, 0.9062007791F, 0.9098074886F, 0.9133248482F,
+ 0.9167533451F, 0.9200935163F, 0.9233459472F, 0.9265112712F,
+ 0.9295901680F, 0.9325833632F, 0.9354916263F, 0.9383157705F,
+ 0.9410566504F, 0.9437151618F, 0.9462922398F, 0.9487888576F,
+ 0.9512060252F, 0.9535447882F, 0.9558062262F, 0.9579914516F,
+ 0.9601016078F, 0.9621378683F, 0.9641014348F, 0.9659935361F,
+ 0.9678154261F, 0.9695683830F, 0.9712537071F, 0.9728727198F,
+ 0.9744267618F, 0.9759171916F, 0.9773453842F, 0.9787127293F,
+ 0.9800206298F, 0.9812705006F, 0.9824637665F, 0.9836018613F,
+ 0.9846862258F, 0.9857183066F, 0.9866995544F, 0.9876314227F,
+ 0.9885153662F, 0.9893528393F, 0.9901452948F, 0.9908941823F,
+ 0.9916009470F, 0.9922670279F, 0.9928938570F, 0.9934828574F,
+ 0.9940354423F, 0.9945530133F, 0.9950369595F, 0.9954886562F,
+ 0.9959094633F, 0.9963007242F, 0.9966637649F, 0.9969998925F,
+ 0.9973103939F, 0.9975965351F, 0.9978595598F, 0.9981006885F,
+ 0.9983211172F, 0.9985220166F, 0.9987045311F, 0.9988697776F,
+ 0.9990188449F, 0.9991527924F, 0.9992726499F, 0.9993794157F,
+ 0.9994740570F, 0.9995575079F, 0.9996306699F, 0.9996944099F,
+ 0.9997495605F, 0.9997969190F, 0.9998372465F, 0.9998712678F,
+ 0.9998996704F, 0.9999231041F, 0.9999421807F, 0.9999574732F,
+ 0.9999695157F, 0.9999788026F, 0.9999857885F, 0.9999908879F,
+ 0.9999944746F, 0.9999968817F, 0.9999984010F, 0.9999992833F,
+ 0.9999997377F, 0.9999999317F, 0.9999999911F, 0.9999999999F,
+};
+
+static const float vwin1024[512] = {
+ 0.0000036962F, 0.0000332659F, 0.0000924041F, 0.0001811086F,
+ 0.0002993761F, 0.0004472021F, 0.0006245811F, 0.0008315063F,
+ 0.0010679699F, 0.0013339631F, 0.0016294757F, 0.0019544965F,
+ 0.0023090133F, 0.0026930125F, 0.0031064797F, 0.0035493989F,
+ 0.0040217533F, 0.0045235250F, 0.0050546946F, 0.0056152418F,
+ 0.0062051451F, 0.0068243817F, 0.0074729278F, 0.0081507582F,
+ 0.0088578466F, 0.0095941655F, 0.0103596863F, 0.0111543789F,
+ 0.0119782122F, 0.0128311538F, 0.0137131701F, 0.0146242260F,
+ 0.0155642855F, 0.0165333111F, 0.0175312640F, 0.0185581042F,
+ 0.0196137903F, 0.0206982797F, 0.0218115284F, 0.0229534910F,
+ 0.0241241208F, 0.0253233698F, 0.0265511886F, 0.0278075263F,
+ 0.0290923308F, 0.0304055484F, 0.0317471241F, 0.0331170013F,
+ 0.0345151222F, 0.0359414274F, 0.0373958560F, 0.0388783456F,
+ 0.0403888325F, 0.0419272511F, 0.0434935347F, 0.0450876148F,
+ 0.0467094213F, 0.0483588828F, 0.0500359261F, 0.0517404765F,
+ 0.0534724575F, 0.0552317913F, 0.0570183983F, 0.0588321971F,
+ 0.0606731048F, 0.0625410369F, 0.0644359070F, 0.0663576272F,
+ 0.0683061077F, 0.0702812571F, 0.0722829821F, 0.0743111878F,
+ 0.0763657775F, 0.0784466526F, 0.0805537129F, 0.0826868561F,
+ 0.0848459782F, 0.0870309736F, 0.0892417345F, 0.0914781514F,
+ 0.0937401128F, 0.0960275056F, 0.0983402145F, 0.1006781223F,
+ 0.1030411101F, 0.1054290568F, 0.1078418397F, 0.1102793336F,
+ 0.1127414119F, 0.1152279457F, 0.1177388042F, 0.1202738544F,
+ 0.1228329618F, 0.1254159892F, 0.1280227980F, 0.1306532471F,
+ 0.1333071937F, 0.1359844927F, 0.1386849970F, 0.1414085575F,
+ 0.1441550230F, 0.1469242403F, 0.1497160539F, 0.1525303063F,
+ 0.1553668381F, 0.1582254875F, 0.1611060909F, 0.1640084822F,
+ 0.1669324936F, 0.1698779549F, 0.1728446939F, 0.1758325362F,
+ 0.1788413055F, 0.1818708232F, 0.1849209084F, 0.1879913785F,
+ 0.1910820485F, 0.1941927312F, 0.1973232376F, 0.2004733764F,
+ 0.2036429541F, 0.2068317752F, 0.2100396421F, 0.2132663552F,
+ 0.2165117125F, 0.2197755102F, 0.2230575422F, 0.2263576007F,
+ 0.2296754753F, 0.2330109540F, 0.2363638225F, 0.2397338646F,
+ 0.2431208619F, 0.2465245941F, 0.2499448389F, 0.2533813719F,
+ 0.2568339669F, 0.2603023956F, 0.2637864277F, 0.2672858312F,
+ 0.2708003718F, 0.2743298135F, 0.2778739186F, 0.2814324472F,
+ 0.2850051576F, 0.2885918065F, 0.2921921485F, 0.2958059366F,
+ 0.2994329219F, 0.3030728538F, 0.3067254799F, 0.3103905462F,
+ 0.3140677969F, 0.3177569747F, 0.3214578205F, 0.3251700736F,
+ 0.3288934718F, 0.3326277513F, 0.3363726468F, 0.3401278914F,
+ 0.3438932168F, 0.3476683533F, 0.3514530297F, 0.3552469734F,
+ 0.3590499106F, 0.3628615659F, 0.3666816630F, 0.3705099239F,
+ 0.3743460698F, 0.3781898204F, 0.3820408945F, 0.3858990095F,
+ 0.3897638820F, 0.3936352274F, 0.3975127601F, 0.4013961936F,
+ 0.4052852405F, 0.4091796123F, 0.4130790198F, 0.4169831732F,
+ 0.4208917815F, 0.4248045534F, 0.4287211965F, 0.4326414181F,
+ 0.4365649248F, 0.4404914225F, 0.4444206167F, 0.4483522125F,
+ 0.4522859146F, 0.4562214270F, 0.4601584538F, 0.4640966984F,
+ 0.4680358644F, 0.4719756548F, 0.4759157726F, 0.4798559209F,
+ 0.4837958024F, 0.4877351199F, 0.4916735765F, 0.4956108751F,
+ 0.4995467188F, 0.5034808109F, 0.5074128550F, 0.5113425550F,
+ 0.5152696149F, 0.5191937395F, 0.5231146336F, 0.5270320028F,
+ 0.5309455530F, 0.5348549910F, 0.5387600239F, 0.5426603597F,
+ 0.5465557070F, 0.5504457754F, 0.5543302752F, 0.5582089175F,
+ 0.5620814145F, 0.5659474793F, 0.5698068262F, 0.5736591704F,
+ 0.5775042283F, 0.5813417176F, 0.5851713571F, 0.5889928670F,
+ 0.5928059689F, 0.5966103856F, 0.6004058415F, 0.6041920626F,
+ 0.6079687761F, 0.6117357113F, 0.6154925986F, 0.6192391705F,
+ 0.6229751612F, 0.6267003064F, 0.6304143441F, 0.6341170137F,
+ 0.6378080569F, 0.6414872173F, 0.6451542405F, 0.6488088741F,
+ 0.6524508681F, 0.6560799742F, 0.6596959469F, 0.6632985424F,
+ 0.6668875197F, 0.6704626398F, 0.6740236662F, 0.6775703649F,
+ 0.6811025043F, 0.6846198554F, 0.6881221916F, 0.6916092892F,
+ 0.6950809269F, 0.6985368861F, 0.7019769510F, 0.7054009085F,
+ 0.7088085484F, 0.7121996632F, 0.7155740484F, 0.7189315023F,
+ 0.7222718263F, 0.7255948245F, 0.7289003043F, 0.7321880760F,
+ 0.7354579530F, 0.7387097518F, 0.7419432921F, 0.7451583966F,
+ 0.7483548915F, 0.7515326059F, 0.7546913723F, 0.7578310265F,
+ 0.7609514077F, 0.7640523581F, 0.7671337237F, 0.7701953535F,
+ 0.7732371001F, 0.7762588195F, 0.7792603711F, 0.7822416178F,
+ 0.7852024259F, 0.7881426654F, 0.7910622097F, 0.7939609356F,
+ 0.7968387237F, 0.7996954579F, 0.8025310261F, 0.8053453193F,
+ 0.8081382324F, 0.8109096638F, 0.8136595156F, 0.8163876936F,
+ 0.8190941071F, 0.8217786690F, 0.8244412960F, 0.8270819086F,
+ 0.8297004305F, 0.8322967896F, 0.8348709171F, 0.8374227481F,
+ 0.8399522213F, 0.8424592789F, 0.8449438672F, 0.8474059356F,
+ 0.8498454378F, 0.8522623306F, 0.8546565748F, 0.8570281348F,
+ 0.8593769787F, 0.8617030779F, 0.8640064080F, 0.8662869477F,
+ 0.8685446796F, 0.8707795899F, 0.8729916682F, 0.8751809079F,
+ 0.8773473059F, 0.8794908626F, 0.8816115819F, 0.8837094713F,
+ 0.8857845418F, 0.8878368079F, 0.8898662874F, 0.8918730019F,
+ 0.8938569760F, 0.8958182380F, 0.8977568194F, 0.8996727552F,
+ 0.9015660837F, 0.9034368465F, 0.9052850885F, 0.9071108577F,
+ 0.9089142057F, 0.9106951869F, 0.9124538591F, 0.9141902832F,
+ 0.9159045233F, 0.9175966464F, 0.9192667228F, 0.9209148257F,
+ 0.9225410313F, 0.9241454187F, 0.9257280701F, 0.9272890704F,
+ 0.9288285075F, 0.9303464720F, 0.9318430576F, 0.9333183603F,
+ 0.9347724792F, 0.9362055158F, 0.9376175745F, 0.9390087622F,
+ 0.9403791881F, 0.9417289644F, 0.9430582055F, 0.9443670283F,
+ 0.9456555521F, 0.9469238986F, 0.9481721917F, 0.9494005577F,
+ 0.9506091252F, 0.9517980248F, 0.9529673894F, 0.9541173540F,
+ 0.9552480557F, 0.9563596334F, 0.9574522282F, 0.9585259830F,
+ 0.9595810428F, 0.9606175542F, 0.9616356656F, 0.9626355274F,
+ 0.9636172915F, 0.9645811114F, 0.9655271425F, 0.9664555414F,
+ 0.9673664664F, 0.9682600774F, 0.9691365355F, 0.9699960034F,
+ 0.9708386448F, 0.9716646250F, 0.9724741103F, 0.9732672685F,
+ 0.9740442683F, 0.9748052795F, 0.9755504729F, 0.9762800205F,
+ 0.9769940950F, 0.9776928703F, 0.9783765210F, 0.9790452223F,
+ 0.9796991504F, 0.9803384823F, 0.9809633954F, 0.9815740679F,
+ 0.9821706784F, 0.9827534063F, 0.9833224312F, 0.9838779332F,
+ 0.9844200928F, 0.9849490910F, 0.9854651087F, 0.9859683274F,
+ 0.9864589286F, 0.9869370940F, 0.9874030054F, 0.9878568447F,
+ 0.9882987937F, 0.9887290343F, 0.9891477481F, 0.9895551169F,
+ 0.9899513220F, 0.9903365446F, 0.9907109658F, 0.9910747662F,
+ 0.9914281260F, 0.9917712252F, 0.9921042433F, 0.9924273593F,
+ 0.9927407516F, 0.9930445982F, 0.9933390763F, 0.9936243626F,
+ 0.9939006331F, 0.9941680631F, 0.9944268269F, 0.9946770982F,
+ 0.9949190498F, 0.9951528537F, 0.9953786808F, 0.9955967011F,
+ 0.9958070836F, 0.9960099963F, 0.9962056061F, 0.9963940787F,
+ 0.9965755786F, 0.9967502693F, 0.9969183129F, 0.9970798704F,
+ 0.9972351013F, 0.9973841640F, 0.9975272151F, 0.9976644103F,
+ 0.9977959036F, 0.9979218476F, 0.9980423932F, 0.9981576901F,
+ 0.9982678862F, 0.9983731278F, 0.9984735596F, 0.9985693247F,
+ 0.9986605645F, 0.9987474186F, 0.9988300248F, 0.9989085193F,
+ 0.9989830364F, 0.9990537085F, 0.9991206662F, 0.9991840382F,
+ 0.9992439513F, 0.9993005303F, 0.9993538982F, 0.9994041757F,
+ 0.9994514817F, 0.9994959330F, 0.9995376444F, 0.9995767286F,
+ 0.9996132960F, 0.9996474550F, 0.9996793121F, 0.9997089710F,
+ 0.9997365339F, 0.9997621003F, 0.9997857677F, 0.9998076311F,
+ 0.9998277836F, 0.9998463156F, 0.9998633155F, 0.9998788692F,
+ 0.9998930603F, 0.9999059701F, 0.9999176774F, 0.9999282586F,
+ 0.9999377880F, 0.9999463370F, 0.9999539749F, 0.9999607685F,
+ 0.9999667820F, 0.9999720773F, 0.9999767136F, 0.9999807479F,
+ 0.9999842344F, 0.9999872249F, 0.9999897688F, 0.9999919127F,
+ 0.9999937009F, 0.9999951749F, 0.9999963738F, 0.9999973342F,
+ 0.9999980900F, 0.9999986724F, 0.9999991103F, 0.9999994297F,
+ 0.9999996543F, 0.9999998049F, 0.9999999000F, 0.9999999552F,
+ 0.9999999836F, 0.9999999957F, 0.9999999994F, 1.0000000000F,
+};
+
+static const float vwin2048[1024] = {
+ 0.0000009241F, 0.0000083165F, 0.0000231014F, 0.0000452785F,
+ 0.0000748476F, 0.0001118085F, 0.0001561608F, 0.0002079041F,
+ 0.0002670379F, 0.0003335617F, 0.0004074748F, 0.0004887765F,
+ 0.0005774661F, 0.0006735427F, 0.0007770054F, 0.0008878533F,
+ 0.0010060853F, 0.0011317002F, 0.0012646969F, 0.0014050742F,
+ 0.0015528307F, 0.0017079650F, 0.0018704756F, 0.0020403610F,
+ 0.0022176196F, 0.0024022497F, 0.0025942495F, 0.0027936173F,
+ 0.0030003511F, 0.0032144490F, 0.0034359088F, 0.0036647286F,
+ 0.0039009061F, 0.0041444391F, 0.0043953253F, 0.0046535621F,
+ 0.0049191472F, 0.0051920781F, 0.0054723520F, 0.0057599664F,
+ 0.0060549184F, 0.0063572052F, 0.0066668239F, 0.0069837715F,
+ 0.0073080449F, 0.0076396410F, 0.0079785566F, 0.0083247884F,
+ 0.0086783330F, 0.0090391871F, 0.0094073470F, 0.0097828092F,
+ 0.0101655700F, 0.0105556258F, 0.0109529726F, 0.0113576065F,
+ 0.0117695237F, 0.0121887200F, 0.0126151913F, 0.0130489335F,
+ 0.0134899422F, 0.0139382130F, 0.0143937415F, 0.0148565233F,
+ 0.0153265536F, 0.0158038279F, 0.0162883413F, 0.0167800889F,
+ 0.0172790660F, 0.0177852675F, 0.0182986882F, 0.0188193231F,
+ 0.0193471668F, 0.0198822141F, 0.0204244594F, 0.0209738974F,
+ 0.0215305225F, 0.0220943289F, 0.0226653109F, 0.0232434627F,
+ 0.0238287784F, 0.0244212519F, 0.0250208772F, 0.0256276481F,
+ 0.0262415582F, 0.0268626014F, 0.0274907711F, 0.0281260608F,
+ 0.0287684638F, 0.0294179736F, 0.0300745833F, 0.0307382859F,
+ 0.0314090747F, 0.0320869424F, 0.0327718819F, 0.0334638860F,
+ 0.0341629474F, 0.0348690586F, 0.0355822122F, 0.0363024004F,
+ 0.0370296157F, 0.0377638502F, 0.0385050960F, 0.0392533451F,
+ 0.0400085896F, 0.0407708211F, 0.0415400315F, 0.0423162123F,
+ 0.0430993552F, 0.0438894515F, 0.0446864926F, 0.0454904698F,
+ 0.0463013742F, 0.0471191969F, 0.0479439288F, 0.0487755607F,
+ 0.0496140836F, 0.0504594879F, 0.0513117642F, 0.0521709031F,
+ 0.0530368949F, 0.0539097297F, 0.0547893979F, 0.0556758894F,
+ 0.0565691941F, 0.0574693019F, 0.0583762026F, 0.0592898858F,
+ 0.0602103410F, 0.0611375576F, 0.0620715250F, 0.0630122324F,
+ 0.0639596688F, 0.0649138234F, 0.0658746848F, 0.0668422421F,
+ 0.0678164838F, 0.0687973985F, 0.0697849746F, 0.0707792005F,
+ 0.0717800645F, 0.0727875547F, 0.0738016591F, 0.0748223656F,
+ 0.0758496620F, 0.0768835359F, 0.0779239751F, 0.0789709668F,
+ 0.0800244985F, 0.0810845574F, 0.0821511306F, 0.0832242052F,
+ 0.0843037679F, 0.0853898056F, 0.0864823050F, 0.0875812525F,
+ 0.0886866347F, 0.0897984378F, 0.0909166480F, 0.0920412513F,
+ 0.0931722338F, 0.0943095813F, 0.0954532795F, 0.0966033140F,
+ 0.0977596702F, 0.0989223336F, 0.1000912894F, 0.1012665227F,
+ 0.1024480185F, 0.1036357616F, 0.1048297369F, 0.1060299290F,
+ 0.1072363224F, 0.1084489014F, 0.1096676504F, 0.1108925534F,
+ 0.1121235946F, 0.1133607577F, 0.1146040267F, 0.1158533850F,
+ 0.1171088163F, 0.1183703040F, 0.1196378312F, 0.1209113812F,
+ 0.1221909370F, 0.1234764815F, 0.1247679974F, 0.1260654674F,
+ 0.1273688740F, 0.1286781995F, 0.1299934263F, 0.1313145365F,
+ 0.1326415121F, 0.1339743349F, 0.1353129866F, 0.1366574490F,
+ 0.1380077035F, 0.1393637315F, 0.1407255141F, 0.1420930325F,
+ 0.1434662677F, 0.1448452004F, 0.1462298115F, 0.1476200814F,
+ 0.1490159906F, 0.1504175195F, 0.1518246482F, 0.1532373569F,
+ 0.1546556253F, 0.1560794333F, 0.1575087606F, 0.1589435866F,
+ 0.1603838909F, 0.1618296526F, 0.1632808509F, 0.1647374648F,
+ 0.1661994731F, 0.1676668546F, 0.1691395880F, 0.1706176516F,
+ 0.1721010238F, 0.1735896829F, 0.1750836068F, 0.1765827736F,
+ 0.1780871610F, 0.1795967468F, 0.1811115084F, 0.1826314234F,
+ 0.1841564689F, 0.1856866221F, 0.1872218600F, 0.1887621595F,
+ 0.1903074974F, 0.1918578503F, 0.1934131947F, 0.1949735068F,
+ 0.1965387630F, 0.1981089393F, 0.1996840117F, 0.2012639560F,
+ 0.2028487479F, 0.2044383630F, 0.2060327766F, 0.2076319642F,
+ 0.2092359007F, 0.2108445614F, 0.2124579211F, 0.2140759545F,
+ 0.2156986364F, 0.2173259411F, 0.2189578432F, 0.2205943168F,
+ 0.2222353361F, 0.2238808751F, 0.2255309076F, 0.2271854073F,
+ 0.2288443480F, 0.2305077030F, 0.2321754457F, 0.2338475493F,
+ 0.2355239869F, 0.2372047315F, 0.2388897560F, 0.2405790329F,
+ 0.2422725350F, 0.2439702347F, 0.2456721043F, 0.2473781159F,
+ 0.2490882418F, 0.2508024539F, 0.2525207240F, 0.2542430237F,
+ 0.2559693248F, 0.2576995986F, 0.2594338166F, 0.2611719498F,
+ 0.2629139695F, 0.2646598466F, 0.2664095520F, 0.2681630564F,
+ 0.2699203304F, 0.2716813445F, 0.2734460691F, 0.2752144744F,
+ 0.2769865307F, 0.2787622079F, 0.2805414760F, 0.2823243047F,
+ 0.2841106637F, 0.2859005227F, 0.2876938509F, 0.2894906179F,
+ 0.2912907928F, 0.2930943447F, 0.2949012426F, 0.2967114554F,
+ 0.2985249520F, 0.3003417009F, 0.3021616708F, 0.3039848301F,
+ 0.3058111471F, 0.3076405901F, 0.3094731273F, 0.3113087266F,
+ 0.3131473560F, 0.3149889833F, 0.3168335762F, 0.3186811024F,
+ 0.3205315294F, 0.3223848245F, 0.3242409552F, 0.3260998886F,
+ 0.3279615918F, 0.3298260319F, 0.3316931758F, 0.3335629903F,
+ 0.3354354423F, 0.3373104982F, 0.3391881247F, 0.3410682882F,
+ 0.3429509551F, 0.3448360917F, 0.3467236642F, 0.3486136387F,
+ 0.3505059811F, 0.3524006575F, 0.3542976336F, 0.3561968753F,
+ 0.3580983482F, 0.3600020179F, 0.3619078499F, 0.3638158096F,
+ 0.3657258625F, 0.3676379737F, 0.3695521086F, 0.3714682321F,
+ 0.3733863094F, 0.3753063055F, 0.3772281852F, 0.3791519134F,
+ 0.3810774548F, 0.3830047742F, 0.3849338362F, 0.3868646053F,
+ 0.3887970459F, 0.3907311227F, 0.3926667998F, 0.3946040417F,
+ 0.3965428125F, 0.3984830765F, 0.4004247978F, 0.4023679403F,
+ 0.4043124683F, 0.4062583455F, 0.4082055359F, 0.4101540034F,
+ 0.4121037117F, 0.4140546246F, 0.4160067058F, 0.4179599190F,
+ 0.4199142277F, 0.4218695956F, 0.4238259861F, 0.4257833627F,
+ 0.4277416888F, 0.4297009279F, 0.4316610433F, 0.4336219983F,
+ 0.4355837562F, 0.4375462803F, 0.4395095337F, 0.4414734797F,
+ 0.4434380815F, 0.4454033021F, 0.4473691046F, 0.4493354521F,
+ 0.4513023078F, 0.4532696345F, 0.4552373954F, 0.4572055533F,
+ 0.4591740713F, 0.4611429123F, 0.4631120393F, 0.4650814151F,
+ 0.4670510028F, 0.4690207650F, 0.4709906649F, 0.4729606651F,
+ 0.4749307287F, 0.4769008185F, 0.4788708972F, 0.4808409279F,
+ 0.4828108732F, 0.4847806962F, 0.4867503597F, 0.4887198264F,
+ 0.4906890593F, 0.4926580213F, 0.4946266753F, 0.4965949840F,
+ 0.4985629105F, 0.5005304176F, 0.5024974683F, 0.5044640255F,
+ 0.5064300522F, 0.5083955114F, 0.5103603659F, 0.5123245790F,
+ 0.5142881136F, 0.5162509328F, 0.5182129997F, 0.5201742774F,
+ 0.5221347290F, 0.5240943178F, 0.5260530070F, 0.5280107598F,
+ 0.5299675395F, 0.5319233095F, 0.5338780330F, 0.5358316736F,
+ 0.5377841946F, 0.5397355596F, 0.5416857320F, 0.5436346755F,
+ 0.5455823538F, 0.5475287304F, 0.5494737691F, 0.5514174337F,
+ 0.5533596881F, 0.5553004962F, 0.5572398218F, 0.5591776291F,
+ 0.5611138821F, 0.5630485449F, 0.5649815818F, 0.5669129570F,
+ 0.5688426349F, 0.5707705799F, 0.5726967564F, 0.5746211290F,
+ 0.5765436624F, 0.5784643212F, 0.5803830702F, 0.5822998743F,
+ 0.5842146984F, 0.5861275076F, 0.5880382669F, 0.5899469416F,
+ 0.5918534968F, 0.5937578981F, 0.5956601107F, 0.5975601004F,
+ 0.5994578326F, 0.6013532732F, 0.6032463880F, 0.6051371429F,
+ 0.6070255039F, 0.6089114372F, 0.6107949090F, 0.6126758856F,
+ 0.6145543334F, 0.6164302191F, 0.6183035092F, 0.6201741706F,
+ 0.6220421700F, 0.6239074745F, 0.6257700513F, 0.6276298674F,
+ 0.6294868903F, 0.6313410873F, 0.6331924262F, 0.6350408745F,
+ 0.6368864001F, 0.6387289710F, 0.6405685552F, 0.6424051209F,
+ 0.6442386364F, 0.6460690702F, 0.6478963910F, 0.6497205673F,
+ 0.6515415682F, 0.6533593625F, 0.6551739194F, 0.6569852082F,
+ 0.6587931984F, 0.6605978593F, 0.6623991609F, 0.6641970728F,
+ 0.6659915652F, 0.6677826081F, 0.6695701718F, 0.6713542268F,
+ 0.6731347437F, 0.6749116932F, 0.6766850461F, 0.6784547736F,
+ 0.6802208469F, 0.6819832374F, 0.6837419164F, 0.6854968559F,
+ 0.6872480275F, 0.6889954034F, 0.6907389556F, 0.6924786566F,
+ 0.6942144788F, 0.6959463950F, 0.6976743780F, 0.6993984008F,
+ 0.7011184365F, 0.7028344587F, 0.7045464407F, 0.7062543564F,
+ 0.7079581796F, 0.7096578844F, 0.7113534450F, 0.7130448359F,
+ 0.7147320316F, 0.7164150070F, 0.7180937371F, 0.7197681970F,
+ 0.7214383620F, 0.7231042077F, 0.7247657098F, 0.7264228443F,
+ 0.7280755871F, 0.7297239147F, 0.7313678035F, 0.7330072301F,
+ 0.7346421715F, 0.7362726046F, 0.7378985069F, 0.7395198556F,
+ 0.7411366285F, 0.7427488034F, 0.7443563584F, 0.7459592717F,
+ 0.7475575218F, 0.7491510873F, 0.7507399471F, 0.7523240803F,
+ 0.7539034661F, 0.7554780839F, 0.7570479136F, 0.7586129349F,
+ 0.7601731279F, 0.7617284730F, 0.7632789506F, 0.7648245416F,
+ 0.7663652267F, 0.7679009872F, 0.7694318044F, 0.7709576599F,
+ 0.7724785354F, 0.7739944130F, 0.7755052749F, 0.7770111035F,
+ 0.7785118815F, 0.7800075916F, 0.7814982170F, 0.7829837410F,
+ 0.7844641472F, 0.7859394191F, 0.7874095408F, 0.7888744965F,
+ 0.7903342706F, 0.7917888476F, 0.7932382124F, 0.7946823501F,
+ 0.7961212460F, 0.7975548855F, 0.7989832544F, 0.8004063386F,
+ 0.8018241244F, 0.8032365981F, 0.8046437463F, 0.8060455560F,
+ 0.8074420141F, 0.8088331080F, 0.8102188253F, 0.8115991536F,
+ 0.8129740810F, 0.8143435957F, 0.8157076861F, 0.8170663409F,
+ 0.8184195489F, 0.8197672994F, 0.8211095817F, 0.8224463853F,
+ 0.8237777001F, 0.8251035161F, 0.8264238235F, 0.8277386129F,
+ 0.8290478750F, 0.8303516008F, 0.8316497814F, 0.8329424083F,
+ 0.8342294731F, 0.8355109677F, 0.8367868841F, 0.8380572148F,
+ 0.8393219523F, 0.8405810893F, 0.8418346190F, 0.8430825345F,
+ 0.8443248294F, 0.8455614974F, 0.8467925323F, 0.8480179285F,
+ 0.8492376802F, 0.8504517822F, 0.8516602292F, 0.8528630164F,
+ 0.8540601391F, 0.8552515928F, 0.8564373733F, 0.8576174766F,
+ 0.8587918990F, 0.8599606368F, 0.8611236868F, 0.8622810460F,
+ 0.8634327113F, 0.8645786802F, 0.8657189504F, 0.8668535195F,
+ 0.8679823857F, 0.8691055472F, 0.8702230025F, 0.8713347503F,
+ 0.8724407896F, 0.8735411194F, 0.8746357394F, 0.8757246489F,
+ 0.8768078479F, 0.8778853364F, 0.8789571146F, 0.8800231832F,
+ 0.8810835427F, 0.8821381942F, 0.8831871387F, 0.8842303777F,
+ 0.8852679127F, 0.8862997456F, 0.8873258784F, 0.8883463132F,
+ 0.8893610527F, 0.8903700994F, 0.8913734562F, 0.8923711263F,
+ 0.8933631129F, 0.8943494196F, 0.8953300500F, 0.8963050083F,
+ 0.8972742985F, 0.8982379249F, 0.8991958922F, 0.9001482052F,
+ 0.9010948688F, 0.9020358883F, 0.9029712690F, 0.9039010165F,
+ 0.9048251367F, 0.9057436357F, 0.9066565195F, 0.9075637946F,
+ 0.9084654678F, 0.9093615456F, 0.9102520353F, 0.9111369440F,
+ 0.9120162792F, 0.9128900484F, 0.9137582595F, 0.9146209204F,
+ 0.9154780394F, 0.9163296248F, 0.9171756853F, 0.9180162296F,
+ 0.9188512667F, 0.9196808057F, 0.9205048559F, 0.9213234270F,
+ 0.9221365285F, 0.9229441704F, 0.9237463629F, 0.9245431160F,
+ 0.9253344404F, 0.9261203465F, 0.9269008453F, 0.9276759477F,
+ 0.9284456648F, 0.9292100080F, 0.9299689889F, 0.9307226190F,
+ 0.9314709103F, 0.9322138747F, 0.9329515245F, 0.9336838721F,
+ 0.9344109300F, 0.9351327108F, 0.9358492275F, 0.9365604931F,
+ 0.9372665208F, 0.9379673239F, 0.9386629160F, 0.9393533107F,
+ 0.9400385220F, 0.9407185637F, 0.9413934501F, 0.9420631954F,
+ 0.9427278141F, 0.9433873208F, 0.9440417304F, 0.9446910576F,
+ 0.9453353176F, 0.9459745255F, 0.9466086968F, 0.9472378469F,
+ 0.9478619915F, 0.9484811463F, 0.9490953274F, 0.9497045506F,
+ 0.9503088323F, 0.9509081888F, 0.9515026365F, 0.9520921921F,
+ 0.9526768723F, 0.9532566940F, 0.9538316742F, 0.9544018300F,
+ 0.9549671786F, 0.9555277375F, 0.9560835241F, 0.9566345562F,
+ 0.9571808513F, 0.9577224275F, 0.9582593027F, 0.9587914949F,
+ 0.9593190225F, 0.9598419038F, 0.9603601571F, 0.9608738012F,
+ 0.9613828546F, 0.9618873361F, 0.9623872646F, 0.9628826591F,
+ 0.9633735388F, 0.9638599227F, 0.9643418303F, 0.9648192808F,
+ 0.9652922939F, 0.9657608890F, 0.9662250860F, 0.9666849046F,
+ 0.9671403646F, 0.9675914861F, 0.9680382891F, 0.9684807937F,
+ 0.9689190202F, 0.9693529890F, 0.9697827203F, 0.9702082347F,
+ 0.9706295529F, 0.9710466953F, 0.9714596828F, 0.9718685362F,
+ 0.9722732762F, 0.9726739240F, 0.9730705005F, 0.9734630267F,
+ 0.9738515239F, 0.9742360134F, 0.9746165163F, 0.9749930540F,
+ 0.9753656481F, 0.9757343198F, 0.9760990909F, 0.9764599829F,
+ 0.9768170175F, 0.9771702164F, 0.9775196013F, 0.9778651941F,
+ 0.9782070167F, 0.9785450909F, 0.9788794388F, 0.9792100824F,
+ 0.9795370437F, 0.9798603449F, 0.9801800080F, 0.9804960554F,
+ 0.9808085092F, 0.9811173916F, 0.9814227251F, 0.9817245318F,
+ 0.9820228343F, 0.9823176549F, 0.9826090160F, 0.9828969402F,
+ 0.9831814498F, 0.9834625674F, 0.9837403156F, 0.9840147169F,
+ 0.9842857939F, 0.9845535692F, 0.9848180654F, 0.9850793052F,
+ 0.9853373113F, 0.9855921062F, 0.9858437127F, 0.9860921535F,
+ 0.9863374512F, 0.9865796287F, 0.9868187085F, 0.9870547136F,
+ 0.9872876664F, 0.9875175899F, 0.9877445067F, 0.9879684396F,
+ 0.9881894112F, 0.9884074444F, 0.9886225619F, 0.9888347863F,
+ 0.9890441404F, 0.9892506468F, 0.9894543284F, 0.9896552077F,
+ 0.9898533074F, 0.9900486502F, 0.9902412587F, 0.9904311555F,
+ 0.9906183633F, 0.9908029045F, 0.9909848019F, 0.9911640779F,
+ 0.9913407550F, 0.9915148557F, 0.9916864025F, 0.9918554179F,
+ 0.9920219241F, 0.9921859437F, 0.9923474989F, 0.9925066120F,
+ 0.9926633054F, 0.9928176012F, 0.9929695218F, 0.9931190891F,
+ 0.9932663254F, 0.9934112527F, 0.9935538932F, 0.9936942686F,
+ 0.9938324012F, 0.9939683126F, 0.9941020248F, 0.9942335597F,
+ 0.9943629388F, 0.9944901841F, 0.9946153170F, 0.9947383593F,
+ 0.9948593325F, 0.9949782579F, 0.9950951572F, 0.9952100516F,
+ 0.9953229625F, 0.9954339111F, 0.9955429186F, 0.9956500062F,
+ 0.9957551948F, 0.9958585056F, 0.9959599593F, 0.9960595769F,
+ 0.9961573792F, 0.9962533869F, 0.9963476206F, 0.9964401009F,
+ 0.9965308483F, 0.9966198833F, 0.9967072261F, 0.9967928971F,
+ 0.9968769164F, 0.9969593041F, 0.9970400804F, 0.9971192651F,
+ 0.9971968781F, 0.9972729391F, 0.9973474680F, 0.9974204842F,
+ 0.9974920074F, 0.9975620569F, 0.9976306521F, 0.9976978122F,
+ 0.9977635565F, 0.9978279039F, 0.9978908736F, 0.9979524842F,
+ 0.9980127547F, 0.9980717037F, 0.9981293499F, 0.9981857116F,
+ 0.9982408073F, 0.9982946554F, 0.9983472739F, 0.9983986810F,
+ 0.9984488947F, 0.9984979328F, 0.9985458132F, 0.9985925534F,
+ 0.9986381711F, 0.9986826838F, 0.9987261086F, 0.9987684630F,
+ 0.9988097640F, 0.9988500286F, 0.9988892738F, 0.9989275163F,
+ 0.9989647727F, 0.9990010597F, 0.9990363938F, 0.9990707911F,
+ 0.9991042679F, 0.9991368404F, 0.9991685244F, 0.9991993358F,
+ 0.9992292905F, 0.9992584038F, 0.9992866914F, 0.9993141686F,
+ 0.9993408506F, 0.9993667526F, 0.9993918895F, 0.9994162761F,
+ 0.9994399273F, 0.9994628576F, 0.9994850815F, 0.9995066133F,
+ 0.9995274672F, 0.9995476574F, 0.9995671978F, 0.9995861021F,
+ 0.9996043841F, 0.9996220573F, 0.9996391352F, 0.9996556310F,
+ 0.9996715579F, 0.9996869288F, 0.9997017568F, 0.9997160543F,
+ 0.9997298342F, 0.9997431088F, 0.9997558905F, 0.9997681914F,
+ 0.9997800236F, 0.9997913990F, 0.9998023292F, 0.9998128261F,
+ 0.9998229009F, 0.9998325650F, 0.9998418296F, 0.9998507058F,
+ 0.9998592044F, 0.9998673362F, 0.9998751117F, 0.9998825415F,
+ 0.9998896358F, 0.9998964047F, 0.9999028584F, 0.9999090066F,
+ 0.9999148590F, 0.9999204253F, 0.9999257148F, 0.9999307368F,
+ 0.9999355003F, 0.9999400144F, 0.9999442878F, 0.9999483293F,
+ 0.9999521472F, 0.9999557499F, 0.9999591457F, 0.9999623426F,
+ 0.9999653483F, 0.9999681708F, 0.9999708175F, 0.9999732959F,
+ 0.9999756132F, 0.9999777765F, 0.9999797928F, 0.9999816688F,
+ 0.9999834113F, 0.9999850266F, 0.9999865211F, 0.9999879009F,
+ 0.9999891721F, 0.9999903405F, 0.9999914118F, 0.9999923914F,
+ 0.9999932849F, 0.9999940972F, 0.9999948336F, 0.9999954989F,
+ 0.9999960978F, 0.9999966349F, 0.9999971146F, 0.9999975411F,
+ 0.9999979185F, 0.9999982507F, 0.9999985414F, 0.9999987944F,
+ 0.9999990129F, 0.9999992003F, 0.9999993596F, 0.9999994939F,
+ 0.9999996059F, 0.9999996981F, 0.9999997732F, 0.9999998333F,
+ 0.9999998805F, 0.9999999170F, 0.9999999444F, 0.9999999643F,
+ 0.9999999784F, 0.9999999878F, 0.9999999937F, 0.9999999972F,
+ 0.9999999990F, 0.9999999997F, 1.0000000000F, 1.0000000000F,
+};
+
+static const float vwin4096[2048] = {
+ 0.0000002310F, 0.0000020791F, 0.0000057754F, 0.0000113197F,
+ 0.0000187121F, 0.0000279526F, 0.0000390412F, 0.0000519777F,
+ 0.0000667623F, 0.0000833949F, 0.0001018753F, 0.0001222036F,
+ 0.0001443798F, 0.0001684037F, 0.0001942754F, 0.0002219947F,
+ 0.0002515616F, 0.0002829761F, 0.0003162380F, 0.0003513472F,
+ 0.0003883038F, 0.0004271076F, 0.0004677584F, 0.0005102563F,
+ 0.0005546011F, 0.0006007928F, 0.0006488311F, 0.0006987160F,
+ 0.0007504474F, 0.0008040251F, 0.0008594490F, 0.0009167191F,
+ 0.0009758351F, 0.0010367969F, 0.0010996044F, 0.0011642574F,
+ 0.0012307558F, 0.0012990994F, 0.0013692880F, 0.0014413216F,
+ 0.0015151998F, 0.0015909226F, 0.0016684898F, 0.0017479011F,
+ 0.0018291565F, 0.0019122556F, 0.0019971983F, 0.0020839845F,
+ 0.0021726138F, 0.0022630861F, 0.0023554012F, 0.0024495588F,
+ 0.0025455588F, 0.0026434008F, 0.0027430847F, 0.0028446103F,
+ 0.0029479772F, 0.0030531853F, 0.0031602342F, 0.0032691238F,
+ 0.0033798538F, 0.0034924239F, 0.0036068338F, 0.0037230833F,
+ 0.0038411721F, 0.0039610999F, 0.0040828664F, 0.0042064714F,
+ 0.0043319145F, 0.0044591954F, 0.0045883139F, 0.0047192696F,
+ 0.0048520622F, 0.0049866914F, 0.0051231569F, 0.0052614583F,
+ 0.0054015953F, 0.0055435676F, 0.0056873748F, 0.0058330166F,
+ 0.0059804926F, 0.0061298026F, 0.0062809460F, 0.0064339226F,
+ 0.0065887320F, 0.0067453738F, 0.0069038476F, 0.0070641531F,
+ 0.0072262899F, 0.0073902575F, 0.0075560556F, 0.0077236838F,
+ 0.0078931417F, 0.0080644288F, 0.0082375447F, 0.0084124891F,
+ 0.0085892615F, 0.0087678614F, 0.0089482885F, 0.0091305422F,
+ 0.0093146223F, 0.0095005281F, 0.0096882592F, 0.0098778153F,
+ 0.0100691958F, 0.0102624002F, 0.0104574281F, 0.0106542791F,
+ 0.0108529525F, 0.0110534480F, 0.0112557651F, 0.0114599032F,
+ 0.0116658618F, 0.0118736405F, 0.0120832387F, 0.0122946560F,
+ 0.0125078917F, 0.0127229454F, 0.0129398166F, 0.0131585046F,
+ 0.0133790090F, 0.0136013292F, 0.0138254647F, 0.0140514149F,
+ 0.0142791792F, 0.0145087572F, 0.0147401481F, 0.0149733515F,
+ 0.0152083667F, 0.0154451932F, 0.0156838304F, 0.0159242777F,
+ 0.0161665345F, 0.0164106001F, 0.0166564741F, 0.0169041557F,
+ 0.0171536443F, 0.0174049393F, 0.0176580401F, 0.0179129461F,
+ 0.0181696565F, 0.0184281708F, 0.0186884883F, 0.0189506084F,
+ 0.0192145303F, 0.0194802535F, 0.0197477772F, 0.0200171008F,
+ 0.0202882236F, 0.0205611449F, 0.0208358639F, 0.0211123801F,
+ 0.0213906927F, 0.0216708011F, 0.0219527043F, 0.0222364019F,
+ 0.0225218930F, 0.0228091769F, 0.0230982529F, 0.0233891203F,
+ 0.0236817782F, 0.0239762259F, 0.0242724628F, 0.0245704880F,
+ 0.0248703007F, 0.0251719002F, 0.0254752858F, 0.0257804565F,
+ 0.0260874117F, 0.0263961506F, 0.0267066722F, 0.0270189760F,
+ 0.0273330609F, 0.0276489263F, 0.0279665712F, 0.0282859949F,
+ 0.0286071966F, 0.0289301753F, 0.0292549303F, 0.0295814607F,
+ 0.0299097656F, 0.0302398442F, 0.0305716957F, 0.0309053191F,
+ 0.0312407135F, 0.0315778782F, 0.0319168122F, 0.0322575145F,
+ 0.0325999844F, 0.0329442209F, 0.0332902231F, 0.0336379900F,
+ 0.0339875208F, 0.0343388146F, 0.0346918703F, 0.0350466871F,
+ 0.0354032640F, 0.0357616000F, 0.0361216943F, 0.0364835458F,
+ 0.0368471535F, 0.0372125166F, 0.0375796339F, 0.0379485046F,
+ 0.0383191276F, 0.0386915020F, 0.0390656267F, 0.0394415008F,
+ 0.0398191231F, 0.0401984927F, 0.0405796086F, 0.0409624698F,
+ 0.0413470751F, 0.0417334235F, 0.0421215141F, 0.0425113457F,
+ 0.0429029172F, 0.0432962277F, 0.0436912760F, 0.0440880610F,
+ 0.0444865817F, 0.0448868370F, 0.0452888257F, 0.0456925468F,
+ 0.0460979992F, 0.0465051816F, 0.0469140931F, 0.0473247325F,
+ 0.0477370986F, 0.0481511902F, 0.0485670064F, 0.0489845458F,
+ 0.0494038074F, 0.0498247899F, 0.0502474922F, 0.0506719131F,
+ 0.0510980514F, 0.0515259060F, 0.0519554756F, 0.0523867590F,
+ 0.0528197550F, 0.0532544624F, 0.0536908800F, 0.0541290066F,
+ 0.0545688408F, 0.0550103815F, 0.0554536274F, 0.0558985772F,
+ 0.0563452297F, 0.0567935837F, 0.0572436377F, 0.0576953907F,
+ 0.0581488412F, 0.0586039880F, 0.0590608297F, 0.0595193651F,
+ 0.0599795929F, 0.0604415117F, 0.0609051202F, 0.0613704170F,
+ 0.0618374009F, 0.0623060704F, 0.0627764243F, 0.0632484611F,
+ 0.0637221795F, 0.0641975781F, 0.0646746555F, 0.0651534104F,
+ 0.0656338413F, 0.0661159469F, 0.0665997257F, 0.0670851763F,
+ 0.0675722973F, 0.0680610873F, 0.0685515448F, 0.0690436684F,
+ 0.0695374567F, 0.0700329081F, 0.0705300213F, 0.0710287947F,
+ 0.0715292269F, 0.0720313163F, 0.0725350616F, 0.0730404612F,
+ 0.0735475136F, 0.0740562172F, 0.0745665707F, 0.0750785723F,
+ 0.0755922207F, 0.0761075143F, 0.0766244515F, 0.0771430307F,
+ 0.0776632505F, 0.0781851092F, 0.0787086052F, 0.0792337371F,
+ 0.0797605032F, 0.0802889018F, 0.0808189315F, 0.0813505905F,
+ 0.0818838773F, 0.0824187903F, 0.0829553277F, 0.0834934881F,
+ 0.0840332697F, 0.0845746708F, 0.0851176899F, 0.0856623252F,
+ 0.0862085751F, 0.0867564379F, 0.0873059119F, 0.0878569954F,
+ 0.0884096867F, 0.0889639840F, 0.0895198858F, 0.0900773902F,
+ 0.0906364955F, 0.0911972000F, 0.0917595019F, 0.0923233995F,
+ 0.0928888909F, 0.0934559745F, 0.0940246485F, 0.0945949110F,
+ 0.0951667604F, 0.0957401946F, 0.0963152121F, 0.0968918109F,
+ 0.0974699893F, 0.0980497454F, 0.0986310773F, 0.0992139832F,
+ 0.0997984614F, 0.1003845098F, 0.1009721267F, 0.1015613101F,
+ 0.1021520582F, 0.1027443692F, 0.1033382410F, 0.1039336718F,
+ 0.1045306597F, 0.1051292027F, 0.1057292990F, 0.1063309466F,
+ 0.1069341435F, 0.1075388878F, 0.1081451776F, 0.1087530108F,
+ 0.1093623856F, 0.1099732998F, 0.1105857516F, 0.1111997389F,
+ 0.1118152597F, 0.1124323121F, 0.1130508939F, 0.1136710032F,
+ 0.1142926379F, 0.1149157960F, 0.1155404755F, 0.1161666742F,
+ 0.1167943901F, 0.1174236211F, 0.1180543652F, 0.1186866202F,
+ 0.1193203841F, 0.1199556548F, 0.1205924300F, 0.1212307078F,
+ 0.1218704860F, 0.1225117624F, 0.1231545349F, 0.1237988013F,
+ 0.1244445596F, 0.1250918074F, 0.1257405427F, 0.1263907632F,
+ 0.1270424667F, 0.1276956512F, 0.1283503142F, 0.1290064537F,
+ 0.1296640674F, 0.1303231530F, 0.1309837084F, 0.1316457312F,
+ 0.1323092193F, 0.1329741703F, 0.1336405820F, 0.1343084520F,
+ 0.1349777782F, 0.1356485582F, 0.1363207897F, 0.1369944704F,
+ 0.1376695979F, 0.1383461700F, 0.1390241842F, 0.1397036384F,
+ 0.1403845300F, 0.1410668567F, 0.1417506162F, 0.1424358061F,
+ 0.1431224240F, 0.1438104674F, 0.1444999341F, 0.1451908216F,
+ 0.1458831274F, 0.1465768492F, 0.1472719844F, 0.1479685308F,
+ 0.1486664857F, 0.1493658468F, 0.1500666115F, 0.1507687775F,
+ 0.1514723422F, 0.1521773031F, 0.1528836577F, 0.1535914035F,
+ 0.1543005380F, 0.1550110587F, 0.1557229631F, 0.1564362485F,
+ 0.1571509124F, 0.1578669524F, 0.1585843657F, 0.1593031499F,
+ 0.1600233024F, 0.1607448205F, 0.1614677017F, 0.1621919433F,
+ 0.1629175428F, 0.1636444975F, 0.1643728047F, 0.1651024619F,
+ 0.1658334665F, 0.1665658156F, 0.1672995067F, 0.1680345371F,
+ 0.1687709041F, 0.1695086050F, 0.1702476372F, 0.1709879978F,
+ 0.1717296843F, 0.1724726938F, 0.1732170237F, 0.1739626711F,
+ 0.1747096335F, 0.1754579079F, 0.1762074916F, 0.1769583819F,
+ 0.1777105760F, 0.1784640710F, 0.1792188642F, 0.1799749529F,
+ 0.1807323340F, 0.1814910049F, 0.1822509628F, 0.1830122046F,
+ 0.1837747277F, 0.1845385292F, 0.1853036062F, 0.1860699558F,
+ 0.1868375751F, 0.1876064613F, 0.1883766114F, 0.1891480226F,
+ 0.1899206919F, 0.1906946164F, 0.1914697932F, 0.1922462194F,
+ 0.1930238919F, 0.1938028079F, 0.1945829643F, 0.1953643583F,
+ 0.1961469868F, 0.1969308468F, 0.1977159353F, 0.1985022494F,
+ 0.1992897859F, 0.2000785420F, 0.2008685145F, 0.2016597005F,
+ 0.2024520968F, 0.2032457005F, 0.2040405084F, 0.2048365175F,
+ 0.2056337247F, 0.2064321269F, 0.2072317211F, 0.2080325041F,
+ 0.2088344727F, 0.2096376240F, 0.2104419547F, 0.2112474618F,
+ 0.2120541420F, 0.2128619923F, 0.2136710094F, 0.2144811902F,
+ 0.2152925315F, 0.2161050301F, 0.2169186829F, 0.2177334866F,
+ 0.2185494381F, 0.2193665340F, 0.2201847712F, 0.2210041465F,
+ 0.2218246565F, 0.2226462981F, 0.2234690680F, 0.2242929629F,
+ 0.2251179796F, 0.2259441147F, 0.2267713650F, 0.2275997272F,
+ 0.2284291979F, 0.2292597739F, 0.2300914518F, 0.2309242283F,
+ 0.2317581001F, 0.2325930638F, 0.2334291160F, 0.2342662534F,
+ 0.2351044727F, 0.2359437703F, 0.2367841431F, 0.2376255875F,
+ 0.2384681001F, 0.2393116776F, 0.2401563165F, 0.2410020134F,
+ 0.2418487649F, 0.2426965675F, 0.2435454178F, 0.2443953122F,
+ 0.2452462474F, 0.2460982199F, 0.2469512262F, 0.2478052628F,
+ 0.2486603262F, 0.2495164129F, 0.2503735194F, 0.2512316421F,
+ 0.2520907776F, 0.2529509222F, 0.2538120726F, 0.2546742250F,
+ 0.2555373760F, 0.2564015219F, 0.2572666593F, 0.2581327845F,
+ 0.2589998939F, 0.2598679840F, 0.2607370510F, 0.2616070916F,
+ 0.2624781019F, 0.2633500783F, 0.2642230173F, 0.2650969152F,
+ 0.2659717684F, 0.2668475731F, 0.2677243257F, 0.2686020226F,
+ 0.2694806601F, 0.2703602344F, 0.2712407419F, 0.2721221789F,
+ 0.2730045417F, 0.2738878265F, 0.2747720297F, 0.2756571474F,
+ 0.2765431760F, 0.2774301117F, 0.2783179508F, 0.2792066895F,
+ 0.2800963240F, 0.2809868505F, 0.2818782654F, 0.2827705647F,
+ 0.2836637447F, 0.2845578016F, 0.2854527315F, 0.2863485307F,
+ 0.2872451953F, 0.2881427215F, 0.2890411055F, 0.2899403433F,
+ 0.2908404312F, 0.2917413654F, 0.2926431418F, 0.2935457567F,
+ 0.2944492061F, 0.2953534863F, 0.2962585932F, 0.2971645230F,
+ 0.2980712717F, 0.2989788356F, 0.2998872105F, 0.3007963927F,
+ 0.3017063781F, 0.3026171629F, 0.3035287430F, 0.3044411145F,
+ 0.3053542736F, 0.3062682161F, 0.3071829381F, 0.3080984356F,
+ 0.3090147047F, 0.3099317413F, 0.3108495414F, 0.3117681011F,
+ 0.3126874163F, 0.3136074830F, 0.3145282972F, 0.3154498548F,
+ 0.3163721517F, 0.3172951841F, 0.3182189477F, 0.3191434385F,
+ 0.3200686525F, 0.3209945856F, 0.3219212336F, 0.3228485927F,
+ 0.3237766585F, 0.3247054271F, 0.3256348943F, 0.3265650560F,
+ 0.3274959081F, 0.3284274465F, 0.3293596671F, 0.3302925657F,
+ 0.3312261382F, 0.3321603804F, 0.3330952882F, 0.3340308574F,
+ 0.3349670838F, 0.3359039634F, 0.3368414919F, 0.3377796651F,
+ 0.3387184789F, 0.3396579290F, 0.3405980113F, 0.3415387216F,
+ 0.3424800556F, 0.3434220091F, 0.3443645779F, 0.3453077578F,
+ 0.3462515446F, 0.3471959340F, 0.3481409217F, 0.3490865036F,
+ 0.3500326754F, 0.3509794328F, 0.3519267715F, 0.3528746873F,
+ 0.3538231759F, 0.3547722330F, 0.3557218544F, 0.3566720357F,
+ 0.3576227727F, 0.3585740610F, 0.3595258964F, 0.3604782745F,
+ 0.3614311910F, 0.3623846417F, 0.3633386221F, 0.3642931280F,
+ 0.3652481549F, 0.3662036987F, 0.3671597548F, 0.3681163191F,
+ 0.3690733870F, 0.3700309544F, 0.3709890167F, 0.3719475696F,
+ 0.3729066089F, 0.3738661299F, 0.3748261285F, 0.3757866002F,
+ 0.3767475406F, 0.3777089453F, 0.3786708100F, 0.3796331302F,
+ 0.3805959014F, 0.3815591194F, 0.3825227796F, 0.3834868777F,
+ 0.3844514093F, 0.3854163698F, 0.3863817549F, 0.3873475601F,
+ 0.3883137810F, 0.3892804131F, 0.3902474521F, 0.3912148933F,
+ 0.3921827325F, 0.3931509650F, 0.3941195865F, 0.3950885925F,
+ 0.3960579785F, 0.3970277400F, 0.3979978725F, 0.3989683716F,
+ 0.3999392328F, 0.4009104516F, 0.4018820234F, 0.4028539438F,
+ 0.4038262084F, 0.4047988125F, 0.4057717516F, 0.4067450214F,
+ 0.4077186172F, 0.4086925345F, 0.4096667688F, 0.4106413155F,
+ 0.4116161703F, 0.4125913284F, 0.4135667854F, 0.4145425368F,
+ 0.4155185780F, 0.4164949044F, 0.4174715116F, 0.4184483949F,
+ 0.4194255498F, 0.4204029718F, 0.4213806563F, 0.4223585987F,
+ 0.4233367946F, 0.4243152392F, 0.4252939281F, 0.4262728566F,
+ 0.4272520202F, 0.4282314144F, 0.4292110345F, 0.4301908760F,
+ 0.4311709343F, 0.4321512047F, 0.4331316828F, 0.4341123639F,
+ 0.4350932435F, 0.4360743168F, 0.4370555794F, 0.4380370267F,
+ 0.4390186540F, 0.4400004567F, 0.4409824303F, 0.4419645701F,
+ 0.4429468716F, 0.4439293300F, 0.4449119409F, 0.4458946996F,
+ 0.4468776014F, 0.4478606418F, 0.4488438162F, 0.4498271199F,
+ 0.4508105483F, 0.4517940967F, 0.4527777607F, 0.4537615355F,
+ 0.4547454165F, 0.4557293991F, 0.4567134786F, 0.4576976505F,
+ 0.4586819101F, 0.4596662527F, 0.4606506738F, 0.4616351687F,
+ 0.4626197328F, 0.4636043614F, 0.4645890499F, 0.4655737936F,
+ 0.4665585880F, 0.4675434284F, 0.4685283101F, 0.4695132286F,
+ 0.4704981791F, 0.4714831570F, 0.4724681577F, 0.4734531766F,
+ 0.4744382089F, 0.4754232501F, 0.4764082956F, 0.4773933406F,
+ 0.4783783806F, 0.4793634108F, 0.4803484267F, 0.4813334237F,
+ 0.4823183969F, 0.4833033419F, 0.4842882540F, 0.4852731285F,
+ 0.4862579608F, 0.4872427462F, 0.4882274802F, 0.4892121580F,
+ 0.4901967751F, 0.4911813267F, 0.4921658083F, 0.4931502151F,
+ 0.4941345427F, 0.4951187863F, 0.4961029412F, 0.4970870029F,
+ 0.4980709667F, 0.4990548280F, 0.5000385822F, 0.5010222245F,
+ 0.5020057505F, 0.5029891553F, 0.5039724345F, 0.5049555834F,
+ 0.5059385973F, 0.5069214716F, 0.5079042018F, 0.5088867831F,
+ 0.5098692110F, 0.5108514808F, 0.5118335879F, 0.5128155277F,
+ 0.5137972956F, 0.5147788869F, 0.5157602971F, 0.5167415215F,
+ 0.5177225555F, 0.5187033945F, 0.5196840339F, 0.5206644692F,
+ 0.5216446956F, 0.5226247086F, 0.5236045035F, 0.5245840759F,
+ 0.5255634211F, 0.5265425344F, 0.5275214114F, 0.5285000474F,
+ 0.5294784378F, 0.5304565781F, 0.5314344637F, 0.5324120899F,
+ 0.5333894522F, 0.5343665461F, 0.5353433670F, 0.5363199102F,
+ 0.5372961713F, 0.5382721457F, 0.5392478287F, 0.5402232159F,
+ 0.5411983027F, 0.5421730845F, 0.5431475569F, 0.5441217151F,
+ 0.5450955548F, 0.5460690714F, 0.5470422602F, 0.5480151169F,
+ 0.5489876368F, 0.5499598155F, 0.5509316484F, 0.5519031310F,
+ 0.5528742587F, 0.5538450271F, 0.5548154317F, 0.5557854680F,
+ 0.5567551314F, 0.5577244174F, 0.5586933216F, 0.5596618395F,
+ 0.5606299665F, 0.5615976983F, 0.5625650302F, 0.5635319580F,
+ 0.5644984770F, 0.5654645828F, 0.5664302709F, 0.5673955370F,
+ 0.5683603765F, 0.5693247850F, 0.5702887580F, 0.5712522912F,
+ 0.5722153800F, 0.5731780200F, 0.5741402069F, 0.5751019362F,
+ 0.5760632034F, 0.5770240042F, 0.5779843341F, 0.5789441889F,
+ 0.5799035639F, 0.5808624549F, 0.5818208575F, 0.5827787673F,
+ 0.5837361800F, 0.5846930910F, 0.5856494961F, 0.5866053910F,
+ 0.5875607712F, 0.5885156324F, 0.5894699703F, 0.5904237804F,
+ 0.5913770586F, 0.5923298004F, 0.5932820016F, 0.5942336578F,
+ 0.5951847646F, 0.5961353179F, 0.5970853132F, 0.5980347464F,
+ 0.5989836131F, 0.5999319090F, 0.6008796298F, 0.6018267713F,
+ 0.6027733292F, 0.6037192993F, 0.6046646773F, 0.6056094589F,
+ 0.6065536400F, 0.6074972162F, 0.6084401833F, 0.6093825372F,
+ 0.6103242736F, 0.6112653884F, 0.6122058772F, 0.6131457359F,
+ 0.6140849604F, 0.6150235464F, 0.6159614897F, 0.6168987862F,
+ 0.6178354318F, 0.6187714223F, 0.6197067535F, 0.6206414213F,
+ 0.6215754215F, 0.6225087501F, 0.6234414028F, 0.6243733757F,
+ 0.6253046646F, 0.6262352654F, 0.6271651739F, 0.6280943862F,
+ 0.6290228982F, 0.6299507057F, 0.6308778048F, 0.6318041913F,
+ 0.6327298612F, 0.6336548105F, 0.6345790352F, 0.6355025312F,
+ 0.6364252945F, 0.6373473211F, 0.6382686070F, 0.6391891483F,
+ 0.6401089409F, 0.6410279808F, 0.6419462642F, 0.6428637869F,
+ 0.6437805452F, 0.6446965350F, 0.6456117524F, 0.6465261935F,
+ 0.6474398544F, 0.6483527311F, 0.6492648197F, 0.6501761165F,
+ 0.6510866174F, 0.6519963186F, 0.6529052162F, 0.6538133064F,
+ 0.6547205854F, 0.6556270492F, 0.6565326941F, 0.6574375162F,
+ 0.6583415117F, 0.6592446769F, 0.6601470079F, 0.6610485009F,
+ 0.6619491521F, 0.6628489578F, 0.6637479143F, 0.6646460177F,
+ 0.6655432643F, 0.6664396505F, 0.6673351724F, 0.6682298264F,
+ 0.6691236087F, 0.6700165157F, 0.6709085436F, 0.6717996889F,
+ 0.6726899478F, 0.6735793167F, 0.6744677918F, 0.6753553697F,
+ 0.6762420466F, 0.6771278190F, 0.6780126832F, 0.6788966357F,
+ 0.6797796728F, 0.6806617909F, 0.6815429866F, 0.6824232562F,
+ 0.6833025961F, 0.6841810030F, 0.6850584731F, 0.6859350031F,
+ 0.6868105894F, 0.6876852284F, 0.6885589168F, 0.6894316510F,
+ 0.6903034275F, 0.6911742430F, 0.6920440939F, 0.6929129769F,
+ 0.6937808884F, 0.6946478251F, 0.6955137837F, 0.6963787606F,
+ 0.6972427525F, 0.6981057560F, 0.6989677678F, 0.6998287845F,
+ 0.7006888028F, 0.7015478194F, 0.7024058309F, 0.7032628340F,
+ 0.7041188254F, 0.7049738019F, 0.7058277601F, 0.7066806969F,
+ 0.7075326089F, 0.7083834929F, 0.7092333457F, 0.7100821640F,
+ 0.7109299447F, 0.7117766846F, 0.7126223804F, 0.7134670291F,
+ 0.7143106273F, 0.7151531721F, 0.7159946602F, 0.7168350885F,
+ 0.7176744539F, 0.7185127534F, 0.7193499837F, 0.7201861418F,
+ 0.7210212247F, 0.7218552293F, 0.7226881526F, 0.7235199914F,
+ 0.7243507428F, 0.7251804039F, 0.7260089715F, 0.7268364426F,
+ 0.7276628144F, 0.7284880839F, 0.7293122481F, 0.7301353040F,
+ 0.7309572487F, 0.7317780794F, 0.7325977930F, 0.7334163868F,
+ 0.7342338579F, 0.7350502033F, 0.7358654202F, 0.7366795059F,
+ 0.7374924573F, 0.7383042718F, 0.7391149465F, 0.7399244787F,
+ 0.7407328655F, 0.7415401041F, 0.7423461920F, 0.7431511261F,
+ 0.7439549040F, 0.7447575227F, 0.7455589797F, 0.7463592723F,
+ 0.7471583976F, 0.7479563532F, 0.7487531363F, 0.7495487443F,
+ 0.7503431745F, 0.7511364244F, 0.7519284913F, 0.7527193726F,
+ 0.7535090658F, 0.7542975683F, 0.7550848776F, 0.7558709910F,
+ 0.7566559062F, 0.7574396205F, 0.7582221314F, 0.7590034366F,
+ 0.7597835334F, 0.7605624194F, 0.7613400923F, 0.7621165495F,
+ 0.7628917886F, 0.7636658072F, 0.7644386030F, 0.7652101735F,
+ 0.7659805164F, 0.7667496292F, 0.7675175098F, 0.7682841556F,
+ 0.7690495645F, 0.7698137341F, 0.7705766622F, 0.7713383463F,
+ 0.7720987844F, 0.7728579741F, 0.7736159132F, 0.7743725994F,
+ 0.7751280306F, 0.7758822046F, 0.7766351192F, 0.7773867722F,
+ 0.7781371614F, 0.7788862848F, 0.7796341401F, 0.7803807253F,
+ 0.7811260383F, 0.7818700769F, 0.7826128392F, 0.7833543230F,
+ 0.7840945263F, 0.7848334471F, 0.7855710833F, 0.7863074330F,
+ 0.7870424941F, 0.7877762647F, 0.7885087428F, 0.7892399264F,
+ 0.7899698137F, 0.7906984026F, 0.7914256914F, 0.7921516780F,
+ 0.7928763607F, 0.7935997375F, 0.7943218065F, 0.7950425661F,
+ 0.7957620142F, 0.7964801492F, 0.7971969692F, 0.7979124724F,
+ 0.7986266570F, 0.7993395214F, 0.8000510638F, 0.8007612823F,
+ 0.8014701754F, 0.8021777413F, 0.8028839784F, 0.8035888849F,
+ 0.8042924592F, 0.8049946997F, 0.8056956048F, 0.8063951727F,
+ 0.8070934020F, 0.8077902910F, 0.8084858381F, 0.8091800419F,
+ 0.8098729007F, 0.8105644130F, 0.8112545774F, 0.8119433922F,
+ 0.8126308561F, 0.8133169676F, 0.8140017251F, 0.8146851272F,
+ 0.8153671726F, 0.8160478598F, 0.8167271874F, 0.8174051539F,
+ 0.8180817582F, 0.8187569986F, 0.8194308741F, 0.8201033831F,
+ 0.8207745244F, 0.8214442966F, 0.8221126986F, 0.8227797290F,
+ 0.8234453865F, 0.8241096700F, 0.8247725781F, 0.8254341097F,
+ 0.8260942636F, 0.8267530385F, 0.8274104334F, 0.8280664470F,
+ 0.8287210782F, 0.8293743259F, 0.8300261889F, 0.8306766662F,
+ 0.8313257566F, 0.8319734591F, 0.8326197727F, 0.8332646963F,
+ 0.8339082288F, 0.8345503692F, 0.8351911167F, 0.8358304700F,
+ 0.8364684284F, 0.8371049907F, 0.8377401562F, 0.8383739238F,
+ 0.8390062927F, 0.8396372618F, 0.8402668305F, 0.8408949977F,
+ 0.8415217626F, 0.8421471245F, 0.8427710823F, 0.8433936354F,
+ 0.8440147830F, 0.8446345242F, 0.8452528582F, 0.8458697844F,
+ 0.8464853020F, 0.8470994102F, 0.8477121084F, 0.8483233958F,
+ 0.8489332718F, 0.8495417356F, 0.8501487866F, 0.8507544243F,
+ 0.8513586479F, 0.8519614568F, 0.8525628505F, 0.8531628283F,
+ 0.8537613897F, 0.8543585341F, 0.8549542611F, 0.8555485699F,
+ 0.8561414603F, 0.8567329315F, 0.8573229832F, 0.8579116149F,
+ 0.8584988262F, 0.8590846165F, 0.8596689855F, 0.8602519327F,
+ 0.8608334577F, 0.8614135603F, 0.8619922399F, 0.8625694962F,
+ 0.8631453289F, 0.8637197377F, 0.8642927222F, 0.8648642821F,
+ 0.8654344172F, 0.8660031272F, 0.8665704118F, 0.8671362708F,
+ 0.8677007039F, 0.8682637109F, 0.8688252917F, 0.8693854460F,
+ 0.8699441737F, 0.8705014745F, 0.8710573485F, 0.8716117953F,
+ 0.8721648150F, 0.8727164073F, 0.8732665723F, 0.8738153098F,
+ 0.8743626197F, 0.8749085021F, 0.8754529569F, 0.8759959840F,
+ 0.8765375835F, 0.8770777553F, 0.8776164996F, 0.8781538162F,
+ 0.8786897054F, 0.8792241670F, 0.8797572013F, 0.8802888082F,
+ 0.8808189880F, 0.8813477407F, 0.8818750664F, 0.8824009653F,
+ 0.8829254375F, 0.8834484833F, 0.8839701028F, 0.8844902961F,
+ 0.8850090636F, 0.8855264054F, 0.8860423218F, 0.8865568131F,
+ 0.8870698794F, 0.8875815212F, 0.8880917386F, 0.8886005319F,
+ 0.8891079016F, 0.8896138479F, 0.8901183712F, 0.8906214719F,
+ 0.8911231503F, 0.8916234067F, 0.8921222417F, 0.8926196556F,
+ 0.8931156489F, 0.8936102219F, 0.8941033752F, 0.8945951092F,
+ 0.8950854244F, 0.8955743212F, 0.8960618003F, 0.8965478621F,
+ 0.8970325071F, 0.8975157359F, 0.8979975490F, 0.8984779471F,
+ 0.8989569307F, 0.8994345004F, 0.8999106568F, 0.9003854005F,
+ 0.9008587323F, 0.9013306526F, 0.9018011623F, 0.9022702619F,
+ 0.9027379521F, 0.9032042337F, 0.9036691074F, 0.9041325739F,
+ 0.9045946339F, 0.9050552882F, 0.9055145376F, 0.9059723828F,
+ 0.9064288246F, 0.9068838638F, 0.9073375013F, 0.9077897379F,
+ 0.9082405743F, 0.9086900115F, 0.9091380503F, 0.9095846917F,
+ 0.9100299364F, 0.9104737854F, 0.9109162397F, 0.9113573001F,
+ 0.9117969675F, 0.9122352430F, 0.9126721275F, 0.9131076219F,
+ 0.9135417273F, 0.9139744447F, 0.9144057750F, 0.9148357194F,
+ 0.9152642787F, 0.9156914542F, 0.9161172468F, 0.9165416576F,
+ 0.9169646877F, 0.9173863382F, 0.9178066102F, 0.9182255048F,
+ 0.9186430232F, 0.9190591665F, 0.9194739359F, 0.9198873324F,
+ 0.9202993574F, 0.9207100120F, 0.9211192973F, 0.9215272147F,
+ 0.9219337653F, 0.9223389504F, 0.9227427713F, 0.9231452290F,
+ 0.9235463251F, 0.9239460607F, 0.9243444371F, 0.9247414557F,
+ 0.9251371177F, 0.9255314245F, 0.9259243774F, 0.9263159778F,
+ 0.9267062270F, 0.9270951264F, 0.9274826774F, 0.9278688814F,
+ 0.9282537398F, 0.9286372540F, 0.9290194254F, 0.9294002555F,
+ 0.9297797458F, 0.9301578976F, 0.9305347125F, 0.9309101919F,
+ 0.9312843373F, 0.9316571503F, 0.9320286323F, 0.9323987849F,
+ 0.9327676097F, 0.9331351080F, 0.9335012816F, 0.9338661320F,
+ 0.9342296607F, 0.9345918694F, 0.9349527596F, 0.9353123330F,
+ 0.9356705911F, 0.9360275357F, 0.9363831683F, 0.9367374905F,
+ 0.9370905042F, 0.9374422108F, 0.9377926122F, 0.9381417099F,
+ 0.9384895057F, 0.9388360014F, 0.9391811985F, 0.9395250989F,
+ 0.9398677043F, 0.9402090165F, 0.9405490371F, 0.9408877680F,
+ 0.9412252110F, 0.9415613678F, 0.9418962402F, 0.9422298301F,
+ 0.9425621392F, 0.9428931695F, 0.9432229226F, 0.9435514005F,
+ 0.9438786050F, 0.9442045381F, 0.9445292014F, 0.9448525971F,
+ 0.9451747268F, 0.9454955926F, 0.9458151963F, 0.9461335399F,
+ 0.9464506253F, 0.9467664545F, 0.9470810293F, 0.9473943517F,
+ 0.9477064238F, 0.9480172474F, 0.9483268246F, 0.9486351573F,
+ 0.9489422475F, 0.9492480973F, 0.9495527087F, 0.9498560837F,
+ 0.9501582243F, 0.9504591325F, 0.9507588105F, 0.9510572603F,
+ 0.9513544839F, 0.9516504834F, 0.9519452609F, 0.9522388186F,
+ 0.9525311584F, 0.9528222826F, 0.9531121932F, 0.9534008923F,
+ 0.9536883821F, 0.9539746647F, 0.9542597424F, 0.9545436171F,
+ 0.9548262912F, 0.9551077667F, 0.9553880459F, 0.9556671309F,
+ 0.9559450239F, 0.9562217272F, 0.9564972429F, 0.9567715733F,
+ 0.9570447206F, 0.9573166871F, 0.9575874749F, 0.9578570863F,
+ 0.9581255236F, 0.9583927890F, 0.9586588849F, 0.9589238134F,
+ 0.9591875769F, 0.9594501777F, 0.9597116180F, 0.9599719003F,
+ 0.9602310267F, 0.9604889995F, 0.9607458213F, 0.9610014942F,
+ 0.9612560206F, 0.9615094028F, 0.9617616433F, 0.9620127443F,
+ 0.9622627083F, 0.9625115376F, 0.9627592345F, 0.9630058016F,
+ 0.9632512411F, 0.9634955555F, 0.9637387471F, 0.9639808185F,
+ 0.9642217720F, 0.9644616100F, 0.9647003349F, 0.9649379493F,
+ 0.9651744556F, 0.9654098561F, 0.9656441534F, 0.9658773499F,
+ 0.9661094480F, 0.9663404504F, 0.9665703593F, 0.9667991774F,
+ 0.9670269071F, 0.9672535509F, 0.9674791114F, 0.9677035909F,
+ 0.9679269921F, 0.9681493174F, 0.9683705694F, 0.9685907506F,
+ 0.9688098636F, 0.9690279108F, 0.9692448948F, 0.9694608182F,
+ 0.9696756836F, 0.9698894934F, 0.9701022503F, 0.9703139569F,
+ 0.9705246156F, 0.9707342291F, 0.9709428000F, 0.9711503309F,
+ 0.9713568243F, 0.9715622829F, 0.9717667093F, 0.9719701060F,
+ 0.9721724757F, 0.9723738210F, 0.9725741446F, 0.9727734490F,
+ 0.9729717369F, 0.9731690109F, 0.9733652737F, 0.9735605279F,
+ 0.9737547762F, 0.9739480212F, 0.9741402656F, 0.9743315120F,
+ 0.9745217631F, 0.9747110216F, 0.9748992901F, 0.9750865714F,
+ 0.9752728681F, 0.9754581829F, 0.9756425184F, 0.9758258775F,
+ 0.9760082627F, 0.9761896768F, 0.9763701224F, 0.9765496024F,
+ 0.9767281193F, 0.9769056760F, 0.9770822751F, 0.9772579193F,
+ 0.9774326114F, 0.9776063542F, 0.9777791502F, 0.9779510023F,
+ 0.9781219133F, 0.9782918858F, 0.9784609226F, 0.9786290264F,
+ 0.9787962000F, 0.9789624461F, 0.9791277676F, 0.9792921671F,
+ 0.9794556474F, 0.9796182113F, 0.9797798615F, 0.9799406009F,
+ 0.9801004321F, 0.9802593580F, 0.9804173813F, 0.9805745049F,
+ 0.9807307314F, 0.9808860637F, 0.9810405046F, 0.9811940568F,
+ 0.9813467232F, 0.9814985065F, 0.9816494095F, 0.9817994351F,
+ 0.9819485860F, 0.9820968650F, 0.9822442750F, 0.9823908186F,
+ 0.9825364988F, 0.9826813184F, 0.9828252801F, 0.9829683868F,
+ 0.9831106413F, 0.9832520463F, 0.9833926048F, 0.9835323195F,
+ 0.9836711932F, 0.9838092288F, 0.9839464291F, 0.9840827969F,
+ 0.9842183351F, 0.9843530464F, 0.9844869337F, 0.9846199998F,
+ 0.9847522475F, 0.9848836798F, 0.9850142993F, 0.9851441090F,
+ 0.9852731117F, 0.9854013101F, 0.9855287073F, 0.9856553058F,
+ 0.9857811087F, 0.9859061188F, 0.9860303388F, 0.9861537717F,
+ 0.9862764202F, 0.9863982872F, 0.9865193756F, 0.9866396882F,
+ 0.9867592277F, 0.9868779972F, 0.9869959993F, 0.9871132370F,
+ 0.9872297131F, 0.9873454304F, 0.9874603918F, 0.9875746001F,
+ 0.9876880581F, 0.9878007688F, 0.9879127348F, 0.9880239592F,
+ 0.9881344447F, 0.9882441941F, 0.9883532104F, 0.9884614962F,
+ 0.9885690546F, 0.9886758883F, 0.9887820001F, 0.9888873930F,
+ 0.9889920697F, 0.9890960331F, 0.9891992859F, 0.9893018312F,
+ 0.9894036716F, 0.9895048100F, 0.9896052493F, 0.9897049923F,
+ 0.9898040418F, 0.9899024006F, 0.9900000717F, 0.9900970577F,
+ 0.9901933616F, 0.9902889862F, 0.9903839343F, 0.9904782087F,
+ 0.9905718122F, 0.9906647477F, 0.9907570180F, 0.9908486259F,
+ 0.9909395742F, 0.9910298658F, 0.9911195034F, 0.9912084899F,
+ 0.9912968281F, 0.9913845208F, 0.9914715708F, 0.9915579810F,
+ 0.9916437540F, 0.9917288928F, 0.9918134001F, 0.9918972788F,
+ 0.9919805316F, 0.9920631613F, 0.9921451707F, 0.9922265626F,
+ 0.9923073399F, 0.9923875052F, 0.9924670615F, 0.9925460114F,
+ 0.9926243577F, 0.9927021033F, 0.9927792508F, 0.9928558032F,
+ 0.9929317631F, 0.9930071333F, 0.9930819167F, 0.9931561158F,
+ 0.9932297337F, 0.9933027728F, 0.9933752362F, 0.9934471264F,
+ 0.9935184462F, 0.9935891985F, 0.9936593859F, 0.9937290112F,
+ 0.9937980771F, 0.9938665864F, 0.9939345418F, 0.9940019460F,
+ 0.9940688018F, 0.9941351118F, 0.9942008789F, 0.9942661057F,
+ 0.9943307950F, 0.9943949494F, 0.9944585717F, 0.9945216645F,
+ 0.9945842307F, 0.9946462728F, 0.9947077936F, 0.9947687957F,
+ 0.9948292820F, 0.9948892550F, 0.9949487174F, 0.9950076719F,
+ 0.9950661212F, 0.9951240679F, 0.9951815148F, 0.9952384645F,
+ 0.9952949196F, 0.9953508828F, 0.9954063568F, 0.9954613442F,
+ 0.9955158476F, 0.9955698697F, 0.9956234132F, 0.9956764806F,
+ 0.9957290746F, 0.9957811978F, 0.9958328528F, 0.9958840423F,
+ 0.9959347688F, 0.9959850351F, 0.9960348435F, 0.9960841969F,
+ 0.9961330977F, 0.9961815486F, 0.9962295521F, 0.9962771108F,
+ 0.9963242274F, 0.9963709043F, 0.9964171441F, 0.9964629494F,
+ 0.9965083228F, 0.9965532668F, 0.9965977840F, 0.9966418768F,
+ 0.9966855479F, 0.9967287998F, 0.9967716350F, 0.9968140559F,
+ 0.9968560653F, 0.9968976655F, 0.9969388591F, 0.9969796485F,
+ 0.9970200363F, 0.9970600250F, 0.9970996170F, 0.9971388149F,
+ 0.9971776211F, 0.9972160380F, 0.9972540683F, 0.9972917142F,
+ 0.9973289783F, 0.9973658631F, 0.9974023709F, 0.9974385042F,
+ 0.9974742655F, 0.9975096571F, 0.9975446816F, 0.9975793413F,
+ 0.9976136386F, 0.9976475759F, 0.9976811557F, 0.9977143803F,
+ 0.9977472521F, 0.9977797736F, 0.9978119470F, 0.9978437748F,
+ 0.9978752593F, 0.9979064029F, 0.9979372079F, 0.9979676768F,
+ 0.9979978117F, 0.9980276151F, 0.9980570893F, 0.9980862367F,
+ 0.9981150595F, 0.9981435600F, 0.9981717406F, 0.9981996035F,
+ 0.9982271511F, 0.9982543856F, 0.9982813093F, 0.9983079246F,
+ 0.9983342336F, 0.9983602386F, 0.9983859418F, 0.9984113456F,
+ 0.9984364522F, 0.9984612638F, 0.9984857825F, 0.9985100108F,
+ 0.9985339507F, 0.9985576044F, 0.9985809743F, 0.9986040624F,
+ 0.9986268710F, 0.9986494022F, 0.9986716583F, 0.9986936413F,
+ 0.9987153535F, 0.9987367969F, 0.9987579738F, 0.9987788864F,
+ 0.9987995366F, 0.9988199267F, 0.9988400587F, 0.9988599348F,
+ 0.9988795572F, 0.9988989278F, 0.9989180487F, 0.9989369222F,
+ 0.9989555501F, 0.9989739347F, 0.9989920780F, 0.9990099820F,
+ 0.9990276487F, 0.9990450803F, 0.9990622787F, 0.9990792460F,
+ 0.9990959841F, 0.9991124952F, 0.9991287812F, 0.9991448440F,
+ 0.9991606858F, 0.9991763084F, 0.9991917139F, 0.9992069042F,
+ 0.9992218813F, 0.9992366471F, 0.9992512035F, 0.9992655525F,
+ 0.9992796961F, 0.9992936361F, 0.9993073744F, 0.9993209131F,
+ 0.9993342538F, 0.9993473987F, 0.9993603494F, 0.9993731080F,
+ 0.9993856762F, 0.9993980559F, 0.9994102490F, 0.9994222573F,
+ 0.9994340827F, 0.9994457269F, 0.9994571918F, 0.9994684793F,
+ 0.9994795910F, 0.9994905288F, 0.9995012945F, 0.9995118898F,
+ 0.9995223165F, 0.9995325765F, 0.9995426713F, 0.9995526029F,
+ 0.9995623728F, 0.9995719829F, 0.9995814349F, 0.9995907304F,
+ 0.9995998712F, 0.9996088590F, 0.9996176954F, 0.9996263821F,
+ 0.9996349208F, 0.9996433132F, 0.9996515609F, 0.9996596656F,
+ 0.9996676288F, 0.9996754522F, 0.9996831375F, 0.9996906862F,
+ 0.9996981000F, 0.9997053804F, 0.9997125290F, 0.9997195474F,
+ 0.9997264371F, 0.9997331998F, 0.9997398369F, 0.9997463500F,
+ 0.9997527406F, 0.9997590103F, 0.9997651606F, 0.9997711930F,
+ 0.9997771089F, 0.9997829098F, 0.9997885973F, 0.9997941728F,
+ 0.9997996378F, 0.9998049936F, 0.9998102419F, 0.9998153839F,
+ 0.9998204211F, 0.9998253550F, 0.9998301868F, 0.9998349182F,
+ 0.9998395503F, 0.9998440847F, 0.9998485226F, 0.9998528654F,
+ 0.9998571146F, 0.9998612713F, 0.9998653370F, 0.9998693130F,
+ 0.9998732007F, 0.9998770012F, 0.9998807159F, 0.9998843461F,
+ 0.9998878931F, 0.9998913581F, 0.9998947424F, 0.9998980473F,
+ 0.9999012740F, 0.9999044237F, 0.9999074976F, 0.9999104971F,
+ 0.9999134231F, 0.9999162771F, 0.9999190601F, 0.9999217733F,
+ 0.9999244179F, 0.9999269950F, 0.9999295058F, 0.9999319515F,
+ 0.9999343332F, 0.9999366519F, 0.9999389088F, 0.9999411050F,
+ 0.9999432416F, 0.9999453196F, 0.9999473402F, 0.9999493044F,
+ 0.9999512132F, 0.9999530677F, 0.9999548690F, 0.9999566180F,
+ 0.9999583157F, 0.9999599633F, 0.9999615616F, 0.9999631116F,
+ 0.9999646144F, 0.9999660709F, 0.9999674820F, 0.9999688487F,
+ 0.9999701719F, 0.9999714526F, 0.9999726917F, 0.9999738900F,
+ 0.9999750486F, 0.9999761682F, 0.9999772497F, 0.9999782941F,
+ 0.9999793021F, 0.9999802747F, 0.9999812126F, 0.9999821167F,
+ 0.9999829878F, 0.9999838268F, 0.9999846343F, 0.9999854113F,
+ 0.9999861584F, 0.9999868765F, 0.9999875664F, 0.9999882287F,
+ 0.9999888642F, 0.9999894736F, 0.9999900577F, 0.9999906172F,
+ 0.9999911528F, 0.9999916651F, 0.9999921548F, 0.9999926227F,
+ 0.9999930693F, 0.9999934954F, 0.9999939015F, 0.9999942883F,
+ 0.9999946564F, 0.9999950064F, 0.9999953390F, 0.9999956547F,
+ 0.9999959541F, 0.9999962377F, 0.9999965062F, 0.9999967601F,
+ 0.9999969998F, 0.9999972260F, 0.9999974392F, 0.9999976399F,
+ 0.9999978285F, 0.9999980056F, 0.9999981716F, 0.9999983271F,
+ 0.9999984724F, 0.9999986081F, 0.9999987345F, 0.9999988521F,
+ 0.9999989613F, 0.9999990625F, 0.9999991562F, 0.9999992426F,
+ 0.9999993223F, 0.9999993954F, 0.9999994625F, 0.9999995239F,
+ 0.9999995798F, 0.9999996307F, 0.9999996768F, 0.9999997184F,
+ 0.9999997559F, 0.9999997895F, 0.9999998195F, 0.9999998462F,
+ 0.9999998698F, 0.9999998906F, 0.9999999088F, 0.9999999246F,
+ 0.9999999383F, 0.9999999500F, 0.9999999600F, 0.9999999684F,
+ 0.9999999754F, 0.9999999811F, 0.9999999858F, 0.9999999896F,
+ 0.9999999925F, 0.9999999948F, 0.9999999965F, 0.9999999978F,
+ 0.9999999986F, 0.9999999992F, 0.9999999996F, 0.9999999998F,
+ 0.9999999999F, 1.0000000000F, 1.0000000000F, 1.0000000000F,
+};
+
+static const float vwin8192[4096] = {
+ 0.0000000578F, 0.0000005198F, 0.0000014438F, 0.0000028299F,
+ 0.0000046780F, 0.0000069882F, 0.0000097604F, 0.0000129945F,
+ 0.0000166908F, 0.0000208490F, 0.0000254692F, 0.0000305515F,
+ 0.0000360958F, 0.0000421021F, 0.0000485704F, 0.0000555006F,
+ 0.0000628929F, 0.0000707472F, 0.0000790635F, 0.0000878417F,
+ 0.0000970820F, 0.0001067842F, 0.0001169483F, 0.0001275744F,
+ 0.0001386625F, 0.0001502126F, 0.0001622245F, 0.0001746984F,
+ 0.0001876343F, 0.0002010320F, 0.0002148917F, 0.0002292132F,
+ 0.0002439967F, 0.0002592421F, 0.0002749493F, 0.0002911184F,
+ 0.0003077493F, 0.0003248421F, 0.0003423967F, 0.0003604132F,
+ 0.0003788915F, 0.0003978316F, 0.0004172335F, 0.0004370971F,
+ 0.0004574226F, 0.0004782098F, 0.0004994587F, 0.0005211694F,
+ 0.0005433418F, 0.0005659759F, 0.0005890717F, 0.0006126292F,
+ 0.0006366484F, 0.0006611292F, 0.0006860716F, 0.0007114757F,
+ 0.0007373414F, 0.0007636687F, 0.0007904576F, 0.0008177080F,
+ 0.0008454200F, 0.0008735935F, 0.0009022285F, 0.0009313250F,
+ 0.0009608830F, 0.0009909025F, 0.0010213834F, 0.0010523257F,
+ 0.0010837295F, 0.0011155946F, 0.0011479211F, 0.0011807090F,
+ 0.0012139582F, 0.0012476687F, 0.0012818405F, 0.0013164736F,
+ 0.0013515679F, 0.0013871235F, 0.0014231402F, 0.0014596182F,
+ 0.0014965573F, 0.0015339576F, 0.0015718190F, 0.0016101415F,
+ 0.0016489251F, 0.0016881698F, 0.0017278754F, 0.0017680421F,
+ 0.0018086698F, 0.0018497584F, 0.0018913080F, 0.0019333185F,
+ 0.0019757898F, 0.0020187221F, 0.0020621151F, 0.0021059690F,
+ 0.0021502837F, 0.0021950591F, 0.0022402953F, 0.0022859921F,
+ 0.0023321497F, 0.0023787679F, 0.0024258467F, 0.0024733861F,
+ 0.0025213861F, 0.0025698466F, 0.0026187676F, 0.0026681491F,
+ 0.0027179911F, 0.0027682935F, 0.0028190562F, 0.0028702794F,
+ 0.0029219628F, 0.0029741066F, 0.0030267107F, 0.0030797749F,
+ 0.0031332994F, 0.0031872841F, 0.0032417289F, 0.0032966338F,
+ 0.0033519988F, 0.0034078238F, 0.0034641089F, 0.0035208539F,
+ 0.0035780589F, 0.0036357237F, 0.0036938485F, 0.0037524331F,
+ 0.0038114775F, 0.0038709817F, 0.0039309456F, 0.0039913692F,
+ 0.0040522524F, 0.0041135953F, 0.0041753978F, 0.0042376599F,
+ 0.0043003814F, 0.0043635624F, 0.0044272029F, 0.0044913028F,
+ 0.0045558620F, 0.0046208806F, 0.0046863585F, 0.0047522955F,
+ 0.0048186919F, 0.0048855473F, 0.0049528619F, 0.0050206356F,
+ 0.0050888684F, 0.0051575601F, 0.0052267108F, 0.0052963204F,
+ 0.0053663890F, 0.0054369163F, 0.0055079025F, 0.0055793474F,
+ 0.0056512510F, 0.0057236133F, 0.0057964342F, 0.0058697137F,
+ 0.0059434517F, 0.0060176482F, 0.0060923032F, 0.0061674166F,
+ 0.0062429883F, 0.0063190183F, 0.0063955066F, 0.0064724532F,
+ 0.0065498579F, 0.0066277207F, 0.0067060416F, 0.0067848205F,
+ 0.0068640575F, 0.0069437523F, 0.0070239051F, 0.0071045157F,
+ 0.0071855840F, 0.0072671102F, 0.0073490940F, 0.0074315355F,
+ 0.0075144345F, 0.0075977911F, 0.0076816052F, 0.0077658768F,
+ 0.0078506057F, 0.0079357920F, 0.0080214355F, 0.0081075363F,
+ 0.0081940943F, 0.0082811094F, 0.0083685816F, 0.0084565108F,
+ 0.0085448970F, 0.0086337401F, 0.0087230401F, 0.0088127969F,
+ 0.0089030104F, 0.0089936807F, 0.0090848076F, 0.0091763911F,
+ 0.0092684311F, 0.0093609276F, 0.0094538805F, 0.0095472898F,
+ 0.0096411554F, 0.0097354772F, 0.0098302552F, 0.0099254894F,
+ 0.0100211796F, 0.0101173259F, 0.0102139281F, 0.0103109863F,
+ 0.0104085002F, 0.0105064700F, 0.0106048955F, 0.0107037766F,
+ 0.0108031133F, 0.0109029056F, 0.0110031534F, 0.0111038565F,
+ 0.0112050151F, 0.0113066289F, 0.0114086980F, 0.0115112222F,
+ 0.0116142015F, 0.0117176359F, 0.0118215252F, 0.0119258695F,
+ 0.0120306686F, 0.0121359225F, 0.0122416312F, 0.0123477944F,
+ 0.0124544123F, 0.0125614847F, 0.0126690116F, 0.0127769928F,
+ 0.0128854284F, 0.0129943182F, 0.0131036623F, 0.0132134604F,
+ 0.0133237126F, 0.0134344188F, 0.0135455790F, 0.0136571929F,
+ 0.0137692607F, 0.0138817821F, 0.0139947572F, 0.0141081859F,
+ 0.0142220681F, 0.0143364037F, 0.0144511927F, 0.0145664350F,
+ 0.0146821304F, 0.0147982791F, 0.0149148808F, 0.0150319355F,
+ 0.0151494431F, 0.0152674036F, 0.0153858168F, 0.0155046828F,
+ 0.0156240014F, 0.0157437726F, 0.0158639962F, 0.0159846723F,
+ 0.0161058007F, 0.0162273814F, 0.0163494142F, 0.0164718991F,
+ 0.0165948361F, 0.0167182250F, 0.0168420658F, 0.0169663584F,
+ 0.0170911027F, 0.0172162987F, 0.0173419462F, 0.0174680452F,
+ 0.0175945956F, 0.0177215974F, 0.0178490504F, 0.0179769545F,
+ 0.0181053098F, 0.0182341160F, 0.0183633732F, 0.0184930812F,
+ 0.0186232399F, 0.0187538494F, 0.0188849094F, 0.0190164200F,
+ 0.0191483809F, 0.0192807923F, 0.0194136539F, 0.0195469656F,
+ 0.0196807275F, 0.0198149394F, 0.0199496012F, 0.0200847128F,
+ 0.0202202742F, 0.0203562853F, 0.0204927460F, 0.0206296561F,
+ 0.0207670157F, 0.0209048245F, 0.0210430826F, 0.0211817899F,
+ 0.0213209462F, 0.0214605515F, 0.0216006057F, 0.0217411086F,
+ 0.0218820603F, 0.0220234605F, 0.0221653093F, 0.0223076066F,
+ 0.0224503521F, 0.0225935459F, 0.0227371879F, 0.0228812779F,
+ 0.0230258160F, 0.0231708018F, 0.0233162355F, 0.0234621169F,
+ 0.0236084459F, 0.0237552224F, 0.0239024462F, 0.0240501175F,
+ 0.0241982359F, 0.0243468015F, 0.0244958141F, 0.0246452736F,
+ 0.0247951800F, 0.0249455331F, 0.0250963329F, 0.0252475792F,
+ 0.0253992720F, 0.0255514111F, 0.0257039965F, 0.0258570281F,
+ 0.0260105057F, 0.0261644293F, 0.0263187987F, 0.0264736139F,
+ 0.0266288747F, 0.0267845811F, 0.0269407330F, 0.0270973302F,
+ 0.0272543727F, 0.0274118604F, 0.0275697930F, 0.0277281707F,
+ 0.0278869932F, 0.0280462604F, 0.0282059723F, 0.0283661287F,
+ 0.0285267295F, 0.0286877747F, 0.0288492641F, 0.0290111976F,
+ 0.0291735751F, 0.0293363965F, 0.0294996617F, 0.0296633706F,
+ 0.0298275231F, 0.0299921190F, 0.0301571583F, 0.0303226409F,
+ 0.0304885667F, 0.0306549354F, 0.0308217472F, 0.0309890017F,
+ 0.0311566989F, 0.0313248388F, 0.0314934211F, 0.0316624459F,
+ 0.0318319128F, 0.0320018220F, 0.0321721732F, 0.0323429663F,
+ 0.0325142013F, 0.0326858779F, 0.0328579962F, 0.0330305559F,
+ 0.0332035570F, 0.0333769994F, 0.0335508829F, 0.0337252074F,
+ 0.0338999728F, 0.0340751790F, 0.0342508259F, 0.0344269134F,
+ 0.0346034412F, 0.0347804094F, 0.0349578178F, 0.0351356663F,
+ 0.0353139548F, 0.0354926831F, 0.0356718511F, 0.0358514588F,
+ 0.0360315059F, 0.0362119924F, 0.0363929182F, 0.0365742831F,
+ 0.0367560870F, 0.0369383297F, 0.0371210113F, 0.0373041315F,
+ 0.0374876902F, 0.0376716873F, 0.0378561226F, 0.0380409961F,
+ 0.0382263077F, 0.0384120571F, 0.0385982443F, 0.0387848691F,
+ 0.0389719315F, 0.0391594313F, 0.0393473683F, 0.0395357425F,
+ 0.0397245537F, 0.0399138017F, 0.0401034866F, 0.0402936080F,
+ 0.0404841660F, 0.0406751603F, 0.0408665909F, 0.0410584576F,
+ 0.0412507603F, 0.0414434988F, 0.0416366731F, 0.0418302829F,
+ 0.0420243282F, 0.0422188088F, 0.0424137246F, 0.0426090755F,
+ 0.0428048613F, 0.0430010819F, 0.0431977371F, 0.0433948269F,
+ 0.0435923511F, 0.0437903095F, 0.0439887020F, 0.0441875285F,
+ 0.0443867889F, 0.0445864830F, 0.0447866106F, 0.0449871717F,
+ 0.0451881661F, 0.0453895936F, 0.0455914542F, 0.0457937477F,
+ 0.0459964738F, 0.0461996326F, 0.0464032239F, 0.0466072475F,
+ 0.0468117032F, 0.0470165910F, 0.0472219107F, 0.0474276622F,
+ 0.0476338452F, 0.0478404597F, 0.0480475056F, 0.0482549827F,
+ 0.0484628907F, 0.0486712297F, 0.0488799994F, 0.0490891998F,
+ 0.0492988306F, 0.0495088917F, 0.0497193830F, 0.0499303043F,
+ 0.0501416554F, 0.0503534363F, 0.0505656468F, 0.0507782867F,
+ 0.0509913559F, 0.0512048542F, 0.0514187815F, 0.0516331376F,
+ 0.0518479225F, 0.0520631358F, 0.0522787775F, 0.0524948475F,
+ 0.0527113455F, 0.0529282715F, 0.0531456252F, 0.0533634066F,
+ 0.0535816154F, 0.0538002515F, 0.0540193148F, 0.0542388051F,
+ 0.0544587222F, 0.0546790660F, 0.0548998364F, 0.0551210331F,
+ 0.0553426561F, 0.0555647051F, 0.0557871801F, 0.0560100807F,
+ 0.0562334070F, 0.0564571587F, 0.0566813357F, 0.0569059378F,
+ 0.0571309649F, 0.0573564168F, 0.0575822933F, 0.0578085942F,
+ 0.0580353195F, 0.0582624689F, 0.0584900423F, 0.0587180396F,
+ 0.0589464605F, 0.0591753049F, 0.0594045726F, 0.0596342635F,
+ 0.0598643774F, 0.0600949141F, 0.0603258735F, 0.0605572555F,
+ 0.0607890597F, 0.0610212862F, 0.0612539346F, 0.0614870049F,
+ 0.0617204968F, 0.0619544103F, 0.0621887451F, 0.0624235010F,
+ 0.0626586780F, 0.0628942758F, 0.0631302942F, 0.0633667331F,
+ 0.0636035923F, 0.0638408717F, 0.0640785710F, 0.0643166901F,
+ 0.0645552288F, 0.0647941870F, 0.0650335645F, 0.0652733610F,
+ 0.0655135765F, 0.0657542108F, 0.0659952636F, 0.0662367348F,
+ 0.0664786242F, 0.0667209316F, 0.0669636570F, 0.0672068000F,
+ 0.0674503605F, 0.0676943384F, 0.0679387334F, 0.0681835454F,
+ 0.0684287742F, 0.0686744196F, 0.0689204814F, 0.0691669595F,
+ 0.0694138536F, 0.0696611637F, 0.0699088894F, 0.0701570307F,
+ 0.0704055873F, 0.0706545590F, 0.0709039458F, 0.0711537473F,
+ 0.0714039634F, 0.0716545939F, 0.0719056387F, 0.0721570975F,
+ 0.0724089702F, 0.0726612565F, 0.0729139563F, 0.0731670694F,
+ 0.0734205956F, 0.0736745347F, 0.0739288866F, 0.0741836510F,
+ 0.0744388277F, 0.0746944166F, 0.0749504175F, 0.0752068301F,
+ 0.0754636543F, 0.0757208899F, 0.0759785367F, 0.0762365946F,
+ 0.0764950632F, 0.0767539424F, 0.0770132320F, 0.0772729319F,
+ 0.0775330418F, 0.0777935616F, 0.0780544909F, 0.0783158298F,
+ 0.0785775778F, 0.0788397349F, 0.0791023009F, 0.0793652755F,
+ 0.0796286585F, 0.0798924498F, 0.0801566492F, 0.0804212564F,
+ 0.0806862712F, 0.0809516935F, 0.0812175231F, 0.0814837597F,
+ 0.0817504031F, 0.0820174532F, 0.0822849097F, 0.0825527724F,
+ 0.0828210412F, 0.0830897158F, 0.0833587960F, 0.0836282816F,
+ 0.0838981724F, 0.0841684682F, 0.0844391688F, 0.0847102740F,
+ 0.0849817835F, 0.0852536973F, 0.0855260150F, 0.0857987364F,
+ 0.0860718614F, 0.0863453897F, 0.0866193211F, 0.0868936554F,
+ 0.0871683924F, 0.0874435319F, 0.0877190737F, 0.0879950175F,
+ 0.0882713632F, 0.0885481105F, 0.0888252592F, 0.0891028091F,
+ 0.0893807600F, 0.0896591117F, 0.0899378639F, 0.0902170165F,
+ 0.0904965692F, 0.0907765218F, 0.0910568740F, 0.0913376258F,
+ 0.0916187767F, 0.0919003268F, 0.0921822756F, 0.0924646230F,
+ 0.0927473687F, 0.0930305126F, 0.0933140545F, 0.0935979940F,
+ 0.0938823310F, 0.0941670653F, 0.0944521966F, 0.0947377247F,
+ 0.0950236494F, 0.0953099704F, 0.0955966876F, 0.0958838007F,
+ 0.0961713094F, 0.0964592136F, 0.0967475131F, 0.0970362075F,
+ 0.0973252967F, 0.0976147805F, 0.0979046585F, 0.0981949307F,
+ 0.0984855967F, 0.0987766563F, 0.0990681093F, 0.0993599555F,
+ 0.0996521945F, 0.0999448263F, 0.1002378506F, 0.1005312671F,
+ 0.1008250755F, 0.1011192757F, 0.1014138675F, 0.1017088505F,
+ 0.1020042246F, 0.1022999895F, 0.1025961450F, 0.1028926909F,
+ 0.1031896268F, 0.1034869526F, 0.1037846680F, 0.1040827729F,
+ 0.1043812668F, 0.1046801497F, 0.1049794213F, 0.1052790813F,
+ 0.1055791294F, 0.1058795656F, 0.1061803894F, 0.1064816006F,
+ 0.1067831991F, 0.1070851846F, 0.1073875568F, 0.1076903155F,
+ 0.1079934604F, 0.1082969913F, 0.1086009079F, 0.1089052101F,
+ 0.1092098975F, 0.1095149699F, 0.1098204270F, 0.1101262687F,
+ 0.1104324946F, 0.1107391045F, 0.1110460982F, 0.1113534754F,
+ 0.1116612359F, 0.1119693793F, 0.1122779055F, 0.1125868142F,
+ 0.1128961052F, 0.1132057781F, 0.1135158328F, 0.1138262690F,
+ 0.1141370863F, 0.1144482847F, 0.1147598638F, 0.1150718233F,
+ 0.1153841631F, 0.1156968828F, 0.1160099822F, 0.1163234610F,
+ 0.1166373190F, 0.1169515559F, 0.1172661714F, 0.1175811654F,
+ 0.1178965374F, 0.1182122874F, 0.1185284149F, 0.1188449198F,
+ 0.1191618018F, 0.1194790606F, 0.1197966960F, 0.1201147076F,
+ 0.1204330953F, 0.1207518587F, 0.1210709976F, 0.1213905118F,
+ 0.1217104009F, 0.1220306647F, 0.1223513029F, 0.1226723153F,
+ 0.1229937016F, 0.1233154615F, 0.1236375948F, 0.1239601011F,
+ 0.1242829803F, 0.1246062319F, 0.1249298559F, 0.1252538518F,
+ 0.1255782195F, 0.1259029586F, 0.1262280689F, 0.1265535501F,
+ 0.1268794019F, 0.1272056241F, 0.1275322163F, 0.1278591784F,
+ 0.1281865099F, 0.1285142108F, 0.1288422805F, 0.1291707190F,
+ 0.1294995259F, 0.1298287009F, 0.1301582437F, 0.1304881542F,
+ 0.1308184319F, 0.1311490766F, 0.1314800881F, 0.1318114660F,
+ 0.1321432100F, 0.1324753200F, 0.1328077955F, 0.1331406364F,
+ 0.1334738422F, 0.1338074129F, 0.1341413479F, 0.1344756472F,
+ 0.1348103103F, 0.1351453370F, 0.1354807270F, 0.1358164801F,
+ 0.1361525959F, 0.1364890741F, 0.1368259145F, 0.1371631167F,
+ 0.1375006805F, 0.1378386056F, 0.1381768917F, 0.1385155384F,
+ 0.1388545456F, 0.1391939129F, 0.1395336400F, 0.1398737266F,
+ 0.1402141724F, 0.1405549772F, 0.1408961406F, 0.1412376623F,
+ 0.1415795421F, 0.1419217797F, 0.1422643746F, 0.1426073268F,
+ 0.1429506358F, 0.1432943013F, 0.1436383231F, 0.1439827008F,
+ 0.1443274342F, 0.1446725229F, 0.1450179667F, 0.1453637652F,
+ 0.1457099181F, 0.1460564252F, 0.1464032861F, 0.1467505006F,
+ 0.1470980682F, 0.1474459888F, 0.1477942620F, 0.1481428875F,
+ 0.1484918651F, 0.1488411942F, 0.1491908748F, 0.1495409065F,
+ 0.1498912889F, 0.1502420218F, 0.1505931048F, 0.1509445376F,
+ 0.1512963200F, 0.1516484516F, 0.1520009321F, 0.1523537612F,
+ 0.1527069385F, 0.1530604638F, 0.1534143368F, 0.1537685571F,
+ 0.1541231244F, 0.1544780384F, 0.1548332987F, 0.1551889052F,
+ 0.1555448574F, 0.1559011550F, 0.1562577978F, 0.1566147853F,
+ 0.1569721173F, 0.1573297935F, 0.1576878135F, 0.1580461771F,
+ 0.1584048838F, 0.1587639334F, 0.1591233255F, 0.1594830599F,
+ 0.1598431361F, 0.1602035540F, 0.1605643131F, 0.1609254131F,
+ 0.1612868537F, 0.1616486346F, 0.1620107555F, 0.1623732160F,
+ 0.1627360158F, 0.1630991545F, 0.1634626319F, 0.1638264476F,
+ 0.1641906013F, 0.1645550926F, 0.1649199212F, 0.1652850869F,
+ 0.1656505892F, 0.1660164278F, 0.1663826024F, 0.1667491127F,
+ 0.1671159583F, 0.1674831388F, 0.1678506541F, 0.1682185036F,
+ 0.1685866872F, 0.1689552044F, 0.1693240549F, 0.1696932384F,
+ 0.1700627545F, 0.1704326029F, 0.1708027833F, 0.1711732952F,
+ 0.1715441385F, 0.1719153127F, 0.1722868175F, 0.1726586526F,
+ 0.1730308176F, 0.1734033121F, 0.1737761359F, 0.1741492886F,
+ 0.1745227698F, 0.1748965792F, 0.1752707164F, 0.1756451812F,
+ 0.1760199731F, 0.1763950918F, 0.1767705370F, 0.1771463083F,
+ 0.1775224054F, 0.1778988279F, 0.1782755754F, 0.1786526477F,
+ 0.1790300444F, 0.1794077651F, 0.1797858094F, 0.1801641771F,
+ 0.1805428677F, 0.1809218810F, 0.1813012165F, 0.1816808739F,
+ 0.1820608528F, 0.1824411530F, 0.1828217739F, 0.1832027154F,
+ 0.1835839770F, 0.1839655584F, 0.1843474592F, 0.1847296790F,
+ 0.1851122175F, 0.1854950744F, 0.1858782492F, 0.1862617417F,
+ 0.1866455514F, 0.1870296780F, 0.1874141211F, 0.1877988804F,
+ 0.1881839555F, 0.1885693461F, 0.1889550517F, 0.1893410721F,
+ 0.1897274068F, 0.1901140555F, 0.1905010178F, 0.1908882933F,
+ 0.1912758818F, 0.1916637828F, 0.1920519959F, 0.1924405208F,
+ 0.1928293571F, 0.1932185044F, 0.1936079625F, 0.1939977308F,
+ 0.1943878091F, 0.1947781969F, 0.1951688939F, 0.1955598998F,
+ 0.1959512141F, 0.1963428364F, 0.1967347665F, 0.1971270038F,
+ 0.1975195482F, 0.1979123990F, 0.1983055561F, 0.1986990190F,
+ 0.1990927873F, 0.1994868607F, 0.1998812388F, 0.2002759212F,
+ 0.2006709075F, 0.2010661974F, 0.2014617904F, 0.2018576862F,
+ 0.2022538844F, 0.2026503847F, 0.2030471865F, 0.2034442897F,
+ 0.2038416937F, 0.2042393982F, 0.2046374028F, 0.2050357071F,
+ 0.2054343107F, 0.2058332133F, 0.2062324145F, 0.2066319138F,
+ 0.2070317110F, 0.2074318055F, 0.2078321970F, 0.2082328852F,
+ 0.2086338696F, 0.2090351498F, 0.2094367255F, 0.2098385962F,
+ 0.2102407617F, 0.2106432213F, 0.2110459749F, 0.2114490220F,
+ 0.2118523621F, 0.2122559950F, 0.2126599202F, 0.2130641373F,
+ 0.2134686459F, 0.2138734456F, 0.2142785361F, 0.2146839168F,
+ 0.2150895875F, 0.2154955478F, 0.2159017972F, 0.2163083353F,
+ 0.2167151617F, 0.2171222761F, 0.2175296780F, 0.2179373670F,
+ 0.2183453428F, 0.2187536049F, 0.2191621529F, 0.2195709864F,
+ 0.2199801051F, 0.2203895085F, 0.2207991961F, 0.2212091677F,
+ 0.2216194228F, 0.2220299610F, 0.2224407818F, 0.2228518850F,
+ 0.2232632699F, 0.2236749364F, 0.2240868839F, 0.2244991121F,
+ 0.2249116204F, 0.2253244086F, 0.2257374763F, 0.2261508229F,
+ 0.2265644481F, 0.2269783514F, 0.2273925326F, 0.2278069911F,
+ 0.2282217265F, 0.2286367384F, 0.2290520265F, 0.2294675902F,
+ 0.2298834292F, 0.2302995431F, 0.2307159314F, 0.2311325937F,
+ 0.2315495297F, 0.2319667388F, 0.2323842207F, 0.2328019749F,
+ 0.2332200011F, 0.2336382988F, 0.2340568675F, 0.2344757070F,
+ 0.2348948166F, 0.2353141961F, 0.2357338450F, 0.2361537629F,
+ 0.2365739493F, 0.2369944038F, 0.2374151261F, 0.2378361156F,
+ 0.2382573720F, 0.2386788948F, 0.2391006836F, 0.2395227380F,
+ 0.2399450575F, 0.2403676417F, 0.2407904902F, 0.2412136026F,
+ 0.2416369783F, 0.2420606171F, 0.2424845185F, 0.2429086820F,
+ 0.2433331072F, 0.2437577936F, 0.2441827409F, 0.2446079486F,
+ 0.2450334163F, 0.2454591435F, 0.2458851298F, 0.2463113747F,
+ 0.2467378779F, 0.2471646389F, 0.2475916573F, 0.2480189325F,
+ 0.2484464643F, 0.2488742521F, 0.2493022955F, 0.2497305940F,
+ 0.2501591473F, 0.2505879549F, 0.2510170163F, 0.2514463311F,
+ 0.2518758989F, 0.2523057193F, 0.2527357916F, 0.2531661157F,
+ 0.2535966909F, 0.2540275169F, 0.2544585931F, 0.2548899193F,
+ 0.2553214948F, 0.2557533193F, 0.2561853924F, 0.2566177135F,
+ 0.2570502822F, 0.2574830981F, 0.2579161608F, 0.2583494697F,
+ 0.2587830245F, 0.2592168246F, 0.2596508697F, 0.2600851593F,
+ 0.2605196929F, 0.2609544701F, 0.2613894904F, 0.2618247534F,
+ 0.2622602586F, 0.2626960055F, 0.2631319938F, 0.2635682230F,
+ 0.2640046925F, 0.2644414021F, 0.2648783511F, 0.2653155391F,
+ 0.2657529657F, 0.2661906305F, 0.2666285329F, 0.2670666725F,
+ 0.2675050489F, 0.2679436616F, 0.2683825101F, 0.2688215940F,
+ 0.2692609127F, 0.2697004660F, 0.2701402532F, 0.2705802739F,
+ 0.2710205278F, 0.2714610142F, 0.2719017327F, 0.2723426830F,
+ 0.2727838644F, 0.2732252766F, 0.2736669191F, 0.2741087914F,
+ 0.2745508930F, 0.2749932235F, 0.2754357824F, 0.2758785693F,
+ 0.2763215837F, 0.2767648251F, 0.2772082930F, 0.2776519870F,
+ 0.2780959066F, 0.2785400513F, 0.2789844207F, 0.2794290143F,
+ 0.2798738316F, 0.2803188722F, 0.2807641355F, 0.2812096211F,
+ 0.2816553286F, 0.2821012574F, 0.2825474071F, 0.2829937773F,
+ 0.2834403673F, 0.2838871768F, 0.2843342053F, 0.2847814523F,
+ 0.2852289174F, 0.2856765999F, 0.2861244996F, 0.2865726159F,
+ 0.2870209482F, 0.2874694962F, 0.2879182594F, 0.2883672372F,
+ 0.2888164293F, 0.2892658350F, 0.2897154540F, 0.2901652858F,
+ 0.2906153298F, 0.2910655856F, 0.2915160527F, 0.2919667306F,
+ 0.2924176189F, 0.2928687171F, 0.2933200246F, 0.2937715409F,
+ 0.2942232657F, 0.2946751984F, 0.2951273386F, 0.2955796856F,
+ 0.2960322391F, 0.2964849986F, 0.2969379636F, 0.2973911335F,
+ 0.2978445080F, 0.2982980864F, 0.2987518684F, 0.2992058534F,
+ 0.2996600409F, 0.3001144305F, 0.3005690217F, 0.3010238139F,
+ 0.3014788067F, 0.3019339995F, 0.3023893920F, 0.3028449835F,
+ 0.3033007736F, 0.3037567618F, 0.3042129477F, 0.3046693306F,
+ 0.3051259102F, 0.3055826859F, 0.3060396572F, 0.3064968236F,
+ 0.3069541847F, 0.3074117399F, 0.3078694887F, 0.3083274307F,
+ 0.3087855653F, 0.3092438920F, 0.3097024104F, 0.3101611199F,
+ 0.3106200200F, 0.3110791103F, 0.3115383902F, 0.3119978592F,
+ 0.3124575169F, 0.3129173627F, 0.3133773961F, 0.3138376166F,
+ 0.3142980238F, 0.3147586170F, 0.3152193959F, 0.3156803598F,
+ 0.3161415084F, 0.3166028410F, 0.3170643573F, 0.3175260566F,
+ 0.3179879384F, 0.3184500023F, 0.3189122478F, 0.3193746743F,
+ 0.3198372814F, 0.3203000685F, 0.3207630351F, 0.3212261807F,
+ 0.3216895048F, 0.3221530069F, 0.3226166865F, 0.3230805430F,
+ 0.3235445760F, 0.3240087849F, 0.3244731693F, 0.3249377285F,
+ 0.3254024622F, 0.3258673698F, 0.3263324507F, 0.3267977045F,
+ 0.3272631306F, 0.3277287286F, 0.3281944978F, 0.3286604379F,
+ 0.3291265482F, 0.3295928284F, 0.3300592777F, 0.3305258958F,
+ 0.3309926821F, 0.3314596361F, 0.3319267573F, 0.3323940451F,
+ 0.3328614990F, 0.3333291186F, 0.3337969033F, 0.3342648525F,
+ 0.3347329658F, 0.3352012427F, 0.3356696825F, 0.3361382849F,
+ 0.3366070492F, 0.3370759749F, 0.3375450616F, 0.3380143087F,
+ 0.3384837156F, 0.3389532819F, 0.3394230071F, 0.3398928905F,
+ 0.3403629317F, 0.3408331302F, 0.3413034854F, 0.3417739967F,
+ 0.3422446638F, 0.3427154860F, 0.3431864628F, 0.3436575938F,
+ 0.3441288782F, 0.3446003158F, 0.3450719058F, 0.3455436478F,
+ 0.3460155412F, 0.3464875856F, 0.3469597804F, 0.3474321250F,
+ 0.3479046189F, 0.3483772617F, 0.3488500527F, 0.3493229914F,
+ 0.3497960774F, 0.3502693100F, 0.3507426887F, 0.3512162131F,
+ 0.3516898825F, 0.3521636965F, 0.3526376545F, 0.3531117559F,
+ 0.3535860003F, 0.3540603870F, 0.3545349157F, 0.3550095856F,
+ 0.3554843964F, 0.3559593474F, 0.3564344381F, 0.3569096680F,
+ 0.3573850366F, 0.3578605432F, 0.3583361875F, 0.3588119687F,
+ 0.3592878865F, 0.3597639402F, 0.3602401293F, 0.3607164533F,
+ 0.3611929117F, 0.3616695038F, 0.3621462292F, 0.3626230873F,
+ 0.3631000776F, 0.3635771995F, 0.3640544525F, 0.3645318360F,
+ 0.3650093496F, 0.3654869926F, 0.3659647645F, 0.3664426648F,
+ 0.3669206930F, 0.3673988484F, 0.3678771306F, 0.3683555390F,
+ 0.3688340731F, 0.3693127322F, 0.3697915160F, 0.3702704237F,
+ 0.3707494549F, 0.3712286091F, 0.3717078857F, 0.3721872840F,
+ 0.3726668037F, 0.3731464441F, 0.3736262047F, 0.3741060850F,
+ 0.3745860843F, 0.3750662023F, 0.3755464382F, 0.3760267915F,
+ 0.3765072618F, 0.3769878484F, 0.3774685509F, 0.3779493686F,
+ 0.3784303010F, 0.3789113475F, 0.3793925076F, 0.3798737809F,
+ 0.3803551666F, 0.3808366642F, 0.3813182733F, 0.3817999932F,
+ 0.3822818234F, 0.3827637633F, 0.3832458124F, 0.3837279702F,
+ 0.3842102360F, 0.3846926093F, 0.3851750897F, 0.3856576764F,
+ 0.3861403690F, 0.3866231670F, 0.3871060696F, 0.3875890765F,
+ 0.3880721870F, 0.3885554007F, 0.3890387168F, 0.3895221349F,
+ 0.3900056544F, 0.3904892748F, 0.3909729955F, 0.3914568160F,
+ 0.3919407356F, 0.3924247539F, 0.3929088702F, 0.3933930841F,
+ 0.3938773949F, 0.3943618021F, 0.3948463052F, 0.3953309035F,
+ 0.3958155966F, 0.3963003838F, 0.3967852646F, 0.3972702385F,
+ 0.3977553048F, 0.3982404631F, 0.3987257127F, 0.3992110531F,
+ 0.3996964838F, 0.4001820041F, 0.4006676136F, 0.4011533116F,
+ 0.4016390976F, 0.4021249710F, 0.4026109313F, 0.4030969779F,
+ 0.4035831102F, 0.4040693277F, 0.4045556299F, 0.4050420160F,
+ 0.4055284857F, 0.4060150383F, 0.4065016732F, 0.4069883899F,
+ 0.4074751879F, 0.4079620665F, 0.4084490252F, 0.4089360635F,
+ 0.4094231807F, 0.4099103763F, 0.4103976498F, 0.4108850005F,
+ 0.4113724280F, 0.4118599315F, 0.4123475107F, 0.4128351648F,
+ 0.4133228934F, 0.4138106959F, 0.4142985716F, 0.4147865201F,
+ 0.4152745408F, 0.4157626330F, 0.4162507963F, 0.4167390301F,
+ 0.4172273337F, 0.4177157067F, 0.4182041484F, 0.4186926583F,
+ 0.4191812359F, 0.4196698805F, 0.4201585915F, 0.4206473685F,
+ 0.4211362108F, 0.4216251179F, 0.4221140892F, 0.4226031241F,
+ 0.4230922221F, 0.4235813826F, 0.4240706050F, 0.4245598887F,
+ 0.4250492332F, 0.4255386379F, 0.4260281022F, 0.4265176256F,
+ 0.4270072075F, 0.4274968473F, 0.4279865445F, 0.4284762984F,
+ 0.4289661086F, 0.4294559743F, 0.4299458951F, 0.4304358704F,
+ 0.4309258996F, 0.4314159822F, 0.4319061175F, 0.4323963050F,
+ 0.4328865441F, 0.4333768342F, 0.4338671749F, 0.4343575654F,
+ 0.4348480052F, 0.4353384938F, 0.4358290306F, 0.4363196149F,
+ 0.4368102463F, 0.4373009241F, 0.4377916478F, 0.4382824168F,
+ 0.4387732305F, 0.4392640884F, 0.4397549899F, 0.4402459343F,
+ 0.4407369212F, 0.4412279499F, 0.4417190198F, 0.4422101305F,
+ 0.4427012813F, 0.4431924717F, 0.4436837010F, 0.4441749686F,
+ 0.4446662742F, 0.4451576169F, 0.4456489963F, 0.4461404118F,
+ 0.4466318628F, 0.4471233487F, 0.4476148690F, 0.4481064230F,
+ 0.4485980103F, 0.4490896302F, 0.4495812821F, 0.4500729654F,
+ 0.4505646797F, 0.4510564243F, 0.4515481986F, 0.4520400021F,
+ 0.4525318341F, 0.4530236942F, 0.4535155816F, 0.4540074959F,
+ 0.4544994365F, 0.4549914028F, 0.4554833941F, 0.4559754100F,
+ 0.4564674499F, 0.4569595131F, 0.4574515991F, 0.4579437074F,
+ 0.4584358372F, 0.4589279881F, 0.4594201595F, 0.4599123508F,
+ 0.4604045615F, 0.4608967908F, 0.4613890383F, 0.4618813034F,
+ 0.4623735855F, 0.4628658841F, 0.4633581984F, 0.4638505281F,
+ 0.4643428724F, 0.4648352308F, 0.4653276028F, 0.4658199877F,
+ 0.4663123849F, 0.4668047940F, 0.4672972143F, 0.4677896451F,
+ 0.4682820861F, 0.4687745365F, 0.4692669958F, 0.4697594634F,
+ 0.4702519387F, 0.4707444211F, 0.4712369102F, 0.4717294052F,
+ 0.4722219056F, 0.4727144109F, 0.4732069204F, 0.4736994336F,
+ 0.4741919498F, 0.4746844686F, 0.4751769893F, 0.4756695113F,
+ 0.4761620341F, 0.4766545571F, 0.4771470797F, 0.4776396013F,
+ 0.4781321213F, 0.4786246392F, 0.4791171544F, 0.4796096663F,
+ 0.4801021744F, 0.4805946779F, 0.4810871765F, 0.4815796694F,
+ 0.4820721561F, 0.4825646360F, 0.4830571086F, 0.4835495732F,
+ 0.4840420293F, 0.4845344763F, 0.4850269136F, 0.4855193407F,
+ 0.4860117569F, 0.4865041617F, 0.4869965545F, 0.4874889347F,
+ 0.4879813018F, 0.4884736551F, 0.4889659941F, 0.4894583182F,
+ 0.4899506268F, 0.4904429193F, 0.4909351952F, 0.4914274538F,
+ 0.4919196947F, 0.4924119172F, 0.4929041207F, 0.4933963046F,
+ 0.4938884685F, 0.4943806116F, 0.4948727335F, 0.4953648335F,
+ 0.4958569110F, 0.4963489656F, 0.4968409965F, 0.4973330032F,
+ 0.4978249852F, 0.4983169419F, 0.4988088726F, 0.4993007768F,
+ 0.4997926539F, 0.5002845034F, 0.5007763247F, 0.5012681171F,
+ 0.5017598801F, 0.5022516132F, 0.5027433157F, 0.5032349871F,
+ 0.5037266268F, 0.5042182341F, 0.5047098086F, 0.5052013497F,
+ 0.5056928567F, 0.5061843292F, 0.5066757664F, 0.5071671679F,
+ 0.5076585330F, 0.5081498613F, 0.5086411520F, 0.5091324047F,
+ 0.5096236187F, 0.5101147934F, 0.5106059284F, 0.5110970230F,
+ 0.5115880766F, 0.5120790887F, 0.5125700587F, 0.5130609860F,
+ 0.5135518700F, 0.5140427102F, 0.5145335059F, 0.5150242566F,
+ 0.5155149618F, 0.5160056208F, 0.5164962331F, 0.5169867980F,
+ 0.5174773151F, 0.5179677837F, 0.5184582033F, 0.5189485733F,
+ 0.5194388931F, 0.5199291621F, 0.5204193798F, 0.5209095455F,
+ 0.5213996588F, 0.5218897190F, 0.5223797256F, 0.5228696779F,
+ 0.5233595755F, 0.5238494177F, 0.5243392039F, 0.5248289337F,
+ 0.5253186063F, 0.5258082213F, 0.5262977781F, 0.5267872760F,
+ 0.5272767146F, 0.5277660932F, 0.5282554112F, 0.5287446682F,
+ 0.5292338635F, 0.5297229965F, 0.5302120667F, 0.5307010736F,
+ 0.5311900164F, 0.5316788947F, 0.5321677079F, 0.5326564554F,
+ 0.5331451366F, 0.5336337511F, 0.5341222981F, 0.5346107771F,
+ 0.5350991876F, 0.5355875290F, 0.5360758007F, 0.5365640021F,
+ 0.5370521327F, 0.5375401920F, 0.5380281792F, 0.5385160939F,
+ 0.5390039355F, 0.5394917034F, 0.5399793971F, 0.5404670159F,
+ 0.5409545594F, 0.5414420269F, 0.5419294179F, 0.5424167318F,
+ 0.5429039680F, 0.5433911261F, 0.5438782053F, 0.5443652051F,
+ 0.5448521250F, 0.5453389644F, 0.5458257228F, 0.5463123995F,
+ 0.5467989940F, 0.5472855057F, 0.5477719341F, 0.5482582786F,
+ 0.5487445387F, 0.5492307137F, 0.5497168031F, 0.5502028063F,
+ 0.5506887228F, 0.5511745520F, 0.5516602934F, 0.5521459463F,
+ 0.5526315103F, 0.5531169847F, 0.5536023690F, 0.5540876626F,
+ 0.5545728649F, 0.5550579755F, 0.5555429937F, 0.5560279189F,
+ 0.5565127507F, 0.5569974884F, 0.5574821315F, 0.5579666794F,
+ 0.5584511316F, 0.5589354875F, 0.5594197465F, 0.5599039080F,
+ 0.5603879716F, 0.5608719367F, 0.5613558026F, 0.5618395689F,
+ 0.5623232350F, 0.5628068002F, 0.5632902642F, 0.5637736262F,
+ 0.5642568858F, 0.5647400423F, 0.5652230953F, 0.5657060442F,
+ 0.5661888883F, 0.5666716272F, 0.5671542603F, 0.5676367870F,
+ 0.5681192069F, 0.5686015192F, 0.5690837235F, 0.5695658192F,
+ 0.5700478058F, 0.5705296827F, 0.5710114494F, 0.5714931052F,
+ 0.5719746497F, 0.5724560822F, 0.5729374023F, 0.5734186094F,
+ 0.5738997029F, 0.5743806823F, 0.5748615470F, 0.5753422965F,
+ 0.5758229301F, 0.5763034475F, 0.5767838480F, 0.5772641310F,
+ 0.5777442960F, 0.5782243426F, 0.5787042700F, 0.5791840778F,
+ 0.5796637654F, 0.5801433322F, 0.5806227778F, 0.5811021016F,
+ 0.5815813029F, 0.5820603814F, 0.5825393363F, 0.5830181673F,
+ 0.5834968737F, 0.5839754549F, 0.5844539105F, 0.5849322399F,
+ 0.5854104425F, 0.5858885179F, 0.5863664653F, 0.5868442844F,
+ 0.5873219746F, 0.5877995353F, 0.5882769660F, 0.5887542661F,
+ 0.5892314351F, 0.5897084724F, 0.5901853776F, 0.5906621500F,
+ 0.5911387892F, 0.5916152945F, 0.5920916655F, 0.5925679016F,
+ 0.5930440022F, 0.5935199669F, 0.5939957950F, 0.5944714861F,
+ 0.5949470396F, 0.5954224550F, 0.5958977317F, 0.5963728692F,
+ 0.5968478669F, 0.5973227244F, 0.5977974411F, 0.5982720163F,
+ 0.5987464497F, 0.5992207407F, 0.5996948887F, 0.6001688932F,
+ 0.6006427537F, 0.6011164696F, 0.6015900405F, 0.6020634657F,
+ 0.6025367447F, 0.6030098770F, 0.6034828621F, 0.6039556995F,
+ 0.6044283885F, 0.6049009288F, 0.6053733196F, 0.6058455606F,
+ 0.6063176512F, 0.6067895909F, 0.6072613790F, 0.6077330152F,
+ 0.6082044989F, 0.6086758295F, 0.6091470065F, 0.6096180294F,
+ 0.6100888977F, 0.6105596108F, 0.6110301682F, 0.6115005694F,
+ 0.6119708139F, 0.6124409011F, 0.6129108305F, 0.6133806017F,
+ 0.6138502139F, 0.6143196669F, 0.6147889599F, 0.6152580926F,
+ 0.6157270643F, 0.6161958746F, 0.6166645230F, 0.6171330088F,
+ 0.6176013317F, 0.6180694910F, 0.6185374863F, 0.6190053171F,
+ 0.6194729827F, 0.6199404828F, 0.6204078167F, 0.6208749841F,
+ 0.6213419842F, 0.6218088168F, 0.6222754811F, 0.6227419768F,
+ 0.6232083032F, 0.6236744600F, 0.6241404465F, 0.6246062622F,
+ 0.6250719067F, 0.6255373795F, 0.6260026799F, 0.6264678076F,
+ 0.6269327619F, 0.6273975425F, 0.6278621487F, 0.6283265800F,
+ 0.6287908361F, 0.6292549163F, 0.6297188201F, 0.6301825471F,
+ 0.6306460966F, 0.6311094683F, 0.6315726617F, 0.6320356761F,
+ 0.6324985111F, 0.6329611662F, 0.6334236410F, 0.6338859348F,
+ 0.6343480472F, 0.6348099777F, 0.6352717257F, 0.6357332909F,
+ 0.6361946726F, 0.6366558704F, 0.6371168837F, 0.6375777122F,
+ 0.6380383552F, 0.6384988123F, 0.6389590830F, 0.6394191668F,
+ 0.6398790631F, 0.6403387716F, 0.6407982916F, 0.6412576228F,
+ 0.6417167645F, 0.6421757163F, 0.6426344778F, 0.6430930483F,
+ 0.6435514275F, 0.6440096149F, 0.6444676098F, 0.6449254119F,
+ 0.6453830207F, 0.6458404356F, 0.6462976562F, 0.6467546820F,
+ 0.6472115125F, 0.6476681472F, 0.6481245856F, 0.6485808273F,
+ 0.6490368717F, 0.6494927183F, 0.6499483667F, 0.6504038164F,
+ 0.6508590670F, 0.6513141178F, 0.6517689684F, 0.6522236185F,
+ 0.6526780673F, 0.6531323146F, 0.6535863598F, 0.6540402024F,
+ 0.6544938419F, 0.6549472779F, 0.6554005099F, 0.6558535373F,
+ 0.6563063598F, 0.6567589769F, 0.6572113880F, 0.6576635927F,
+ 0.6581155906F, 0.6585673810F, 0.6590189637F, 0.6594703380F,
+ 0.6599215035F, 0.6603724598F, 0.6608232064F, 0.6612737427F,
+ 0.6617240684F, 0.6621741829F, 0.6626240859F, 0.6630737767F,
+ 0.6635232550F, 0.6639725202F, 0.6644215720F, 0.6648704098F,
+ 0.6653190332F, 0.6657674417F, 0.6662156348F, 0.6666636121F,
+ 0.6671113731F, 0.6675589174F, 0.6680062445F, 0.6684533538F,
+ 0.6689002450F, 0.6693469177F, 0.6697933712F, 0.6702396052F,
+ 0.6706856193F, 0.6711314129F, 0.6715769855F, 0.6720223369F,
+ 0.6724674664F, 0.6729123736F, 0.6733570581F, 0.6738015194F,
+ 0.6742457570F, 0.6746897706F, 0.6751335596F, 0.6755771236F,
+ 0.6760204621F, 0.6764635747F, 0.6769064609F, 0.6773491204F,
+ 0.6777915525F, 0.6782337570F, 0.6786757332F, 0.6791174809F,
+ 0.6795589995F, 0.6800002886F, 0.6804413477F, 0.6808821765F,
+ 0.6813227743F, 0.6817631409F, 0.6822032758F, 0.6826431785F,
+ 0.6830828485F, 0.6835222855F, 0.6839614890F, 0.6844004585F,
+ 0.6848391936F, 0.6852776939F, 0.6857159589F, 0.6861539883F,
+ 0.6865917815F, 0.6870293381F, 0.6874666576F, 0.6879037398F,
+ 0.6883405840F, 0.6887771899F, 0.6892135571F, 0.6896496850F,
+ 0.6900855733F, 0.6905212216F, 0.6909566294F, 0.6913917963F,
+ 0.6918267218F, 0.6922614055F, 0.6926958471F, 0.6931300459F,
+ 0.6935640018F, 0.6939977141F, 0.6944311825F, 0.6948644066F,
+ 0.6952973859F, 0.6957301200F, 0.6961626085F, 0.6965948510F,
+ 0.6970268470F, 0.6974585961F, 0.6978900980F, 0.6983213521F,
+ 0.6987523580F, 0.6991831154F, 0.6996136238F, 0.7000438828F,
+ 0.7004738921F, 0.7009036510F, 0.7013331594F, 0.7017624166F,
+ 0.7021914224F, 0.7026201763F, 0.7030486779F, 0.7034769268F,
+ 0.7039049226F, 0.7043326648F, 0.7047601531F, 0.7051873870F,
+ 0.7056143662F, 0.7060410902F, 0.7064675586F, 0.7068937711F,
+ 0.7073197271F, 0.7077454264F, 0.7081708684F, 0.7085960529F,
+ 0.7090209793F, 0.7094456474F, 0.7098700566F, 0.7102942066F,
+ 0.7107180970F, 0.7111417274F, 0.7115650974F, 0.7119882066F,
+ 0.7124110545F, 0.7128336409F, 0.7132559653F, 0.7136780272F,
+ 0.7140998264F, 0.7145213624F, 0.7149426348F, 0.7153636433F,
+ 0.7157843874F, 0.7162048668F, 0.7166250810F, 0.7170450296F,
+ 0.7174647124F, 0.7178841289F, 0.7183032786F, 0.7187221613F,
+ 0.7191407765F, 0.7195591239F, 0.7199772030F, 0.7203950135F,
+ 0.7208125550F, 0.7212298271F, 0.7216468294F, 0.7220635616F,
+ 0.7224800233F, 0.7228962140F, 0.7233121335F, 0.7237277813F,
+ 0.7241431571F, 0.7245582604F, 0.7249730910F, 0.7253876484F,
+ 0.7258019322F, 0.7262159422F, 0.7266296778F, 0.7270431388F,
+ 0.7274563247F, 0.7278692353F, 0.7282818700F, 0.7286942287F,
+ 0.7291063108F, 0.7295181160F, 0.7299296440F, 0.7303408944F,
+ 0.7307518669F, 0.7311625609F, 0.7315729763F, 0.7319831126F,
+ 0.7323929695F, 0.7328025466F, 0.7332118435F, 0.7336208600F,
+ 0.7340295955F, 0.7344380499F, 0.7348462226F, 0.7352541134F,
+ 0.7356617220F, 0.7360690478F, 0.7364760907F, 0.7368828502F,
+ 0.7372893259F, 0.7376955176F, 0.7381014249F, 0.7385070475F,
+ 0.7389123849F, 0.7393174368F, 0.7397222029F, 0.7401266829F,
+ 0.7405308763F, 0.7409347829F, 0.7413384023F, 0.7417417341F,
+ 0.7421447780F, 0.7425475338F, 0.7429500009F, 0.7433521791F,
+ 0.7437540681F, 0.7441556674F, 0.7445569769F, 0.7449579960F,
+ 0.7453587245F, 0.7457591621F, 0.7461593084F, 0.7465591631F,
+ 0.7469587259F, 0.7473579963F, 0.7477569741F, 0.7481556590F,
+ 0.7485540506F, 0.7489521486F, 0.7493499526F, 0.7497474623F,
+ 0.7501446775F, 0.7505415977F, 0.7509382227F, 0.7513345521F,
+ 0.7517305856F, 0.7521263229F, 0.7525217636F, 0.7529169074F,
+ 0.7533117541F, 0.7537063032F, 0.7541005545F, 0.7544945076F,
+ 0.7548881623F, 0.7552815182F, 0.7556745749F, 0.7560673323F,
+ 0.7564597899F, 0.7568519474F, 0.7572438046F, 0.7576353611F,
+ 0.7580266166F, 0.7584175708F, 0.7588082235F, 0.7591985741F,
+ 0.7595886226F, 0.7599783685F, 0.7603678116F, 0.7607569515F,
+ 0.7611457879F, 0.7615343206F, 0.7619225493F, 0.7623104735F,
+ 0.7626980931F, 0.7630854078F, 0.7634724171F, 0.7638591209F,
+ 0.7642455188F, 0.7646316106F, 0.7650173959F, 0.7654028744F,
+ 0.7657880459F, 0.7661729100F, 0.7665574664F, 0.7669417150F,
+ 0.7673256553F, 0.7677092871F, 0.7680926100F, 0.7684756239F,
+ 0.7688583284F, 0.7692407232F, 0.7696228080F, 0.7700045826F,
+ 0.7703860467F, 0.7707671999F, 0.7711480420F, 0.7715285728F,
+ 0.7719087918F, 0.7722886989F, 0.7726682938F, 0.7730475762F,
+ 0.7734265458F, 0.7738052023F, 0.7741835454F, 0.7745615750F,
+ 0.7749392906F, 0.7753166921F, 0.7756937791F, 0.7760705514F,
+ 0.7764470087F, 0.7768231508F, 0.7771989773F, 0.7775744880F,
+ 0.7779496827F, 0.7783245610F, 0.7786991227F, 0.7790733676F,
+ 0.7794472953F, 0.7798209056F, 0.7801941982F, 0.7805671729F,
+ 0.7809398294F, 0.7813121675F, 0.7816841869F, 0.7820558873F,
+ 0.7824272684F, 0.7827983301F, 0.7831690720F, 0.7835394940F,
+ 0.7839095957F, 0.7842793768F, 0.7846488373F, 0.7850179767F,
+ 0.7853867948F, 0.7857552914F, 0.7861234663F, 0.7864913191F,
+ 0.7868588497F, 0.7872260578F, 0.7875929431F, 0.7879595055F,
+ 0.7883257445F, 0.7886916601F, 0.7890572520F, 0.7894225198F,
+ 0.7897874635F, 0.7901520827F, 0.7905163772F, 0.7908803468F,
+ 0.7912439912F, 0.7916073102F, 0.7919703035F, 0.7923329710F,
+ 0.7926953124F, 0.7930573274F, 0.7934190158F, 0.7937803774F,
+ 0.7941414120F, 0.7945021193F, 0.7948624991F, 0.7952225511F,
+ 0.7955822752F, 0.7959416711F, 0.7963007387F, 0.7966594775F,
+ 0.7970178875F, 0.7973759685F, 0.7977337201F, 0.7980911422F,
+ 0.7984482346F, 0.7988049970F, 0.7991614292F, 0.7995175310F,
+ 0.7998733022F, 0.8002287426F, 0.8005838519F, 0.8009386299F,
+ 0.8012930765F, 0.8016471914F, 0.8020009744F, 0.8023544253F,
+ 0.8027075438F, 0.8030603298F, 0.8034127831F, 0.8037649035F,
+ 0.8041166906F, 0.8044681445F, 0.8048192647F, 0.8051700512F,
+ 0.8055205038F, 0.8058706222F, 0.8062204062F, 0.8065698556F,
+ 0.8069189702F, 0.8072677499F, 0.8076161944F, 0.8079643036F,
+ 0.8083120772F, 0.8086595151F, 0.8090066170F, 0.8093533827F,
+ 0.8096998122F, 0.8100459051F, 0.8103916613F, 0.8107370806F,
+ 0.8110821628F, 0.8114269077F, 0.8117713151F, 0.8121153849F,
+ 0.8124591169F, 0.8128025108F, 0.8131455666F, 0.8134882839F,
+ 0.8138306627F, 0.8141727027F, 0.8145144038F, 0.8148557658F,
+ 0.8151967886F, 0.8155374718F, 0.8158778154F, 0.8162178192F,
+ 0.8165574830F, 0.8168968067F, 0.8172357900F, 0.8175744328F,
+ 0.8179127349F, 0.8182506962F, 0.8185883164F, 0.8189255955F,
+ 0.8192625332F, 0.8195991295F, 0.8199353840F, 0.8202712967F,
+ 0.8206068673F, 0.8209420958F, 0.8212769820F, 0.8216115256F,
+ 0.8219457266F, 0.8222795848F, 0.8226131000F, 0.8229462721F,
+ 0.8232791009F, 0.8236115863F, 0.8239437280F, 0.8242755260F,
+ 0.8246069801F, 0.8249380901F, 0.8252688559F, 0.8255992774F,
+ 0.8259293544F, 0.8262590867F, 0.8265884741F, 0.8269175167F,
+ 0.8272462141F, 0.8275745663F, 0.8279025732F, 0.8282302344F,
+ 0.8285575501F, 0.8288845199F, 0.8292111437F, 0.8295374215F,
+ 0.8298633530F, 0.8301889382F, 0.8305141768F, 0.8308390688F,
+ 0.8311636141F, 0.8314878124F, 0.8318116637F, 0.8321351678F,
+ 0.8324583246F, 0.8327811340F, 0.8331035957F, 0.8334257098F,
+ 0.8337474761F, 0.8340688944F, 0.8343899647F, 0.8347106867F,
+ 0.8350310605F, 0.8353510857F, 0.8356707624F, 0.8359900904F,
+ 0.8363090696F, 0.8366276999F, 0.8369459811F, 0.8372639131F,
+ 0.8375814958F, 0.8378987292F, 0.8382156130F, 0.8385321472F,
+ 0.8388483316F, 0.8391641662F, 0.8394796508F, 0.8397947853F,
+ 0.8401095697F, 0.8404240037F, 0.8407380873F, 0.8410518204F,
+ 0.8413652029F, 0.8416782347F, 0.8419909156F, 0.8423032456F,
+ 0.8426152245F, 0.8429268523F, 0.8432381289F, 0.8435490541F,
+ 0.8438596279F, 0.8441698502F, 0.8444797208F, 0.8447892396F,
+ 0.8450984067F, 0.8454072218F, 0.8457156849F, 0.8460237959F,
+ 0.8463315547F, 0.8466389612F, 0.8469460154F, 0.8472527170F,
+ 0.8475590661F, 0.8478650625F, 0.8481707063F, 0.8484759971F,
+ 0.8487809351F, 0.8490855201F, 0.8493897521F, 0.8496936308F,
+ 0.8499971564F, 0.8503003286F, 0.8506031474F, 0.8509056128F,
+ 0.8512077246F, 0.8515094828F, 0.8518108872F, 0.8521119379F,
+ 0.8524126348F, 0.8527129777F, 0.8530129666F, 0.8533126015F,
+ 0.8536118822F, 0.8539108087F, 0.8542093809F, 0.8545075988F,
+ 0.8548054623F, 0.8551029712F, 0.8554001257F, 0.8556969255F,
+ 0.8559933707F, 0.8562894611F, 0.8565851968F, 0.8568805775F,
+ 0.8571756034F, 0.8574702743F, 0.8577645902F, 0.8580585509F,
+ 0.8583521566F, 0.8586454070F, 0.8589383021F, 0.8592308420F,
+ 0.8595230265F, 0.8598148556F, 0.8601063292F, 0.8603974473F,
+ 0.8606882098F, 0.8609786167F, 0.8612686680F, 0.8615583636F,
+ 0.8618477034F, 0.8621366874F, 0.8624253156F, 0.8627135878F,
+ 0.8630015042F, 0.8632890646F, 0.8635762690F, 0.8638631173F,
+ 0.8641496096F, 0.8644357457F, 0.8647215257F, 0.8650069495F,
+ 0.8652920171F, 0.8655767283F, 0.8658610833F, 0.8661450820F,
+ 0.8664287243F, 0.8667120102F, 0.8669949397F, 0.8672775127F,
+ 0.8675597293F, 0.8678415894F, 0.8681230929F, 0.8684042398F,
+ 0.8686850302F, 0.8689654640F, 0.8692455412F, 0.8695252617F,
+ 0.8698046255F, 0.8700836327F, 0.8703622831F, 0.8706405768F,
+ 0.8709185138F, 0.8711960940F, 0.8714733174F, 0.8717501840F,
+ 0.8720266939F, 0.8723028469F, 0.8725786430F, 0.8728540824F,
+ 0.8731291648F, 0.8734038905F, 0.8736782592F, 0.8739522711F,
+ 0.8742259261F, 0.8744992242F, 0.8747721653F, 0.8750447496F,
+ 0.8753169770F, 0.8755888475F, 0.8758603611F, 0.8761315177F,
+ 0.8764023175F, 0.8766727603F, 0.8769428462F, 0.8772125752F,
+ 0.8774819474F, 0.8777509626F, 0.8780196209F, 0.8782879224F,
+ 0.8785558669F, 0.8788234546F, 0.8790906854F, 0.8793575594F,
+ 0.8796240765F, 0.8798902368F, 0.8801560403F, 0.8804214870F,
+ 0.8806865768F, 0.8809513099F, 0.8812156863F, 0.8814797059F,
+ 0.8817433687F, 0.8820066749F, 0.8822696243F, 0.8825322171F,
+ 0.8827944532F, 0.8830563327F, 0.8833178556F, 0.8835790219F,
+ 0.8838398316F, 0.8841002848F, 0.8843603815F, 0.8846201217F,
+ 0.8848795054F, 0.8851385327F, 0.8853972036F, 0.8856555182F,
+ 0.8859134764F, 0.8861710783F, 0.8864283239F, 0.8866852133F,
+ 0.8869417464F, 0.8871979234F, 0.8874537443F, 0.8877092090F,
+ 0.8879643177F, 0.8882190704F, 0.8884734671F, 0.8887275078F,
+ 0.8889811927F, 0.8892345216F, 0.8894874948F, 0.8897401122F,
+ 0.8899923738F, 0.8902442798F, 0.8904958301F, 0.8907470248F,
+ 0.8909978640F, 0.8912483477F, 0.8914984759F, 0.8917482487F,
+ 0.8919976662F, 0.8922467284F, 0.8924954353F, 0.8927437871F,
+ 0.8929917837F, 0.8932394252F, 0.8934867118F, 0.8937336433F,
+ 0.8939802199F, 0.8942264417F, 0.8944723087F, 0.8947178210F,
+ 0.8949629785F, 0.8952077815F, 0.8954522299F, 0.8956963239F,
+ 0.8959400634F, 0.8961834486F, 0.8964264795F, 0.8966691561F,
+ 0.8969114786F, 0.8971534470F, 0.8973950614F, 0.8976363219F,
+ 0.8978772284F, 0.8981177812F, 0.8983579802F, 0.8985978256F,
+ 0.8988373174F, 0.8990764556F, 0.8993152405F, 0.8995536720F,
+ 0.8997917502F, 0.9000294751F, 0.9002668470F, 0.9005038658F,
+ 0.9007405317F, 0.9009768446F, 0.9012128048F, 0.9014484123F,
+ 0.9016836671F, 0.9019185693F, 0.9021531191F, 0.9023873165F,
+ 0.9026211616F, 0.9028546546F, 0.9030877954F, 0.9033205841F,
+ 0.9035530210F, 0.9037851059F, 0.9040168392F, 0.9042482207F,
+ 0.9044792507F, 0.9047099293F, 0.9049402564F, 0.9051702323F,
+ 0.9053998569F, 0.9056291305F, 0.9058580531F, 0.9060866248F,
+ 0.9063148457F, 0.9065427159F, 0.9067702355F, 0.9069974046F,
+ 0.9072242233F, 0.9074506917F, 0.9076768100F, 0.9079025782F,
+ 0.9081279964F, 0.9083530647F, 0.9085777833F, 0.9088021523F,
+ 0.9090261717F, 0.9092498417F, 0.9094731623F, 0.9096961338F,
+ 0.9099187561F, 0.9101410295F, 0.9103629540F, 0.9105845297F,
+ 0.9108057568F, 0.9110266354F, 0.9112471656F, 0.9114673475F,
+ 0.9116871812F, 0.9119066668F, 0.9121258046F, 0.9123445945F,
+ 0.9125630367F, 0.9127811314F, 0.9129988786F, 0.9132162785F,
+ 0.9134333312F, 0.9136500368F, 0.9138663954F, 0.9140824073F,
+ 0.9142980724F, 0.9145133910F, 0.9147283632F, 0.9149429890F,
+ 0.9151572687F, 0.9153712023F, 0.9155847900F, 0.9157980319F,
+ 0.9160109282F, 0.9162234790F, 0.9164356844F, 0.9166475445F,
+ 0.9168590595F, 0.9170702296F, 0.9172810548F, 0.9174915354F,
+ 0.9177016714F, 0.9179114629F, 0.9181209102F, 0.9183300134F,
+ 0.9185387726F, 0.9187471879F, 0.9189552595F, 0.9191629876F,
+ 0.9193703723F, 0.9195774136F, 0.9197841119F, 0.9199904672F,
+ 0.9201964797F, 0.9204021495F, 0.9206074767F, 0.9208124616F,
+ 0.9210171043F, 0.9212214049F, 0.9214253636F, 0.9216289805F,
+ 0.9218322558F, 0.9220351896F, 0.9222377821F, 0.9224400335F,
+ 0.9226419439F, 0.9228435134F, 0.9230447423F, 0.9232456307F,
+ 0.9234461787F, 0.9236463865F, 0.9238462543F, 0.9240457822F,
+ 0.9242449704F, 0.9244438190F, 0.9246423282F, 0.9248404983F,
+ 0.9250383293F, 0.9252358214F, 0.9254329747F, 0.9256297896F,
+ 0.9258262660F, 0.9260224042F, 0.9262182044F, 0.9264136667F,
+ 0.9266087913F, 0.9268035783F, 0.9269980280F, 0.9271921405F,
+ 0.9273859160F, 0.9275793546F, 0.9277724566F, 0.9279652221F,
+ 0.9281576513F, 0.9283497443F, 0.9285415014F, 0.9287329227F,
+ 0.9289240084F, 0.9291147586F, 0.9293051737F, 0.9294952536F,
+ 0.9296849987F, 0.9298744091F, 0.9300634850F, 0.9302522266F,
+ 0.9304406340F, 0.9306287074F, 0.9308164471F, 0.9310038532F,
+ 0.9311909259F, 0.9313776654F, 0.9315640719F, 0.9317501455F,
+ 0.9319358865F, 0.9321212951F, 0.9323063713F, 0.9324911155F,
+ 0.9326755279F, 0.9328596085F, 0.9330433577F, 0.9332267756F,
+ 0.9334098623F, 0.9335926182F, 0.9337750434F, 0.9339571380F,
+ 0.9341389023F, 0.9343203366F, 0.9345014409F, 0.9346822155F,
+ 0.9348626606F, 0.9350427763F, 0.9352225630F, 0.9354020207F,
+ 0.9355811498F, 0.9357599503F, 0.9359384226F, 0.9361165667F,
+ 0.9362943830F, 0.9364718716F, 0.9366490327F, 0.9368258666F,
+ 0.9370023733F, 0.9371785533F, 0.9373544066F, 0.9375299335F,
+ 0.9377051341F, 0.9378800087F, 0.9380545576F, 0.9382287809F,
+ 0.9384026787F, 0.9385762515F, 0.9387494993F, 0.9389224223F,
+ 0.9390950209F, 0.9392672951F, 0.9394392453F, 0.9396108716F,
+ 0.9397821743F, 0.9399531536F, 0.9401238096F, 0.9402941427F,
+ 0.9404641530F, 0.9406338407F, 0.9408032061F, 0.9409722495F,
+ 0.9411409709F, 0.9413093707F, 0.9414774491F, 0.9416452062F,
+ 0.9418126424F, 0.9419797579F, 0.9421465528F, 0.9423130274F,
+ 0.9424791819F, 0.9426450166F, 0.9428105317F, 0.9429757274F,
+ 0.9431406039F, 0.9433051616F, 0.9434694005F, 0.9436333209F,
+ 0.9437969232F, 0.9439602074F, 0.9441231739F, 0.9442858229F,
+ 0.9444481545F, 0.9446101691F, 0.9447718669F, 0.9449332481F,
+ 0.9450943129F, 0.9452550617F, 0.9454154945F, 0.9455756118F,
+ 0.9457354136F, 0.9458949003F, 0.9460540721F, 0.9462129292F,
+ 0.9463714719F, 0.9465297003F, 0.9466876149F, 0.9468452157F,
+ 0.9470025031F, 0.9471594772F, 0.9473161384F, 0.9474724869F,
+ 0.9476285229F, 0.9477842466F, 0.9479396584F, 0.9480947585F,
+ 0.9482495470F, 0.9484040243F, 0.9485581906F, 0.9487120462F,
+ 0.9488655913F, 0.9490188262F, 0.9491717511F, 0.9493243662F,
+ 0.9494766718F, 0.9496286683F, 0.9497803557F, 0.9499317345F,
+ 0.9500828047F, 0.9502335668F, 0.9503840209F, 0.9505341673F,
+ 0.9506840062F, 0.9508335380F, 0.9509827629F, 0.9511316810F,
+ 0.9512802928F, 0.9514285984F, 0.9515765982F, 0.9517242923F,
+ 0.9518716810F, 0.9520187646F, 0.9521655434F, 0.9523120176F,
+ 0.9524581875F, 0.9526040534F, 0.9527496154F, 0.9528948739F,
+ 0.9530398292F, 0.9531844814F, 0.9533288310F, 0.9534728780F,
+ 0.9536166229F, 0.9537600659F, 0.9539032071F, 0.9540460470F,
+ 0.9541885858F, 0.9543308237F, 0.9544727611F, 0.9546143981F,
+ 0.9547557351F, 0.9548967723F, 0.9550375100F, 0.9551779485F,
+ 0.9553180881F, 0.9554579290F, 0.9555974714F, 0.9557367158F,
+ 0.9558756623F, 0.9560143112F, 0.9561526628F, 0.9562907174F,
+ 0.9564284752F, 0.9565659366F, 0.9567031017F, 0.9568399710F,
+ 0.9569765446F, 0.9571128229F, 0.9572488061F, 0.9573844944F,
+ 0.9575198883F, 0.9576549879F, 0.9577897936F, 0.9579243056F,
+ 0.9580585242F, 0.9581924497F, 0.9583260824F, 0.9584594226F,
+ 0.9585924705F, 0.9587252264F, 0.9588576906F, 0.9589898634F,
+ 0.9591217452F, 0.9592533360F, 0.9593846364F, 0.9595156465F,
+ 0.9596463666F, 0.9597767971F, 0.9599069382F, 0.9600367901F,
+ 0.9601663533F, 0.9602956279F, 0.9604246143F, 0.9605533128F,
+ 0.9606817236F, 0.9608098471F, 0.9609376835F, 0.9610652332F,
+ 0.9611924963F, 0.9613194733F, 0.9614461644F, 0.9615725699F,
+ 0.9616986901F, 0.9618245253F, 0.9619500757F, 0.9620753418F,
+ 0.9622003238F, 0.9623250219F, 0.9624494365F, 0.9625735679F,
+ 0.9626974163F, 0.9628209821F, 0.9629442656F, 0.9630672671F,
+ 0.9631899868F, 0.9633124251F, 0.9634345822F, 0.9635564585F,
+ 0.9636780543F, 0.9637993699F, 0.9639204056F, 0.9640411616F,
+ 0.9641616383F, 0.9642818359F, 0.9644017549F, 0.9645213955F,
+ 0.9646407579F, 0.9647598426F, 0.9648786497F, 0.9649971797F,
+ 0.9651154328F, 0.9652334092F, 0.9653511095F, 0.9654685337F,
+ 0.9655856823F, 0.9657025556F, 0.9658191538F, 0.9659354773F,
+ 0.9660515263F, 0.9661673013F, 0.9662828024F, 0.9663980300F,
+ 0.9665129845F, 0.9666276660F, 0.9667420750F, 0.9668562118F,
+ 0.9669700766F, 0.9670836698F, 0.9671969917F, 0.9673100425F,
+ 0.9674228227F, 0.9675353325F, 0.9676475722F, 0.9677595422F,
+ 0.9678712428F, 0.9679826742F, 0.9680938368F, 0.9682047309F,
+ 0.9683153569F, 0.9684257150F, 0.9685358056F, 0.9686456289F,
+ 0.9687551853F, 0.9688644752F, 0.9689734987F, 0.9690822564F,
+ 0.9691907483F, 0.9692989750F, 0.9694069367F, 0.9695146337F,
+ 0.9696220663F, 0.9697292349F, 0.9698361398F, 0.9699427813F,
+ 0.9700491597F, 0.9701552754F, 0.9702611286F, 0.9703667197F,
+ 0.9704720490F, 0.9705771169F, 0.9706819236F, 0.9707864695F,
+ 0.9708907549F, 0.9709947802F, 0.9710985456F, 0.9712020514F,
+ 0.9713052981F, 0.9714082859F, 0.9715110151F, 0.9716134862F,
+ 0.9717156993F, 0.9718176549F, 0.9719193532F, 0.9720207946F,
+ 0.9721219794F, 0.9722229080F, 0.9723235806F, 0.9724239976F,
+ 0.9725241593F, 0.9726240661F, 0.9727237183F, 0.9728231161F,
+ 0.9729222601F, 0.9730211503F, 0.9731197873F, 0.9732181713F,
+ 0.9733163027F, 0.9734141817F, 0.9735118088F, 0.9736091842F,
+ 0.9737063083F, 0.9738031814F, 0.9738998039F, 0.9739961760F,
+ 0.9740922981F, 0.9741881706F, 0.9742837938F, 0.9743791680F,
+ 0.9744742935F, 0.9745691707F, 0.9746637999F, 0.9747581814F,
+ 0.9748523157F, 0.9749462029F, 0.9750398435F, 0.9751332378F,
+ 0.9752263861F, 0.9753192887F, 0.9754119461F, 0.9755043585F,
+ 0.9755965262F, 0.9756884496F, 0.9757801291F, 0.9758715650F,
+ 0.9759627575F, 0.9760537071F, 0.9761444141F, 0.9762348789F,
+ 0.9763251016F, 0.9764150828F, 0.9765048228F, 0.9765943218F,
+ 0.9766835802F, 0.9767725984F, 0.9768613767F, 0.9769499154F,
+ 0.9770382149F, 0.9771262755F, 0.9772140976F, 0.9773016815F,
+ 0.9773890275F, 0.9774761360F, 0.9775630073F, 0.9776496418F,
+ 0.9777360398F, 0.9778222016F, 0.9779081277F, 0.9779938182F,
+ 0.9780792736F, 0.9781644943F, 0.9782494805F, 0.9783342326F,
+ 0.9784187509F, 0.9785030359F, 0.9785870877F, 0.9786709069F,
+ 0.9787544936F, 0.9788378484F, 0.9789209714F, 0.9790038631F,
+ 0.9790865238F, 0.9791689538F, 0.9792511535F, 0.9793331232F,
+ 0.9794148633F, 0.9794963742F, 0.9795776561F, 0.9796587094F,
+ 0.9797395345F, 0.9798201316F, 0.9799005013F, 0.9799806437F,
+ 0.9800605593F, 0.9801402483F, 0.9802197112F, 0.9802989483F,
+ 0.9803779600F, 0.9804567465F, 0.9805353082F, 0.9806136455F,
+ 0.9806917587F, 0.9807696482F, 0.9808473143F, 0.9809247574F,
+ 0.9810019778F, 0.9810789759F, 0.9811557519F, 0.9812323064F,
+ 0.9813086395F, 0.9813847517F, 0.9814606433F, 0.9815363147F,
+ 0.9816117662F, 0.9816869981F, 0.9817620108F, 0.9818368047F,
+ 0.9819113801F, 0.9819857374F, 0.9820598769F, 0.9821337989F,
+ 0.9822075038F, 0.9822809920F, 0.9823542638F, 0.9824273195F,
+ 0.9825001596F, 0.9825727843F, 0.9826451940F, 0.9827173891F,
+ 0.9827893700F, 0.9828611368F, 0.9829326901F, 0.9830040302F,
+ 0.9830751574F, 0.9831460720F, 0.9832167745F, 0.9832872652F,
+ 0.9833575444F, 0.9834276124F, 0.9834974697F, 0.9835671166F,
+ 0.9836365535F, 0.9837057806F, 0.9837747983F, 0.9838436071F,
+ 0.9839122072F, 0.9839805990F, 0.9840487829F, 0.9841167591F,
+ 0.9841845282F, 0.9842520903F, 0.9843194459F, 0.9843865953F,
+ 0.9844535389F, 0.9845202771F, 0.9845868101F, 0.9846531383F,
+ 0.9847192622F, 0.9847851820F, 0.9848508980F, 0.9849164108F,
+ 0.9849817205F, 0.9850468276F, 0.9851117324F, 0.9851764352F,
+ 0.9852409365F, 0.9853052366F, 0.9853693358F, 0.9854332344F,
+ 0.9854969330F, 0.9855604317F, 0.9856237309F, 0.9856868310F,
+ 0.9857497325F, 0.9858124355F, 0.9858749404F, 0.9859372477F,
+ 0.9859993577F, 0.9860612707F, 0.9861229871F, 0.9861845072F,
+ 0.9862458315F, 0.9863069601F, 0.9863678936F, 0.9864286322F,
+ 0.9864891764F, 0.9865495264F, 0.9866096826F, 0.9866696454F,
+ 0.9867294152F, 0.9867889922F, 0.9868483769F, 0.9869075695F,
+ 0.9869665706F, 0.9870253803F, 0.9870839991F, 0.9871424273F,
+ 0.9872006653F, 0.9872587135F, 0.9873165721F, 0.9873742415F,
+ 0.9874317222F, 0.9874890144F, 0.9875461185F, 0.9876030348F,
+ 0.9876597638F, 0.9877163057F, 0.9877726610F, 0.9878288300F,
+ 0.9878848130F, 0.9879406104F, 0.9879962225F, 0.9880516497F,
+ 0.9881068924F, 0.9881619509F, 0.9882168256F, 0.9882715168F,
+ 0.9883260249F, 0.9883803502F, 0.9884344931F, 0.9884884539F,
+ 0.9885422331F, 0.9885958309F, 0.9886492477F, 0.9887024838F,
+ 0.9887555397F, 0.9888084157F, 0.9888611120F, 0.9889136292F,
+ 0.9889659675F, 0.9890181273F, 0.9890701089F, 0.9891219128F,
+ 0.9891735392F, 0.9892249885F, 0.9892762610F, 0.9893273572F,
+ 0.9893782774F, 0.9894290219F, 0.9894795911F, 0.9895299853F,
+ 0.9895802049F, 0.9896302502F, 0.9896801217F, 0.9897298196F,
+ 0.9897793443F, 0.9898286961F, 0.9898778755F, 0.9899268828F,
+ 0.9899757183F, 0.9900243823F, 0.9900728753F, 0.9901211976F,
+ 0.9901693495F, 0.9902173314F, 0.9902651436F, 0.9903127865F,
+ 0.9903602605F, 0.9904075659F, 0.9904547031F, 0.9905016723F,
+ 0.9905484740F, 0.9905951086F, 0.9906415763F, 0.9906878775F,
+ 0.9907340126F, 0.9907799819F, 0.9908257858F, 0.9908714247F,
+ 0.9909168988F, 0.9909622086F, 0.9910073543F, 0.9910523364F,
+ 0.9910971552F, 0.9911418110F, 0.9911863042F, 0.9912306351F,
+ 0.9912748042F, 0.9913188117F, 0.9913626580F, 0.9914063435F,
+ 0.9914498684F, 0.9914932333F, 0.9915364383F, 0.9915794839F,
+ 0.9916223703F, 0.9916650981F, 0.9917076674F, 0.9917500787F,
+ 0.9917923323F, 0.9918344286F, 0.9918763679F, 0.9919181505F,
+ 0.9919597769F, 0.9920012473F, 0.9920425621F, 0.9920837217F,
+ 0.9921247263F, 0.9921655765F, 0.9922062724F, 0.9922468145F,
+ 0.9922872030F, 0.9923274385F, 0.9923675211F, 0.9924074513F,
+ 0.9924472294F, 0.9924868557F, 0.9925263306F, 0.9925656544F,
+ 0.9926048275F, 0.9926438503F, 0.9926827230F, 0.9927214461F,
+ 0.9927600199F, 0.9927984446F, 0.9928367208F, 0.9928748486F,
+ 0.9929128285F, 0.9929506608F, 0.9929883459F, 0.9930258841F,
+ 0.9930632757F, 0.9931005211F, 0.9931376207F, 0.9931745747F,
+ 0.9932113836F, 0.9932480476F, 0.9932845671F, 0.9933209425F,
+ 0.9933571742F, 0.9933932623F, 0.9934292074F, 0.9934650097F,
+ 0.9935006696F, 0.9935361874F, 0.9935715635F, 0.9936067982F,
+ 0.9936418919F, 0.9936768448F, 0.9937116574F, 0.9937463300F,
+ 0.9937808629F, 0.9938152565F, 0.9938495111F, 0.9938836271F,
+ 0.9939176047F, 0.9939514444F, 0.9939851465F, 0.9940187112F,
+ 0.9940521391F, 0.9940854303F, 0.9941185853F, 0.9941516044F,
+ 0.9941844879F, 0.9942172361F, 0.9942498495F, 0.9942823283F,
+ 0.9943146729F, 0.9943468836F, 0.9943789608F, 0.9944109047F,
+ 0.9944427158F, 0.9944743944F, 0.9945059408F, 0.9945373553F,
+ 0.9945686384F, 0.9945997902F, 0.9946308112F, 0.9946617017F,
+ 0.9946924621F, 0.9947230926F, 0.9947535937F, 0.9947839656F,
+ 0.9948142086F, 0.9948443232F, 0.9948743097F, 0.9949041683F,
+ 0.9949338995F, 0.9949635035F, 0.9949929807F, 0.9950223315F,
+ 0.9950515561F, 0.9950806549F, 0.9951096282F, 0.9951384764F,
+ 0.9951671998F, 0.9951957987F, 0.9952242735F, 0.9952526245F,
+ 0.9952808520F, 0.9953089564F, 0.9953369380F, 0.9953647971F,
+ 0.9953925340F, 0.9954201491F, 0.9954476428F, 0.9954750153F,
+ 0.9955022670F, 0.9955293981F, 0.9955564092F, 0.9955833003F,
+ 0.9956100720F, 0.9956367245F, 0.9956632582F, 0.9956896733F,
+ 0.9957159703F, 0.9957421494F, 0.9957682110F, 0.9957941553F,
+ 0.9958199828F, 0.9958456937F, 0.9958712884F, 0.9958967672F,
+ 0.9959221305F, 0.9959473784F, 0.9959725115F, 0.9959975300F,
+ 0.9960224342F, 0.9960472244F, 0.9960719011F, 0.9960964644F,
+ 0.9961209148F, 0.9961452525F, 0.9961694779F, 0.9961935913F,
+ 0.9962175930F, 0.9962414834F, 0.9962652627F, 0.9962889313F,
+ 0.9963124895F, 0.9963359377F, 0.9963592761F, 0.9963825051F,
+ 0.9964056250F, 0.9964286361F, 0.9964515387F, 0.9964743332F,
+ 0.9964970198F, 0.9965195990F, 0.9965420709F, 0.9965644360F,
+ 0.9965866946F, 0.9966088469F, 0.9966308932F, 0.9966528340F,
+ 0.9966746695F, 0.9966964001F, 0.9967180260F, 0.9967395475F,
+ 0.9967609651F, 0.9967822789F, 0.9968034894F, 0.9968245968F,
+ 0.9968456014F, 0.9968665036F, 0.9968873037F, 0.9969080019F,
+ 0.9969285987F, 0.9969490942F, 0.9969694889F, 0.9969897830F,
+ 0.9970099769F, 0.9970300708F, 0.9970500651F, 0.9970699601F,
+ 0.9970897561F, 0.9971094533F, 0.9971290522F, 0.9971485531F,
+ 0.9971679561F, 0.9971872617F, 0.9972064702F, 0.9972255818F,
+ 0.9972445968F, 0.9972635157F, 0.9972823386F, 0.9973010659F,
+ 0.9973196980F, 0.9973382350F, 0.9973566773F, 0.9973750253F,
+ 0.9973932791F, 0.9974114392F, 0.9974295059F, 0.9974474793F,
+ 0.9974653599F, 0.9974831480F, 0.9975008438F, 0.9975184476F,
+ 0.9975359598F, 0.9975533806F, 0.9975707104F, 0.9975879495F,
+ 0.9976050981F, 0.9976221566F, 0.9976391252F, 0.9976560043F,
+ 0.9976727941F, 0.9976894950F, 0.9977061073F, 0.9977226312F,
+ 0.9977390671F, 0.9977554152F, 0.9977716759F, 0.9977878495F,
+ 0.9978039361F, 0.9978199363F, 0.9978358501F, 0.9978516780F,
+ 0.9978674202F, 0.9978830771F, 0.9978986488F, 0.9979141358F,
+ 0.9979295383F, 0.9979448566F, 0.9979600909F, 0.9979752417F,
+ 0.9979903091F, 0.9980052936F, 0.9980201952F, 0.9980350145F,
+ 0.9980497515F, 0.9980644067F, 0.9980789804F, 0.9980934727F,
+ 0.9981078841F, 0.9981222147F, 0.9981364649F, 0.9981506350F,
+ 0.9981647253F, 0.9981787360F, 0.9981926674F, 0.9982065199F,
+ 0.9982202936F, 0.9982339890F, 0.9982476062F, 0.9982611456F,
+ 0.9982746074F, 0.9982879920F, 0.9983012996F, 0.9983145304F,
+ 0.9983276849F, 0.9983407632F, 0.9983537657F, 0.9983666926F,
+ 0.9983795442F, 0.9983923208F, 0.9984050226F, 0.9984176501F,
+ 0.9984302033F, 0.9984426827F, 0.9984550884F, 0.9984674208F,
+ 0.9984796802F, 0.9984918667F, 0.9985039808F, 0.9985160227F,
+ 0.9985279926F, 0.9985398909F, 0.9985517177F, 0.9985634734F,
+ 0.9985751583F, 0.9985867727F, 0.9985983167F, 0.9986097907F,
+ 0.9986211949F, 0.9986325297F, 0.9986437953F, 0.9986549919F,
+ 0.9986661199F, 0.9986771795F, 0.9986881710F, 0.9986990946F,
+ 0.9987099507F, 0.9987207394F, 0.9987314611F, 0.9987421161F,
+ 0.9987527045F, 0.9987632267F, 0.9987736829F, 0.9987840734F,
+ 0.9987943985F, 0.9988046584F, 0.9988148534F, 0.9988249838F,
+ 0.9988350498F, 0.9988450516F, 0.9988549897F, 0.9988648641F,
+ 0.9988746753F, 0.9988844233F, 0.9988941086F, 0.9989037313F,
+ 0.9989132918F, 0.9989227902F, 0.9989322269F, 0.9989416021F,
+ 0.9989509160F, 0.9989601690F, 0.9989693613F, 0.9989784931F,
+ 0.9989875647F, 0.9989965763F, 0.9990055283F, 0.9990144208F,
+ 0.9990232541F, 0.9990320286F, 0.9990407443F, 0.9990494016F,
+ 0.9990580008F, 0.9990665421F, 0.9990750257F, 0.9990834519F,
+ 0.9990918209F, 0.9991001331F, 0.9991083886F, 0.9991165877F,
+ 0.9991247307F, 0.9991328177F, 0.9991408491F, 0.9991488251F,
+ 0.9991567460F, 0.9991646119F, 0.9991724232F, 0.9991801801F,
+ 0.9991878828F, 0.9991955316F, 0.9992031267F, 0.9992106684F,
+ 0.9992181569F, 0.9992255925F, 0.9992329753F, 0.9992403057F,
+ 0.9992475839F, 0.9992548101F, 0.9992619846F, 0.9992691076F,
+ 0.9992761793F, 0.9992832001F, 0.9992901701F, 0.9992970895F,
+ 0.9993039587F, 0.9993107777F, 0.9993175470F, 0.9993242667F,
+ 0.9993309371F, 0.9993375583F, 0.9993441307F, 0.9993506545F,
+ 0.9993571298F, 0.9993635570F, 0.9993699362F, 0.9993762678F,
+ 0.9993825519F, 0.9993887887F, 0.9993949785F, 0.9994011216F,
+ 0.9994072181F, 0.9994132683F, 0.9994192725F, 0.9994252307F,
+ 0.9994311434F, 0.9994370107F, 0.9994428327F, 0.9994486099F,
+ 0.9994543423F, 0.9994600303F, 0.9994656739F, 0.9994712736F,
+ 0.9994768294F, 0.9994823417F, 0.9994878105F, 0.9994932363F,
+ 0.9994986191F, 0.9995039592F, 0.9995092568F, 0.9995145122F,
+ 0.9995197256F, 0.9995248971F, 0.9995300270F, 0.9995351156F,
+ 0.9995401630F, 0.9995451695F, 0.9995501352F, 0.9995550604F,
+ 0.9995599454F, 0.9995647903F, 0.9995695953F, 0.9995743607F,
+ 0.9995790866F, 0.9995837734F, 0.9995884211F, 0.9995930300F,
+ 0.9995976004F, 0.9996021324F, 0.9996066263F, 0.9996110822F,
+ 0.9996155004F, 0.9996198810F, 0.9996242244F, 0.9996285306F,
+ 0.9996327999F, 0.9996370326F, 0.9996412287F, 0.9996453886F,
+ 0.9996495125F, 0.9996536004F, 0.9996576527F, 0.9996616696F,
+ 0.9996656512F, 0.9996695977F, 0.9996735094F, 0.9996773865F,
+ 0.9996812291F, 0.9996850374F, 0.9996888118F, 0.9996925523F,
+ 0.9996962591F, 0.9996999325F, 0.9997035727F, 0.9997071798F,
+ 0.9997107541F, 0.9997142957F, 0.9997178049F, 0.9997212818F,
+ 0.9997247266F, 0.9997281396F, 0.9997315209F, 0.9997348708F,
+ 0.9997381893F, 0.9997414767F, 0.9997447333F, 0.9997479591F,
+ 0.9997511544F, 0.9997543194F, 0.9997574542F, 0.9997605591F,
+ 0.9997636342F, 0.9997666797F, 0.9997696958F, 0.9997726828F,
+ 0.9997756407F, 0.9997785698F, 0.9997814703F, 0.9997843423F,
+ 0.9997871860F, 0.9997900016F, 0.9997927894F, 0.9997955494F,
+ 0.9997982818F, 0.9998009869F, 0.9998036648F, 0.9998063157F,
+ 0.9998089398F, 0.9998115373F, 0.9998141082F, 0.9998166529F,
+ 0.9998191715F, 0.9998216642F, 0.9998241311F, 0.9998265724F,
+ 0.9998289884F, 0.9998313790F, 0.9998337447F, 0.9998360854F,
+ 0.9998384015F, 0.9998406930F, 0.9998429602F, 0.9998452031F,
+ 0.9998474221F, 0.9998496171F, 0.9998517885F, 0.9998539364F,
+ 0.9998560610F, 0.9998581624F, 0.9998602407F, 0.9998622962F,
+ 0.9998643291F, 0.9998663394F, 0.9998683274F, 0.9998702932F,
+ 0.9998722370F, 0.9998741589F, 0.9998760591F, 0.9998779378F,
+ 0.9998797952F, 0.9998816313F, 0.9998834464F, 0.9998852406F,
+ 0.9998870141F, 0.9998887670F, 0.9998904995F, 0.9998922117F,
+ 0.9998939039F, 0.9998955761F, 0.9998972285F, 0.9998988613F,
+ 0.9999004746F, 0.9999020686F, 0.9999036434F, 0.9999051992F,
+ 0.9999067362F, 0.9999082544F, 0.9999097541F, 0.9999112354F,
+ 0.9999126984F, 0.9999141433F, 0.9999155703F, 0.9999169794F,
+ 0.9999183709F, 0.9999197449F, 0.9999211014F, 0.9999224408F,
+ 0.9999237631F, 0.9999250684F, 0.9999263570F, 0.9999276289F,
+ 0.9999288843F, 0.9999301233F, 0.9999313461F, 0.9999325529F,
+ 0.9999337437F, 0.9999349187F, 0.9999360780F, 0.9999372218F,
+ 0.9999383503F, 0.9999394635F, 0.9999405616F, 0.9999416447F,
+ 0.9999427129F, 0.9999437665F, 0.9999448055F, 0.9999458301F,
+ 0.9999468404F, 0.9999478365F, 0.9999488185F, 0.9999497867F,
+ 0.9999507411F, 0.9999516819F, 0.9999526091F, 0.9999535230F,
+ 0.9999544236F, 0.9999553111F, 0.9999561856F, 0.9999570472F,
+ 0.9999578960F, 0.9999587323F, 0.9999595560F, 0.9999603674F,
+ 0.9999611666F, 0.9999619536F, 0.9999627286F, 0.9999634917F,
+ 0.9999642431F, 0.9999649828F, 0.9999657110F, 0.9999664278F,
+ 0.9999671334F, 0.9999678278F, 0.9999685111F, 0.9999691835F,
+ 0.9999698451F, 0.9999704960F, 0.9999711364F, 0.9999717662F,
+ 0.9999723858F, 0.9999729950F, 0.9999735942F, 0.9999741834F,
+ 0.9999747626F, 0.9999753321F, 0.9999758919F, 0.9999764421F,
+ 0.9999769828F, 0.9999775143F, 0.9999780364F, 0.9999785495F,
+ 0.9999790535F, 0.9999795485F, 0.9999800348F, 0.9999805124F,
+ 0.9999809813F, 0.9999814417F, 0.9999818938F, 0.9999823375F,
+ 0.9999827731F, 0.9999832005F, 0.9999836200F, 0.9999840316F,
+ 0.9999844353F, 0.9999848314F, 0.9999852199F, 0.9999856008F,
+ 0.9999859744F, 0.9999863407F, 0.9999866997F, 0.9999870516F,
+ 0.9999873965F, 0.9999877345F, 0.9999880656F, 0.9999883900F,
+ 0.9999887078F, 0.9999890190F, 0.9999893237F, 0.9999896220F,
+ 0.9999899140F, 0.9999901999F, 0.9999904796F, 0.9999907533F,
+ 0.9999910211F, 0.9999912830F, 0.9999915391F, 0.9999917896F,
+ 0.9999920345F, 0.9999922738F, 0.9999925077F, 0.9999927363F,
+ 0.9999929596F, 0.9999931777F, 0.9999933907F, 0.9999935987F,
+ 0.9999938018F, 0.9999940000F, 0.9999941934F, 0.9999943820F,
+ 0.9999945661F, 0.9999947456F, 0.9999949206F, 0.9999950912F,
+ 0.9999952575F, 0.9999954195F, 0.9999955773F, 0.9999957311F,
+ 0.9999958807F, 0.9999960265F, 0.9999961683F, 0.9999963063F,
+ 0.9999964405F, 0.9999965710F, 0.9999966979F, 0.9999968213F,
+ 0.9999969412F, 0.9999970576F, 0.9999971707F, 0.9999972805F,
+ 0.9999973871F, 0.9999974905F, 0.9999975909F, 0.9999976881F,
+ 0.9999977824F, 0.9999978738F, 0.9999979624F, 0.9999980481F,
+ 0.9999981311F, 0.9999982115F, 0.9999982892F, 0.9999983644F,
+ 0.9999984370F, 0.9999985072F, 0.9999985750F, 0.9999986405F,
+ 0.9999987037F, 0.9999987647F, 0.9999988235F, 0.9999988802F,
+ 0.9999989348F, 0.9999989873F, 0.9999990379F, 0.9999990866F,
+ 0.9999991334F, 0.9999991784F, 0.9999992217F, 0.9999992632F,
+ 0.9999993030F, 0.9999993411F, 0.9999993777F, 0.9999994128F,
+ 0.9999994463F, 0.9999994784F, 0.9999995091F, 0.9999995384F,
+ 0.9999995663F, 0.9999995930F, 0.9999996184F, 0.9999996426F,
+ 0.9999996657F, 0.9999996876F, 0.9999997084F, 0.9999997282F,
+ 0.9999997469F, 0.9999997647F, 0.9999997815F, 0.9999997973F,
+ 0.9999998123F, 0.9999998265F, 0.9999998398F, 0.9999998524F,
+ 0.9999998642F, 0.9999998753F, 0.9999998857F, 0.9999998954F,
+ 0.9999999045F, 0.9999999130F, 0.9999999209F, 0.9999999282F,
+ 0.9999999351F, 0.9999999414F, 0.9999999472F, 0.9999999526F,
+ 0.9999999576F, 0.9999999622F, 0.9999999664F, 0.9999999702F,
+ 0.9999999737F, 0.9999999769F, 0.9999999798F, 0.9999999824F,
+ 0.9999999847F, 0.9999999868F, 0.9999999887F, 0.9999999904F,
+ 0.9999999919F, 0.9999999932F, 0.9999999943F, 0.9999999953F,
+ 0.9999999961F, 0.9999999969F, 0.9999999975F, 0.9999999980F,
+ 0.9999999985F, 0.9999999988F, 0.9999999991F, 0.9999999993F,
+ 0.9999999995F, 0.9999999997F, 0.9999999998F, 0.9999999999F,
+ 0.9999999999F, 1.0000000000F, 1.0000000000F, 1.0000000000F,
+ 1.0000000000F, 1.0000000000F, 1.0000000000F, 1.0000000000F,
+};
+
+static const float *const vwin[8] = {
+ vwin64,
+ vwin128,
+ vwin256,
+ vwin512,
+ vwin1024,
+ vwin2048,
+ vwin4096,
+ vwin8192,
+};
+
+const float *_vorbis_window_get(int n){
+ return vwin[n];
+}
+
+void _vorbis_apply_window(float *d,int *winno,long *blocksizes,
+ int lW,int W,int nW){
+ lW=(W?lW:0);
+ nW=(W?nW:0);
+
+ {
+ const float *windowLW=vwin[winno[lW]];
+ const float *windowNW=vwin[winno[nW]];
+
+ long n=blocksizes[W];
+ long ln=blocksizes[lW];
+ long rn=blocksizes[nW];
+
+ long leftbegin=n/4-ln/4;
+ long leftend=leftbegin+ln/2;
+
+ long rightbegin=n/2+n/4-rn/4;
+ long rightend=rightbegin+rn/2;
+
+ int i,p;
+
+ for(i=0;i<leftbegin;i++)
+ d[i]=0.f;
+
+ for(p=0;i<leftend;i++,p++)
+ d[i]*=windowLW[p];
+
+ for(i=rightbegin,p=rn/2-1;i<rightend;i++,p--)
+ d[i]*=windowNW[p];
+
+ for(;i<n;i++)
+ d[i]=0.f;
+ }
+}
--- /dev/null
+/********************************************************************
+ * *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
+ * *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2007 *
+ * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * *
+ ********************************************************************
+
+ function: window functions
+ last mod: $Id: window.h 13293 2007-07-24 00:09:47Z xiphmont $
+
+ ********************************************************************/
+
+#ifndef _V_WINDOW_
+#define _V_WINDOW_
+
+extern float *_vorbis_window_get(int n);
+extern void _vorbis_apply_window(float *d,int *winno,long *blocksizes,
+ int lW,int W,int nW);
+
+
+#endif
--- /dev/null
+ (C) 1995-2010 Jean-loup Gailly and Mark Adler
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any damages
+ arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+
+ Jean-loup Gailly Mark Adler
+ jloup@gzip.org madler@alumni.caltech.edu
--- /dev/null
+obj = adler32.o compress.o crc32.o deflate.o gzio.o infback.o inffast.o \
+ inflate.o inftrees.o trees.o uncompr.o zutil.o
+
+liba = ../libz.a
+
+CFLAGS = -O3
+
+$(liba): $(obj)
+ $(AR) rcs $@ $(obj)
+
+.PHONY: clean
+clean:
+ rm -f $(obj) $(liba)
--- /dev/null
+/* adler32.c -- compute the Adler-32 checksum of a data stream
+ * Copyright (C) 1995-2004 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#define ZLIB_INTERNAL
+#include "zlib.h"
+
+#define BASE 65521UL /* largest prime smaller than 65536 */
+#define NMAX 5552
+/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
+
+#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;}
+#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1);
+#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2);
+#define DO8(buf,i) DO4(buf,i); DO4(buf,i+4);
+#define DO16(buf) DO8(buf,0); DO8(buf,8);
+
+/* use NO_DIVIDE if your processor does not do division in hardware */
+#ifdef NO_DIVIDE
+# define MOD(a) \
+ do { \
+ if (a >= (BASE << 16)) a -= (BASE << 16); \
+ if (a >= (BASE << 15)) a -= (BASE << 15); \
+ if (a >= (BASE << 14)) a -= (BASE << 14); \
+ if (a >= (BASE << 13)) a -= (BASE << 13); \
+ if (a >= (BASE << 12)) a -= (BASE << 12); \
+ if (a >= (BASE << 11)) a -= (BASE << 11); \
+ if (a >= (BASE << 10)) a -= (BASE << 10); \
+ if (a >= (BASE << 9)) a -= (BASE << 9); \
+ if (a >= (BASE << 8)) a -= (BASE << 8); \
+ if (a >= (BASE << 7)) a -= (BASE << 7); \
+ if (a >= (BASE << 6)) a -= (BASE << 6); \
+ if (a >= (BASE << 5)) a -= (BASE << 5); \
+ if (a >= (BASE << 4)) a -= (BASE << 4); \
+ if (a >= (BASE << 3)) a -= (BASE << 3); \
+ if (a >= (BASE << 2)) a -= (BASE << 2); \
+ if (a >= (BASE << 1)) a -= (BASE << 1); \
+ if (a >= BASE) a -= BASE; \
+ } while (0)
+# define MOD4(a) \
+ do { \
+ if (a >= (BASE << 4)) a -= (BASE << 4); \
+ if (a >= (BASE << 3)) a -= (BASE << 3); \
+ if (a >= (BASE << 2)) a -= (BASE << 2); \
+ if (a >= (BASE << 1)) a -= (BASE << 1); \
+ if (a >= BASE) a -= BASE; \
+ } while (0)
+#else
+# define MOD(a) a %= BASE
+# define MOD4(a) a %= BASE
+#endif
+
+/* ========================================================================= */
+uLong ZEXPORT adler32(adler, buf, len)
+ uLong adler;
+ const Bytef *buf;
+ uInt len;
+{
+ unsigned long sum2;
+ unsigned n;
+
+ /* split Adler-32 into component sums */
+ sum2 = (adler >> 16) & 0xffff;
+ adler &= 0xffff;
+
+ /* in case user likes doing a byte at a time, keep it fast */
+ if (len == 1) {
+ adler += buf[0];
+ if (adler >= BASE)
+ adler -= BASE;
+ sum2 += adler;
+ if (sum2 >= BASE)
+ sum2 -= BASE;
+ return adler | (sum2 << 16);
+ }
+
+ /* initial Adler-32 value (deferred check for len == 1 speed) */
+ if (buf == Z_NULL)
+ return 1L;
+
+ /* in case short lengths are provided, keep it somewhat fast */
+ if (len < 16) {
+ while (len--) {
+ adler += *buf++;
+ sum2 += adler;
+ }
+ if (adler >= BASE)
+ adler -= BASE;
+ MOD4(sum2); /* only added so many BASE's */
+ return adler | (sum2 << 16);
+ }
+
+ /* do length NMAX blocks -- requires just one modulo operation */
+ while (len >= NMAX) {
+ len -= NMAX;
+ n = NMAX / 16; /* NMAX is divisible by 16 */
+ do {
+ DO16(buf); /* 16 sums unrolled */
+ buf += 16;
+ } while (--n);
+ MOD(adler);
+ MOD(sum2);
+ }
+
+ /* do remaining bytes (less than NMAX, still just one modulo) */
+ if (len) { /* avoid modulos if none remaining */
+ while (len >= 16) {
+ len -= 16;
+ DO16(buf);
+ buf += 16;
+ }
+ while (len--) {
+ adler += *buf++;
+ sum2 += adler;
+ }
+ MOD(adler);
+ MOD(sum2);
+ }
+
+ /* return recombined sums */
+ return adler | (sum2 << 16);
+}
+
+/* ========================================================================= */
+uLong ZEXPORT adler32_combine(adler1, adler2, len2)
+ uLong adler1;
+ uLong adler2;
+ z_off_t len2;
+{
+ unsigned long sum1;
+ unsigned long sum2;
+ unsigned rem;
+
+ /* the derivation of this formula is left as an exercise for the reader */
+ rem = (unsigned)(len2 % BASE);
+ sum1 = adler1 & 0xffff;
+ sum2 = rem * sum1;
+ MOD(sum2);
+ sum1 += (adler2 & 0xffff) + BASE - 1;
+ sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
+ if (sum1 > BASE) sum1 -= BASE;
+ if (sum1 > BASE) sum1 -= BASE;
+ if (sum2 > (BASE << 1)) sum2 -= (BASE << 1);
+ if (sum2 > BASE) sum2 -= BASE;
+ return sum1 | (sum2 << 16);
+}
--- /dev/null
+/* compress.c -- compress a memory buffer
+ * Copyright (C) 1995-2003 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#define ZLIB_INTERNAL
+#include "zlib.h"
+
+/* ===========================================================================
+ Compresses the source buffer into the destination buffer. The level
+ parameter has the same meaning as in deflateInit. sourceLen is the byte
+ length of the source buffer. Upon entry, destLen is the total size of the
+ destination buffer, which must be at least 0.1% larger than sourceLen plus
+ 12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
+
+ compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+ memory, Z_BUF_ERROR if there was not enough room in the output buffer,
+ Z_STREAM_ERROR if the level parameter is invalid.
+*/
+int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
+ Bytef *dest;
+ uLongf *destLen;
+ const Bytef *source;
+ uLong sourceLen;
+ int level;
+{
+ z_stream stream;
+ int err;
+
+ stream.next_in = (Bytef*)source;
+ stream.avail_in = (uInt)sourceLen;
+#ifdef MAXSEG_64K
+ /* Check for source > 64K on 16-bit machine: */
+ if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;
+#endif
+ stream.next_out = dest;
+ stream.avail_out = (uInt)*destLen;
+ if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;
+
+ stream.zalloc = (alloc_func)0;
+ stream.zfree = (free_func)0;
+ stream.opaque = (voidpf)0;
+
+ err = deflateInit(&stream, level);
+ if (err != Z_OK) return err;
+
+ err = deflate(&stream, Z_FINISH);
+ if (err != Z_STREAM_END) {
+ deflateEnd(&stream);
+ return err == Z_OK ? Z_BUF_ERROR : err;
+ }
+ *destLen = stream.total_out;
+
+ err = deflateEnd(&stream);
+ return err;
+}
+
+/* ===========================================================================
+ */
+int ZEXPORT compress (dest, destLen, source, sourceLen)
+ Bytef *dest;
+ uLongf *destLen;
+ const Bytef *source;
+ uLong sourceLen;
+{
+ return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION);
+}
+
+/* ===========================================================================
+ If the default memLevel or windowBits for deflateInit() is changed, then
+ this function needs to be updated.
+ */
+uLong ZEXPORT compressBound (sourceLen)
+ uLong sourceLen;
+{
+ return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + 11;
+}
--- /dev/null
+/* crc32.c -- compute the CRC-32 of a data stream
+ * Copyright (C) 1995-2005 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ *
+ * Thanks to Rodney Brown <rbrown64@csc.com.au> for his contribution of faster
+ * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing
+ * tables for updating the shift register in one step with three exclusive-ors
+ * instead of four steps with four exclusive-ors. This results in about a
+ * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3.
+ */
+
+/* @(#) $Id$ */
+
+/*
+ Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore
+ protection on the static variables used to control the first-use generation
+ of the crc tables. Therefore, if you #define DYNAMIC_CRC_TABLE, you should
+ first call get_crc_table() to initialize the tables before allowing more than
+ one thread to use crc32().
+ */
+
+#ifdef MAKECRCH
+# include <stdio.h>
+# ifndef DYNAMIC_CRC_TABLE
+# define DYNAMIC_CRC_TABLE
+# endif /* !DYNAMIC_CRC_TABLE */
+#endif /* MAKECRCH */
+
+#include "zutil.h" /* for STDC and FAR definitions */
+
+#define local static
+
+/* Find a four-byte integer type for crc32_little() and crc32_big(). */
+#ifndef NOBYFOUR
+# ifdef STDC /* need ANSI C limits.h to determine sizes */
+# include <limits.h>
+# define BYFOUR
+# if (UINT_MAX == 0xffffffffUL)
+ typedef unsigned int u4;
+# else
+# if (ULONG_MAX == 0xffffffffUL)
+ typedef unsigned long u4;
+# else
+# if (USHRT_MAX == 0xffffffffUL)
+ typedef unsigned short u4;
+# else
+# undef BYFOUR /* can't find a four-byte integer type! */
+# endif
+# endif
+# endif
+# endif /* STDC */
+#endif /* !NOBYFOUR */
+
+/* Definitions for doing the crc four data bytes at a time. */
+#ifdef BYFOUR
+# define REV(w) (((w)>>24)+(((w)>>8)&0xff00)+ \
+ (((w)&0xff00)<<8)+(((w)&0xff)<<24))
+ local unsigned long crc32_little OF((unsigned long,
+ const unsigned char FAR *, unsigned));
+ local unsigned long crc32_big OF((unsigned long,
+ const unsigned char FAR *, unsigned));
+# define TBLS 8
+#else
+# define TBLS 1
+#endif /* BYFOUR */
+
+/* Local functions for crc concatenation */
+local unsigned long gf2_matrix_times OF((unsigned long *mat,
+ unsigned long vec));
+local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat));
+
+#ifdef DYNAMIC_CRC_TABLE
+
+local volatile int crc_table_empty = 1;
+local unsigned long FAR crc_table[TBLS][256];
+local void make_crc_table OF((void));
+#ifdef MAKECRCH
+ local void write_table OF((FILE *, const unsigned long FAR *));
+#endif /* MAKECRCH */
+/*
+ Generate tables for a byte-wise 32-bit CRC calculation on the polynomial:
+ x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
+
+ Polynomials over GF(2) are represented in binary, one bit per coefficient,
+ with the lowest powers in the most significant bit. Then adding polynomials
+ is just exclusive-or, and multiplying a polynomial by x is a right shift by
+ one. If we call the above polynomial p, and represent a byte as the
+ polynomial q, also with the lowest power in the most significant bit (so the
+ byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,
+ where a mod b means the remainder after dividing a by b.
+
+ This calculation is done using the shift-register method of multiplying and
+ taking the remainder. The register is initialized to zero, and for each
+ incoming bit, x^32 is added mod p to the register if the bit is a one (where
+ x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by
+ x (which is shifting right by one and adding x^32 mod p if the bit shifted
+ out is a one). We start with the highest power (least significant bit) of
+ q and repeat for all eight bits of q.
+
+ The first table is simply the CRC of all possible eight bit values. This is
+ all the information needed to generate CRCs on data a byte at a time for all
+ combinations of CRC register values and incoming bytes. The remaining tables
+ allow for word-at-a-time CRC calculation for both big-endian and little-
+ endian machines, where a word is four bytes.
+*/
+local void make_crc_table()
+{
+ unsigned long c;
+ int n, k;
+ unsigned long poly; /* polynomial exclusive-or pattern */
+ /* terms of polynomial defining this crc (except x^32): */
+ static volatile int first = 1; /* flag to limit concurrent making */
+ static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
+
+ /* See if another task is already doing this (not thread-safe, but better
+ than nothing -- significantly reduces duration of vulnerability in
+ case the advice about DYNAMIC_CRC_TABLE is ignored) */
+ if (first) {
+ first = 0;
+
+ /* make exclusive-or pattern from polynomial (0xedb88320UL) */
+ poly = 0UL;
+ for (n = 0; n < sizeof(p)/sizeof(unsigned char); n++)
+ poly |= 1UL << (31 - p[n]);
+
+ /* generate a crc for every 8-bit value */
+ for (n = 0; n < 256; n++) {
+ c = (unsigned long)n;
+ for (k = 0; k < 8; k++)
+ c = c & 1 ? poly ^ (c >> 1) : c >> 1;
+ crc_table[0][n] = c;
+ }
+
+#ifdef BYFOUR
+ /* generate crc for each value followed by one, two, and three zeros,
+ and then the byte reversal of those as well as the first table */
+ for (n = 0; n < 256; n++) {
+ c = crc_table[0][n];
+ crc_table[4][n] = REV(c);
+ for (k = 1; k < 4; k++) {
+ c = crc_table[0][c & 0xff] ^ (c >> 8);
+ crc_table[k][n] = c;
+ crc_table[k + 4][n] = REV(c);
+ }
+ }
+#endif /* BYFOUR */
+
+ crc_table_empty = 0;
+ }
+ else { /* not first */
+ /* wait for the other guy to finish (not efficient, but rare) */
+ while (crc_table_empty)
+ ;
+ }
+
+#ifdef MAKECRCH
+ /* write out CRC tables to crc32.h */
+ {
+ FILE *out;
+
+ out = fopen("crc32.h", "w");
+ if (out == NULL) return;
+ fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n");
+ fprintf(out, " * Generated automatically by crc32.c\n */\n\n");
+ fprintf(out, "local const unsigned long FAR ");
+ fprintf(out, "crc_table[TBLS][256] =\n{\n {\n");
+ write_table(out, crc_table[0]);
+# ifdef BYFOUR
+ fprintf(out, "#ifdef BYFOUR\n");
+ for (k = 1; k < 8; k++) {
+ fprintf(out, " },\n {\n");
+ write_table(out, crc_table[k]);
+ }
+ fprintf(out, "#endif\n");
+# endif /* BYFOUR */
+ fprintf(out, " }\n};\n");
+ fclose(out);
+ }
+#endif /* MAKECRCH */
+}
+
+#ifdef MAKECRCH
+local void write_table(out, table)
+ FILE *out;
+ const unsigned long FAR *table;
+{
+ int n;
+
+ for (n = 0; n < 256; n++)
+ fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : " ", table[n],
+ n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", "));
+}
+#endif /* MAKECRCH */
+
+#else /* !DYNAMIC_CRC_TABLE */
+/* ========================================================================
+ * Tables of CRC-32s of all single-byte values, made by make_crc_table().
+ */
+#include "crc32.h"
+#endif /* DYNAMIC_CRC_TABLE */
+
+/* =========================================================================
+ * This function can be used by asm versions of crc32()
+ */
+const unsigned long FAR * ZEXPORT get_crc_table()
+{
+#ifdef DYNAMIC_CRC_TABLE
+ if (crc_table_empty)
+ make_crc_table();
+#endif /* DYNAMIC_CRC_TABLE */
+ return (const unsigned long FAR *)crc_table;
+}
+
+/* ========================================================================= */
+#define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8)
+#define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1
+
+/* ========================================================================= */
+unsigned long ZEXPORT crc32(crc, buf, len)
+ unsigned long crc;
+ const unsigned char FAR *buf;
+ unsigned len;
+{
+ if (buf == Z_NULL) return 0UL;
+
+#ifdef DYNAMIC_CRC_TABLE
+ if (crc_table_empty)
+ make_crc_table();
+#endif /* DYNAMIC_CRC_TABLE */
+
+#ifdef BYFOUR
+ if (sizeof(void *) == sizeof(ptrdiff_t)) {
+ u4 endian;
+
+ endian = 1;
+ if (*((unsigned char *)(&endian)))
+ return crc32_little(crc, buf, len);
+ else
+ return crc32_big(crc, buf, len);
+ }
+#endif /* BYFOUR */
+ crc = crc ^ 0xffffffffUL;
+ while (len >= 8) {
+ DO8;
+ len -= 8;
+ }
+ if (len) do {
+ DO1;
+ } while (--len);
+ return crc ^ 0xffffffffUL;
+}
+
+#ifdef BYFOUR
+
+/* ========================================================================= */
+#define DOLIT4 c ^= *buf4++; \
+ c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \
+ crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24]
+#define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4
+
+/* ========================================================================= */
+local unsigned long crc32_little(crc, buf, len)
+ unsigned long crc;
+ const unsigned char FAR *buf;
+ unsigned len;
+{
+ register u4 c;
+ register const u4 FAR *buf4;
+
+ c = (u4)crc;
+ c = ~c;
+ while (len && ((ptrdiff_t)buf & 3)) {
+ c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
+ len--;
+ }
+
+ buf4 = (const u4 FAR *)(const void FAR *)buf;
+ while (len >= 32) {
+ DOLIT32;
+ len -= 32;
+ }
+ while (len >= 4) {
+ DOLIT4;
+ len -= 4;
+ }
+ buf = (const unsigned char FAR *)buf4;
+
+ if (len) do {
+ c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
+ } while (--len);
+ c = ~c;
+ return (unsigned long)c;
+}
+
+/* ========================================================================= */
+#define DOBIG4 c ^= *++buf4; \
+ c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \
+ crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24]
+#define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4
+
+/* ========================================================================= */
+local unsigned long crc32_big(crc, buf, len)
+ unsigned long crc;
+ const unsigned char FAR *buf;
+ unsigned len;
+{
+ register u4 c;
+ register const u4 FAR *buf4;
+
+ c = REV((u4)crc);
+ c = ~c;
+ while (len && ((ptrdiff_t)buf & 3)) {
+ c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
+ len--;
+ }
+
+ buf4 = (const u4 FAR *)(const void FAR *)buf;
+ buf4--;
+ while (len >= 32) {
+ DOBIG32;
+ len -= 32;
+ }
+ while (len >= 4) {
+ DOBIG4;
+ len -= 4;
+ }
+ buf4++;
+ buf = (const unsigned char FAR *)buf4;
+
+ if (len) do {
+ c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
+ } while (--len);
+ c = ~c;
+ return (unsigned long)(REV(c));
+}
+
+#endif /* BYFOUR */
+
+#define GF2_DIM 32 /* dimension of GF(2) vectors (length of CRC) */
+
+/* ========================================================================= */
+local unsigned long gf2_matrix_times(mat, vec)
+ unsigned long *mat;
+ unsigned long vec;
+{
+ unsigned long sum;
+
+ sum = 0;
+ while (vec) {
+ if (vec & 1)
+ sum ^= *mat;
+ vec >>= 1;
+ mat++;
+ }
+ return sum;
+}
+
+/* ========================================================================= */
+local void gf2_matrix_square(square, mat)
+ unsigned long *square;
+ unsigned long *mat;
+{
+ int n;
+
+ for (n = 0; n < GF2_DIM; n++)
+ square[n] = gf2_matrix_times(mat, mat[n]);
+}
+
+/* ========================================================================= */
+uLong ZEXPORT crc32_combine(crc1, crc2, len2)
+ uLong crc1;
+ uLong crc2;
+ z_off_t len2;
+{
+ int n;
+ unsigned long row;
+ unsigned long even[GF2_DIM]; /* even-power-of-two zeros operator */
+ unsigned long odd[GF2_DIM]; /* odd-power-of-two zeros operator */
+
+ /* degenerate case */
+ if (len2 == 0)
+ return crc1;
+
+ /* put operator for one zero bit in odd */
+ odd[0] = 0xedb88320L; /* CRC-32 polynomial */
+ row = 1;
+ for (n = 1; n < GF2_DIM; n++) {
+ odd[n] = row;
+ row <<= 1;
+ }
+
+ /* put operator for two zero bits in even */
+ gf2_matrix_square(even, odd);
+
+ /* put operator for four zero bits in odd */
+ gf2_matrix_square(odd, even);
+
+ /* apply len2 zeros to crc1 (first square will put the operator for one
+ zero byte, eight zero bits, in even) */
+ do {
+ /* apply zeros operator for this bit of len2 */
+ gf2_matrix_square(even, odd);
+ if (len2 & 1)
+ crc1 = gf2_matrix_times(even, crc1);
+ len2 >>= 1;
+
+ /* if no more bits set, then done */
+ if (len2 == 0)
+ break;
+
+ /* another iteration of the loop with odd and even swapped */
+ gf2_matrix_square(odd, even);
+ if (len2 & 1)
+ crc1 = gf2_matrix_times(odd, crc1);
+ len2 >>= 1;
+
+ /* if no more bits set, then done */
+ } while (len2 != 0);
+
+ /* return combined crc */
+ crc1 ^= crc2;
+ return crc1;
+}
--- /dev/null
+/* crc32.h -- tables for rapid CRC calculation
+ * Generated automatically by crc32.c
+ */
+
+local const unsigned long FAR crc_table[TBLS][256] =
+{
+ {
+ 0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
+ 0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
+ 0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
+ 0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
+ 0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
+ 0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
+ 0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
+ 0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
+ 0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
+ 0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
+ 0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
+ 0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
+ 0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
+ 0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
+ 0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
+ 0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
+ 0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
+ 0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
+ 0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
+ 0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
+ 0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
+ 0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
+ 0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
+ 0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
+ 0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
+ 0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
+ 0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
+ 0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
+ 0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
+ 0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
+ 0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
+ 0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
+ 0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
+ 0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
+ 0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
+ 0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
+ 0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
+ 0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
+ 0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
+ 0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
+ 0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
+ 0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
+ 0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
+ 0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
+ 0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
+ 0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
+ 0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
+ 0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
+ 0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
+ 0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
+ 0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
+ 0x2d02ef8dUL
+#ifdef BYFOUR
+ },
+ {
+ 0x00000000UL, 0x191b3141UL, 0x32366282UL, 0x2b2d53c3UL, 0x646cc504UL,
+ 0x7d77f445UL, 0x565aa786UL, 0x4f4196c7UL, 0xc8d98a08UL, 0xd1c2bb49UL,
+ 0xfaefe88aUL, 0xe3f4d9cbUL, 0xacb54f0cUL, 0xb5ae7e4dUL, 0x9e832d8eUL,
+ 0x87981ccfUL, 0x4ac21251UL, 0x53d92310UL, 0x78f470d3UL, 0x61ef4192UL,
+ 0x2eaed755UL, 0x37b5e614UL, 0x1c98b5d7UL, 0x05838496UL, 0x821b9859UL,
+ 0x9b00a918UL, 0xb02dfadbUL, 0xa936cb9aUL, 0xe6775d5dUL, 0xff6c6c1cUL,
+ 0xd4413fdfUL, 0xcd5a0e9eUL, 0x958424a2UL, 0x8c9f15e3UL, 0xa7b24620UL,
+ 0xbea97761UL, 0xf1e8e1a6UL, 0xe8f3d0e7UL, 0xc3de8324UL, 0xdac5b265UL,
+ 0x5d5daeaaUL, 0x44469febUL, 0x6f6bcc28UL, 0x7670fd69UL, 0x39316baeUL,
+ 0x202a5aefUL, 0x0b07092cUL, 0x121c386dUL, 0xdf4636f3UL, 0xc65d07b2UL,
+ 0xed705471UL, 0xf46b6530UL, 0xbb2af3f7UL, 0xa231c2b6UL, 0x891c9175UL,
+ 0x9007a034UL, 0x179fbcfbUL, 0x0e848dbaUL, 0x25a9de79UL, 0x3cb2ef38UL,
+ 0x73f379ffUL, 0x6ae848beUL, 0x41c51b7dUL, 0x58de2a3cUL, 0xf0794f05UL,
+ 0xe9627e44UL, 0xc24f2d87UL, 0xdb541cc6UL, 0x94158a01UL, 0x8d0ebb40UL,
+ 0xa623e883UL, 0xbf38d9c2UL, 0x38a0c50dUL, 0x21bbf44cUL, 0x0a96a78fUL,
+ 0x138d96ceUL, 0x5ccc0009UL, 0x45d73148UL, 0x6efa628bUL, 0x77e153caUL,
+ 0xbabb5d54UL, 0xa3a06c15UL, 0x888d3fd6UL, 0x91960e97UL, 0xded79850UL,
+ 0xc7cca911UL, 0xece1fad2UL, 0xf5facb93UL, 0x7262d75cUL, 0x6b79e61dUL,
+ 0x4054b5deUL, 0x594f849fUL, 0x160e1258UL, 0x0f152319UL, 0x243870daUL,
+ 0x3d23419bUL, 0x65fd6ba7UL, 0x7ce65ae6UL, 0x57cb0925UL, 0x4ed03864UL,
+ 0x0191aea3UL, 0x188a9fe2UL, 0x33a7cc21UL, 0x2abcfd60UL, 0xad24e1afUL,
+ 0xb43fd0eeUL, 0x9f12832dUL, 0x8609b26cUL, 0xc94824abUL, 0xd05315eaUL,
+ 0xfb7e4629UL, 0xe2657768UL, 0x2f3f79f6UL, 0x362448b7UL, 0x1d091b74UL,
+ 0x04122a35UL, 0x4b53bcf2UL, 0x52488db3UL, 0x7965de70UL, 0x607eef31UL,
+ 0xe7e6f3feUL, 0xfefdc2bfUL, 0xd5d0917cUL, 0xcccba03dUL, 0x838a36faUL,
+ 0x9a9107bbUL, 0xb1bc5478UL, 0xa8a76539UL, 0x3b83984bUL, 0x2298a90aUL,
+ 0x09b5fac9UL, 0x10aecb88UL, 0x5fef5d4fUL, 0x46f46c0eUL, 0x6dd93fcdUL,
+ 0x74c20e8cUL, 0xf35a1243UL, 0xea412302UL, 0xc16c70c1UL, 0xd8774180UL,
+ 0x9736d747UL, 0x8e2de606UL, 0xa500b5c5UL, 0xbc1b8484UL, 0x71418a1aUL,
+ 0x685abb5bUL, 0x4377e898UL, 0x5a6cd9d9UL, 0x152d4f1eUL, 0x0c367e5fUL,
+ 0x271b2d9cUL, 0x3e001cddUL, 0xb9980012UL, 0xa0833153UL, 0x8bae6290UL,
+ 0x92b553d1UL, 0xddf4c516UL, 0xc4eff457UL, 0xefc2a794UL, 0xf6d996d5UL,
+ 0xae07bce9UL, 0xb71c8da8UL, 0x9c31de6bUL, 0x852aef2aUL, 0xca6b79edUL,
+ 0xd37048acUL, 0xf85d1b6fUL, 0xe1462a2eUL, 0x66de36e1UL, 0x7fc507a0UL,
+ 0x54e85463UL, 0x4df36522UL, 0x02b2f3e5UL, 0x1ba9c2a4UL, 0x30849167UL,
+ 0x299fa026UL, 0xe4c5aeb8UL, 0xfdde9ff9UL, 0xd6f3cc3aUL, 0xcfe8fd7bUL,
+ 0x80a96bbcUL, 0x99b25afdUL, 0xb29f093eUL, 0xab84387fUL, 0x2c1c24b0UL,
+ 0x350715f1UL, 0x1e2a4632UL, 0x07317773UL, 0x4870e1b4UL, 0x516bd0f5UL,
+ 0x7a468336UL, 0x635db277UL, 0xcbfad74eUL, 0xd2e1e60fUL, 0xf9ccb5ccUL,
+ 0xe0d7848dUL, 0xaf96124aUL, 0xb68d230bUL, 0x9da070c8UL, 0x84bb4189UL,
+ 0x03235d46UL, 0x1a386c07UL, 0x31153fc4UL, 0x280e0e85UL, 0x674f9842UL,
+ 0x7e54a903UL, 0x5579fac0UL, 0x4c62cb81UL, 0x8138c51fUL, 0x9823f45eUL,
+ 0xb30ea79dUL, 0xaa1596dcUL, 0xe554001bUL, 0xfc4f315aUL, 0xd7626299UL,
+ 0xce7953d8UL, 0x49e14f17UL, 0x50fa7e56UL, 0x7bd72d95UL, 0x62cc1cd4UL,
+ 0x2d8d8a13UL, 0x3496bb52UL, 0x1fbbe891UL, 0x06a0d9d0UL, 0x5e7ef3ecUL,
+ 0x4765c2adUL, 0x6c48916eUL, 0x7553a02fUL, 0x3a1236e8UL, 0x230907a9UL,
+ 0x0824546aUL, 0x113f652bUL, 0x96a779e4UL, 0x8fbc48a5UL, 0xa4911b66UL,
+ 0xbd8a2a27UL, 0xf2cbbce0UL, 0xebd08da1UL, 0xc0fdde62UL, 0xd9e6ef23UL,
+ 0x14bce1bdUL, 0x0da7d0fcUL, 0x268a833fUL, 0x3f91b27eUL, 0x70d024b9UL,
+ 0x69cb15f8UL, 0x42e6463bUL, 0x5bfd777aUL, 0xdc656bb5UL, 0xc57e5af4UL,
+ 0xee530937UL, 0xf7483876UL, 0xb809aeb1UL, 0xa1129ff0UL, 0x8a3fcc33UL,
+ 0x9324fd72UL
+ },
+ {
+ 0x00000000UL, 0x01c26a37UL, 0x0384d46eUL, 0x0246be59UL, 0x0709a8dcUL,
+ 0x06cbc2ebUL, 0x048d7cb2UL, 0x054f1685UL, 0x0e1351b8UL, 0x0fd13b8fUL,
+ 0x0d9785d6UL, 0x0c55efe1UL, 0x091af964UL, 0x08d89353UL, 0x0a9e2d0aUL,
+ 0x0b5c473dUL, 0x1c26a370UL, 0x1de4c947UL, 0x1fa2771eUL, 0x1e601d29UL,
+ 0x1b2f0bacUL, 0x1aed619bUL, 0x18abdfc2UL, 0x1969b5f5UL, 0x1235f2c8UL,
+ 0x13f798ffUL, 0x11b126a6UL, 0x10734c91UL, 0x153c5a14UL, 0x14fe3023UL,
+ 0x16b88e7aUL, 0x177ae44dUL, 0x384d46e0UL, 0x398f2cd7UL, 0x3bc9928eUL,
+ 0x3a0bf8b9UL, 0x3f44ee3cUL, 0x3e86840bUL, 0x3cc03a52UL, 0x3d025065UL,
+ 0x365e1758UL, 0x379c7d6fUL, 0x35dac336UL, 0x3418a901UL, 0x3157bf84UL,
+ 0x3095d5b3UL, 0x32d36beaUL, 0x331101ddUL, 0x246be590UL, 0x25a98fa7UL,
+ 0x27ef31feUL, 0x262d5bc9UL, 0x23624d4cUL, 0x22a0277bUL, 0x20e69922UL,
+ 0x2124f315UL, 0x2a78b428UL, 0x2bbade1fUL, 0x29fc6046UL, 0x283e0a71UL,
+ 0x2d711cf4UL, 0x2cb376c3UL, 0x2ef5c89aUL, 0x2f37a2adUL, 0x709a8dc0UL,
+ 0x7158e7f7UL, 0x731e59aeUL, 0x72dc3399UL, 0x7793251cUL, 0x76514f2bUL,
+ 0x7417f172UL, 0x75d59b45UL, 0x7e89dc78UL, 0x7f4bb64fUL, 0x7d0d0816UL,
+ 0x7ccf6221UL, 0x798074a4UL, 0x78421e93UL, 0x7a04a0caUL, 0x7bc6cafdUL,
+ 0x6cbc2eb0UL, 0x6d7e4487UL, 0x6f38fadeUL, 0x6efa90e9UL, 0x6bb5866cUL,
+ 0x6a77ec5bUL, 0x68315202UL, 0x69f33835UL, 0x62af7f08UL, 0x636d153fUL,
+ 0x612bab66UL, 0x60e9c151UL, 0x65a6d7d4UL, 0x6464bde3UL, 0x662203baUL,
+ 0x67e0698dUL, 0x48d7cb20UL, 0x4915a117UL, 0x4b531f4eUL, 0x4a917579UL,
+ 0x4fde63fcUL, 0x4e1c09cbUL, 0x4c5ab792UL, 0x4d98dda5UL, 0x46c49a98UL,
+ 0x4706f0afUL, 0x45404ef6UL, 0x448224c1UL, 0x41cd3244UL, 0x400f5873UL,
+ 0x4249e62aUL, 0x438b8c1dUL, 0x54f16850UL, 0x55330267UL, 0x5775bc3eUL,
+ 0x56b7d609UL, 0x53f8c08cUL, 0x523aaabbUL, 0x507c14e2UL, 0x51be7ed5UL,
+ 0x5ae239e8UL, 0x5b2053dfUL, 0x5966ed86UL, 0x58a487b1UL, 0x5deb9134UL,
+ 0x5c29fb03UL, 0x5e6f455aUL, 0x5fad2f6dUL, 0xe1351b80UL, 0xe0f771b7UL,
+ 0xe2b1cfeeUL, 0xe373a5d9UL, 0xe63cb35cUL, 0xe7fed96bUL, 0xe5b86732UL,
+ 0xe47a0d05UL, 0xef264a38UL, 0xeee4200fUL, 0xeca29e56UL, 0xed60f461UL,
+ 0xe82fe2e4UL, 0xe9ed88d3UL, 0xebab368aUL, 0xea695cbdUL, 0xfd13b8f0UL,
+ 0xfcd1d2c7UL, 0xfe976c9eUL, 0xff5506a9UL, 0xfa1a102cUL, 0xfbd87a1bUL,
+ 0xf99ec442UL, 0xf85cae75UL, 0xf300e948UL, 0xf2c2837fUL, 0xf0843d26UL,
+ 0xf1465711UL, 0xf4094194UL, 0xf5cb2ba3UL, 0xf78d95faUL, 0xf64fffcdUL,
+ 0xd9785d60UL, 0xd8ba3757UL, 0xdafc890eUL, 0xdb3ee339UL, 0xde71f5bcUL,
+ 0xdfb39f8bUL, 0xddf521d2UL, 0xdc374be5UL, 0xd76b0cd8UL, 0xd6a966efUL,
+ 0xd4efd8b6UL, 0xd52db281UL, 0xd062a404UL, 0xd1a0ce33UL, 0xd3e6706aUL,
+ 0xd2241a5dUL, 0xc55efe10UL, 0xc49c9427UL, 0xc6da2a7eUL, 0xc7184049UL,
+ 0xc25756ccUL, 0xc3953cfbUL, 0xc1d382a2UL, 0xc011e895UL, 0xcb4dafa8UL,
+ 0xca8fc59fUL, 0xc8c97bc6UL, 0xc90b11f1UL, 0xcc440774UL, 0xcd866d43UL,
+ 0xcfc0d31aUL, 0xce02b92dUL, 0x91af9640UL, 0x906dfc77UL, 0x922b422eUL,
+ 0x93e92819UL, 0x96a63e9cUL, 0x976454abUL, 0x9522eaf2UL, 0x94e080c5UL,
+ 0x9fbcc7f8UL, 0x9e7eadcfUL, 0x9c381396UL, 0x9dfa79a1UL, 0x98b56f24UL,
+ 0x99770513UL, 0x9b31bb4aUL, 0x9af3d17dUL, 0x8d893530UL, 0x8c4b5f07UL,
+ 0x8e0de15eUL, 0x8fcf8b69UL, 0x8a809decUL, 0x8b42f7dbUL, 0x89044982UL,
+ 0x88c623b5UL, 0x839a6488UL, 0x82580ebfUL, 0x801eb0e6UL, 0x81dcdad1UL,
+ 0x8493cc54UL, 0x8551a663UL, 0x8717183aUL, 0x86d5720dUL, 0xa9e2d0a0UL,
+ 0xa820ba97UL, 0xaa6604ceUL, 0xaba46ef9UL, 0xaeeb787cUL, 0xaf29124bUL,
+ 0xad6fac12UL, 0xacadc625UL, 0xa7f18118UL, 0xa633eb2fUL, 0xa4755576UL,
+ 0xa5b73f41UL, 0xa0f829c4UL, 0xa13a43f3UL, 0xa37cfdaaUL, 0xa2be979dUL,
+ 0xb5c473d0UL, 0xb40619e7UL, 0xb640a7beUL, 0xb782cd89UL, 0xb2cddb0cUL,
+ 0xb30fb13bUL, 0xb1490f62UL, 0xb08b6555UL, 0xbbd72268UL, 0xba15485fUL,
+ 0xb853f606UL, 0xb9919c31UL, 0xbcde8ab4UL, 0xbd1ce083UL, 0xbf5a5edaUL,
+ 0xbe9834edUL
+ },
+ {
+ 0x00000000UL, 0xb8bc6765UL, 0xaa09c88bUL, 0x12b5afeeUL, 0x8f629757UL,
+ 0x37def032UL, 0x256b5fdcUL, 0x9dd738b9UL, 0xc5b428efUL, 0x7d084f8aUL,
+ 0x6fbde064UL, 0xd7018701UL, 0x4ad6bfb8UL, 0xf26ad8ddUL, 0xe0df7733UL,
+ 0x58631056UL, 0x5019579fUL, 0xe8a530faUL, 0xfa109f14UL, 0x42acf871UL,
+ 0xdf7bc0c8UL, 0x67c7a7adUL, 0x75720843UL, 0xcdce6f26UL, 0x95ad7f70UL,
+ 0x2d111815UL, 0x3fa4b7fbUL, 0x8718d09eUL, 0x1acfe827UL, 0xa2738f42UL,
+ 0xb0c620acUL, 0x087a47c9UL, 0xa032af3eUL, 0x188ec85bUL, 0x0a3b67b5UL,
+ 0xb28700d0UL, 0x2f503869UL, 0x97ec5f0cUL, 0x8559f0e2UL, 0x3de59787UL,
+ 0x658687d1UL, 0xdd3ae0b4UL, 0xcf8f4f5aUL, 0x7733283fUL, 0xeae41086UL,
+ 0x525877e3UL, 0x40edd80dUL, 0xf851bf68UL, 0xf02bf8a1UL, 0x48979fc4UL,
+ 0x5a22302aUL, 0xe29e574fUL, 0x7f496ff6UL, 0xc7f50893UL, 0xd540a77dUL,
+ 0x6dfcc018UL, 0x359fd04eUL, 0x8d23b72bUL, 0x9f9618c5UL, 0x272a7fa0UL,
+ 0xbafd4719UL, 0x0241207cUL, 0x10f48f92UL, 0xa848e8f7UL, 0x9b14583dUL,
+ 0x23a83f58UL, 0x311d90b6UL, 0x89a1f7d3UL, 0x1476cf6aUL, 0xaccaa80fUL,
+ 0xbe7f07e1UL, 0x06c36084UL, 0x5ea070d2UL, 0xe61c17b7UL, 0xf4a9b859UL,
+ 0x4c15df3cUL, 0xd1c2e785UL, 0x697e80e0UL, 0x7bcb2f0eUL, 0xc377486bUL,
+ 0xcb0d0fa2UL, 0x73b168c7UL, 0x6104c729UL, 0xd9b8a04cUL, 0x446f98f5UL,
+ 0xfcd3ff90UL, 0xee66507eUL, 0x56da371bUL, 0x0eb9274dUL, 0xb6054028UL,
+ 0xa4b0efc6UL, 0x1c0c88a3UL, 0x81dbb01aUL, 0x3967d77fUL, 0x2bd27891UL,
+ 0x936e1ff4UL, 0x3b26f703UL, 0x839a9066UL, 0x912f3f88UL, 0x299358edUL,
+ 0xb4446054UL, 0x0cf80731UL, 0x1e4da8dfUL, 0xa6f1cfbaUL, 0xfe92dfecUL,
+ 0x462eb889UL, 0x549b1767UL, 0xec277002UL, 0x71f048bbUL, 0xc94c2fdeUL,
+ 0xdbf98030UL, 0x6345e755UL, 0x6b3fa09cUL, 0xd383c7f9UL, 0xc1366817UL,
+ 0x798a0f72UL, 0xe45d37cbUL, 0x5ce150aeUL, 0x4e54ff40UL, 0xf6e89825UL,
+ 0xae8b8873UL, 0x1637ef16UL, 0x048240f8UL, 0xbc3e279dUL, 0x21e91f24UL,
+ 0x99557841UL, 0x8be0d7afUL, 0x335cb0caUL, 0xed59b63bUL, 0x55e5d15eUL,
+ 0x47507eb0UL, 0xffec19d5UL, 0x623b216cUL, 0xda874609UL, 0xc832e9e7UL,
+ 0x708e8e82UL, 0x28ed9ed4UL, 0x9051f9b1UL, 0x82e4565fUL, 0x3a58313aUL,
+ 0xa78f0983UL, 0x1f336ee6UL, 0x0d86c108UL, 0xb53aa66dUL, 0xbd40e1a4UL,
+ 0x05fc86c1UL, 0x1749292fUL, 0xaff54e4aUL, 0x322276f3UL, 0x8a9e1196UL,
+ 0x982bbe78UL, 0x2097d91dUL, 0x78f4c94bUL, 0xc048ae2eUL, 0xd2fd01c0UL,
+ 0x6a4166a5UL, 0xf7965e1cUL, 0x4f2a3979UL, 0x5d9f9697UL, 0xe523f1f2UL,
+ 0x4d6b1905UL, 0xf5d77e60UL, 0xe762d18eUL, 0x5fdeb6ebUL, 0xc2098e52UL,
+ 0x7ab5e937UL, 0x680046d9UL, 0xd0bc21bcUL, 0x88df31eaUL, 0x3063568fUL,
+ 0x22d6f961UL, 0x9a6a9e04UL, 0x07bda6bdUL, 0xbf01c1d8UL, 0xadb46e36UL,
+ 0x15080953UL, 0x1d724e9aUL, 0xa5ce29ffUL, 0xb77b8611UL, 0x0fc7e174UL,
+ 0x9210d9cdUL, 0x2aacbea8UL, 0x38191146UL, 0x80a57623UL, 0xd8c66675UL,
+ 0x607a0110UL, 0x72cfaefeUL, 0xca73c99bUL, 0x57a4f122UL, 0xef189647UL,
+ 0xfdad39a9UL, 0x45115eccUL, 0x764dee06UL, 0xcef18963UL, 0xdc44268dUL,
+ 0x64f841e8UL, 0xf92f7951UL, 0x41931e34UL, 0x5326b1daUL, 0xeb9ad6bfUL,
+ 0xb3f9c6e9UL, 0x0b45a18cUL, 0x19f00e62UL, 0xa14c6907UL, 0x3c9b51beUL,
+ 0x842736dbUL, 0x96929935UL, 0x2e2efe50UL, 0x2654b999UL, 0x9ee8defcUL,
+ 0x8c5d7112UL, 0x34e11677UL, 0xa9362eceUL, 0x118a49abUL, 0x033fe645UL,
+ 0xbb838120UL, 0xe3e09176UL, 0x5b5cf613UL, 0x49e959fdUL, 0xf1553e98UL,
+ 0x6c820621UL, 0xd43e6144UL, 0xc68bceaaUL, 0x7e37a9cfUL, 0xd67f4138UL,
+ 0x6ec3265dUL, 0x7c7689b3UL, 0xc4caeed6UL, 0x591dd66fUL, 0xe1a1b10aUL,
+ 0xf3141ee4UL, 0x4ba87981UL, 0x13cb69d7UL, 0xab770eb2UL, 0xb9c2a15cUL,
+ 0x017ec639UL, 0x9ca9fe80UL, 0x241599e5UL, 0x36a0360bUL, 0x8e1c516eUL,
+ 0x866616a7UL, 0x3eda71c2UL, 0x2c6fde2cUL, 0x94d3b949UL, 0x090481f0UL,
+ 0xb1b8e695UL, 0xa30d497bUL, 0x1bb12e1eUL, 0x43d23e48UL, 0xfb6e592dUL,
+ 0xe9dbf6c3UL, 0x516791a6UL, 0xccb0a91fUL, 0x740cce7aUL, 0x66b96194UL,
+ 0xde0506f1UL
+ },
+ {
+ 0x00000000UL, 0x96300777UL, 0x2c610eeeUL, 0xba510999UL, 0x19c46d07UL,
+ 0x8ff46a70UL, 0x35a563e9UL, 0xa395649eUL, 0x3288db0eUL, 0xa4b8dc79UL,
+ 0x1ee9d5e0UL, 0x88d9d297UL, 0x2b4cb609UL, 0xbd7cb17eUL, 0x072db8e7UL,
+ 0x911dbf90UL, 0x6410b71dUL, 0xf220b06aUL, 0x4871b9f3UL, 0xde41be84UL,
+ 0x7dd4da1aUL, 0xebe4dd6dUL, 0x51b5d4f4UL, 0xc785d383UL, 0x56986c13UL,
+ 0xc0a86b64UL, 0x7af962fdUL, 0xecc9658aUL, 0x4f5c0114UL, 0xd96c0663UL,
+ 0x633d0ffaUL, 0xf50d088dUL, 0xc8206e3bUL, 0x5e10694cUL, 0xe44160d5UL,
+ 0x727167a2UL, 0xd1e4033cUL, 0x47d4044bUL, 0xfd850dd2UL, 0x6bb50aa5UL,
+ 0xfaa8b535UL, 0x6c98b242UL, 0xd6c9bbdbUL, 0x40f9bcacUL, 0xe36cd832UL,
+ 0x755cdf45UL, 0xcf0dd6dcUL, 0x593dd1abUL, 0xac30d926UL, 0x3a00de51UL,
+ 0x8051d7c8UL, 0x1661d0bfUL, 0xb5f4b421UL, 0x23c4b356UL, 0x9995bacfUL,
+ 0x0fa5bdb8UL, 0x9eb80228UL, 0x0888055fUL, 0xb2d90cc6UL, 0x24e90bb1UL,
+ 0x877c6f2fUL, 0x114c6858UL, 0xab1d61c1UL, 0x3d2d66b6UL, 0x9041dc76UL,
+ 0x0671db01UL, 0xbc20d298UL, 0x2a10d5efUL, 0x8985b171UL, 0x1fb5b606UL,
+ 0xa5e4bf9fUL, 0x33d4b8e8UL, 0xa2c90778UL, 0x34f9000fUL, 0x8ea80996UL,
+ 0x18980ee1UL, 0xbb0d6a7fUL, 0x2d3d6d08UL, 0x976c6491UL, 0x015c63e6UL,
+ 0xf4516b6bUL, 0x62616c1cUL, 0xd8306585UL, 0x4e0062f2UL, 0xed95066cUL,
+ 0x7ba5011bUL, 0xc1f40882UL, 0x57c40ff5UL, 0xc6d9b065UL, 0x50e9b712UL,
+ 0xeab8be8bUL, 0x7c88b9fcUL, 0xdf1ddd62UL, 0x492dda15UL, 0xf37cd38cUL,
+ 0x654cd4fbUL, 0x5861b24dUL, 0xce51b53aUL, 0x7400bca3UL, 0xe230bbd4UL,
+ 0x41a5df4aUL, 0xd795d83dUL, 0x6dc4d1a4UL, 0xfbf4d6d3UL, 0x6ae96943UL,
+ 0xfcd96e34UL, 0x468867adUL, 0xd0b860daUL, 0x732d0444UL, 0xe51d0333UL,
+ 0x5f4c0aaaUL, 0xc97c0dddUL, 0x3c710550UL, 0xaa410227UL, 0x10100bbeUL,
+ 0x86200cc9UL, 0x25b56857UL, 0xb3856f20UL, 0x09d466b9UL, 0x9fe461ceUL,
+ 0x0ef9de5eUL, 0x98c9d929UL, 0x2298d0b0UL, 0xb4a8d7c7UL, 0x173db359UL,
+ 0x810db42eUL, 0x3b5cbdb7UL, 0xad6cbac0UL, 0x2083b8edUL, 0xb6b3bf9aUL,
+ 0x0ce2b603UL, 0x9ad2b174UL, 0x3947d5eaUL, 0xaf77d29dUL, 0x1526db04UL,
+ 0x8316dc73UL, 0x120b63e3UL, 0x843b6494UL, 0x3e6a6d0dUL, 0xa85a6a7aUL,
+ 0x0bcf0ee4UL, 0x9dff0993UL, 0x27ae000aUL, 0xb19e077dUL, 0x44930ff0UL,
+ 0xd2a30887UL, 0x68f2011eUL, 0xfec20669UL, 0x5d5762f7UL, 0xcb676580UL,
+ 0x71366c19UL, 0xe7066b6eUL, 0x761bd4feUL, 0xe02bd389UL, 0x5a7ada10UL,
+ 0xcc4add67UL, 0x6fdfb9f9UL, 0xf9efbe8eUL, 0x43beb717UL, 0xd58eb060UL,
+ 0xe8a3d6d6UL, 0x7e93d1a1UL, 0xc4c2d838UL, 0x52f2df4fUL, 0xf167bbd1UL,
+ 0x6757bca6UL, 0xdd06b53fUL, 0x4b36b248UL, 0xda2b0dd8UL, 0x4c1b0aafUL,
+ 0xf64a0336UL, 0x607a0441UL, 0xc3ef60dfUL, 0x55df67a8UL, 0xef8e6e31UL,
+ 0x79be6946UL, 0x8cb361cbUL, 0x1a8366bcUL, 0xa0d26f25UL, 0x36e26852UL,
+ 0x95770cccUL, 0x03470bbbUL, 0xb9160222UL, 0x2f260555UL, 0xbe3bbac5UL,
+ 0x280bbdb2UL, 0x925ab42bUL, 0x046ab35cUL, 0xa7ffd7c2UL, 0x31cfd0b5UL,
+ 0x8b9ed92cUL, 0x1daede5bUL, 0xb0c2649bUL, 0x26f263ecUL, 0x9ca36a75UL,
+ 0x0a936d02UL, 0xa906099cUL, 0x3f360eebUL, 0x85670772UL, 0x13570005UL,
+ 0x824abf95UL, 0x147ab8e2UL, 0xae2bb17bUL, 0x381bb60cUL, 0x9b8ed292UL,
+ 0x0dbed5e5UL, 0xb7efdc7cUL, 0x21dfdb0bUL, 0xd4d2d386UL, 0x42e2d4f1UL,
+ 0xf8b3dd68UL, 0x6e83da1fUL, 0xcd16be81UL, 0x5b26b9f6UL, 0xe177b06fUL,
+ 0x7747b718UL, 0xe65a0888UL, 0x706a0fffUL, 0xca3b0666UL, 0x5c0b0111UL,
+ 0xff9e658fUL, 0x69ae62f8UL, 0xd3ff6b61UL, 0x45cf6c16UL, 0x78e20aa0UL,
+ 0xeed20dd7UL, 0x5483044eUL, 0xc2b30339UL, 0x612667a7UL, 0xf71660d0UL,
+ 0x4d476949UL, 0xdb776e3eUL, 0x4a6ad1aeUL, 0xdc5ad6d9UL, 0x660bdf40UL,
+ 0xf03bd837UL, 0x53aebca9UL, 0xc59ebbdeUL, 0x7fcfb247UL, 0xe9ffb530UL,
+ 0x1cf2bdbdUL, 0x8ac2bacaUL, 0x3093b353UL, 0xa6a3b424UL, 0x0536d0baUL,
+ 0x9306d7cdUL, 0x2957de54UL, 0xbf67d923UL, 0x2e7a66b3UL, 0xb84a61c4UL,
+ 0x021b685dUL, 0x942b6f2aUL, 0x37be0bb4UL, 0xa18e0cc3UL, 0x1bdf055aUL,
+ 0x8def022dUL
+ },
+ {
+ 0x00000000UL, 0x41311b19UL, 0x82623632UL, 0xc3532d2bUL, 0x04c56c64UL,
+ 0x45f4777dUL, 0x86a75a56UL, 0xc796414fUL, 0x088ad9c8UL, 0x49bbc2d1UL,
+ 0x8ae8effaUL, 0xcbd9f4e3UL, 0x0c4fb5acUL, 0x4d7eaeb5UL, 0x8e2d839eUL,
+ 0xcf1c9887UL, 0x5112c24aUL, 0x1023d953UL, 0xd370f478UL, 0x9241ef61UL,
+ 0x55d7ae2eUL, 0x14e6b537UL, 0xd7b5981cUL, 0x96848305UL, 0x59981b82UL,
+ 0x18a9009bUL, 0xdbfa2db0UL, 0x9acb36a9UL, 0x5d5d77e6UL, 0x1c6c6cffUL,
+ 0xdf3f41d4UL, 0x9e0e5acdUL, 0xa2248495UL, 0xe3159f8cUL, 0x2046b2a7UL,
+ 0x6177a9beUL, 0xa6e1e8f1UL, 0xe7d0f3e8UL, 0x2483dec3UL, 0x65b2c5daUL,
+ 0xaaae5d5dUL, 0xeb9f4644UL, 0x28cc6b6fUL, 0x69fd7076UL, 0xae6b3139UL,
+ 0xef5a2a20UL, 0x2c09070bUL, 0x6d381c12UL, 0xf33646dfUL, 0xb2075dc6UL,
+ 0x715470edUL, 0x30656bf4UL, 0xf7f32abbUL, 0xb6c231a2UL, 0x75911c89UL,
+ 0x34a00790UL, 0xfbbc9f17UL, 0xba8d840eUL, 0x79dea925UL, 0x38efb23cUL,
+ 0xff79f373UL, 0xbe48e86aUL, 0x7d1bc541UL, 0x3c2ade58UL, 0x054f79f0UL,
+ 0x447e62e9UL, 0x872d4fc2UL, 0xc61c54dbUL, 0x018a1594UL, 0x40bb0e8dUL,
+ 0x83e823a6UL, 0xc2d938bfUL, 0x0dc5a038UL, 0x4cf4bb21UL, 0x8fa7960aUL,
+ 0xce968d13UL, 0x0900cc5cUL, 0x4831d745UL, 0x8b62fa6eUL, 0xca53e177UL,
+ 0x545dbbbaUL, 0x156ca0a3UL, 0xd63f8d88UL, 0x970e9691UL, 0x5098d7deUL,
+ 0x11a9ccc7UL, 0xd2fae1ecUL, 0x93cbfaf5UL, 0x5cd76272UL, 0x1de6796bUL,
+ 0xdeb55440UL, 0x9f844f59UL, 0x58120e16UL, 0x1923150fUL, 0xda703824UL,
+ 0x9b41233dUL, 0xa76bfd65UL, 0xe65ae67cUL, 0x2509cb57UL, 0x6438d04eUL,
+ 0xa3ae9101UL, 0xe29f8a18UL, 0x21cca733UL, 0x60fdbc2aUL, 0xafe124adUL,
+ 0xeed03fb4UL, 0x2d83129fUL, 0x6cb20986UL, 0xab2448c9UL, 0xea1553d0UL,
+ 0x29467efbUL, 0x687765e2UL, 0xf6793f2fUL, 0xb7482436UL, 0x741b091dUL,
+ 0x352a1204UL, 0xf2bc534bUL, 0xb38d4852UL, 0x70de6579UL, 0x31ef7e60UL,
+ 0xfef3e6e7UL, 0xbfc2fdfeUL, 0x7c91d0d5UL, 0x3da0cbccUL, 0xfa368a83UL,
+ 0xbb07919aUL, 0x7854bcb1UL, 0x3965a7a8UL, 0x4b98833bUL, 0x0aa99822UL,
+ 0xc9fab509UL, 0x88cbae10UL, 0x4f5def5fUL, 0x0e6cf446UL, 0xcd3fd96dUL,
+ 0x8c0ec274UL, 0x43125af3UL, 0x022341eaUL, 0xc1706cc1UL, 0x804177d8UL,
+ 0x47d73697UL, 0x06e62d8eUL, 0xc5b500a5UL, 0x84841bbcUL, 0x1a8a4171UL,
+ 0x5bbb5a68UL, 0x98e87743UL, 0xd9d96c5aUL, 0x1e4f2d15UL, 0x5f7e360cUL,
+ 0x9c2d1b27UL, 0xdd1c003eUL, 0x120098b9UL, 0x533183a0UL, 0x9062ae8bUL,
+ 0xd153b592UL, 0x16c5f4ddUL, 0x57f4efc4UL, 0x94a7c2efUL, 0xd596d9f6UL,
+ 0xe9bc07aeUL, 0xa88d1cb7UL, 0x6bde319cUL, 0x2aef2a85UL, 0xed796bcaUL,
+ 0xac4870d3UL, 0x6f1b5df8UL, 0x2e2a46e1UL, 0xe136de66UL, 0xa007c57fUL,
+ 0x6354e854UL, 0x2265f34dUL, 0xe5f3b202UL, 0xa4c2a91bUL, 0x67918430UL,
+ 0x26a09f29UL, 0xb8aec5e4UL, 0xf99fdefdUL, 0x3accf3d6UL, 0x7bfde8cfUL,
+ 0xbc6ba980UL, 0xfd5ab299UL, 0x3e099fb2UL, 0x7f3884abUL, 0xb0241c2cUL,
+ 0xf1150735UL, 0x32462a1eUL, 0x73773107UL, 0xb4e17048UL, 0xf5d06b51UL,
+ 0x3683467aUL, 0x77b25d63UL, 0x4ed7facbUL, 0x0fe6e1d2UL, 0xccb5ccf9UL,
+ 0x8d84d7e0UL, 0x4a1296afUL, 0x0b238db6UL, 0xc870a09dUL, 0x8941bb84UL,
+ 0x465d2303UL, 0x076c381aUL, 0xc43f1531UL, 0x850e0e28UL, 0x42984f67UL,
+ 0x03a9547eUL, 0xc0fa7955UL, 0x81cb624cUL, 0x1fc53881UL, 0x5ef42398UL,
+ 0x9da70eb3UL, 0xdc9615aaUL, 0x1b0054e5UL, 0x5a314ffcUL, 0x996262d7UL,
+ 0xd85379ceUL, 0x174fe149UL, 0x567efa50UL, 0x952dd77bUL, 0xd41ccc62UL,
+ 0x138a8d2dUL, 0x52bb9634UL, 0x91e8bb1fUL, 0xd0d9a006UL, 0xecf37e5eUL,
+ 0xadc26547UL, 0x6e91486cUL, 0x2fa05375UL, 0xe836123aUL, 0xa9070923UL,
+ 0x6a542408UL, 0x2b653f11UL, 0xe479a796UL, 0xa548bc8fUL, 0x661b91a4UL,
+ 0x272a8abdUL, 0xe0bccbf2UL, 0xa18dd0ebUL, 0x62defdc0UL, 0x23efe6d9UL,
+ 0xbde1bc14UL, 0xfcd0a70dUL, 0x3f838a26UL, 0x7eb2913fUL, 0xb924d070UL,
+ 0xf815cb69UL, 0x3b46e642UL, 0x7a77fd5bUL, 0xb56b65dcUL, 0xf45a7ec5UL,
+ 0x370953eeUL, 0x763848f7UL, 0xb1ae09b8UL, 0xf09f12a1UL, 0x33cc3f8aUL,
+ 0x72fd2493UL
+ },
+ {
+ 0x00000000UL, 0x376ac201UL, 0x6ed48403UL, 0x59be4602UL, 0xdca80907UL,
+ 0xebc2cb06UL, 0xb27c8d04UL, 0x85164f05UL, 0xb851130eUL, 0x8f3bd10fUL,
+ 0xd685970dUL, 0xe1ef550cUL, 0x64f91a09UL, 0x5393d808UL, 0x0a2d9e0aUL,
+ 0x3d475c0bUL, 0x70a3261cUL, 0x47c9e41dUL, 0x1e77a21fUL, 0x291d601eUL,
+ 0xac0b2f1bUL, 0x9b61ed1aUL, 0xc2dfab18UL, 0xf5b56919UL, 0xc8f23512UL,
+ 0xff98f713UL, 0xa626b111UL, 0x914c7310UL, 0x145a3c15UL, 0x2330fe14UL,
+ 0x7a8eb816UL, 0x4de47a17UL, 0xe0464d38UL, 0xd72c8f39UL, 0x8e92c93bUL,
+ 0xb9f80b3aUL, 0x3cee443fUL, 0x0b84863eUL, 0x523ac03cUL, 0x6550023dUL,
+ 0x58175e36UL, 0x6f7d9c37UL, 0x36c3da35UL, 0x01a91834UL, 0x84bf5731UL,
+ 0xb3d59530UL, 0xea6bd332UL, 0xdd011133UL, 0x90e56b24UL, 0xa78fa925UL,
+ 0xfe31ef27UL, 0xc95b2d26UL, 0x4c4d6223UL, 0x7b27a022UL, 0x2299e620UL,
+ 0x15f32421UL, 0x28b4782aUL, 0x1fdeba2bUL, 0x4660fc29UL, 0x710a3e28UL,
+ 0xf41c712dUL, 0xc376b32cUL, 0x9ac8f52eUL, 0xada2372fUL, 0xc08d9a70UL,
+ 0xf7e75871UL, 0xae591e73UL, 0x9933dc72UL, 0x1c259377UL, 0x2b4f5176UL,
+ 0x72f11774UL, 0x459bd575UL, 0x78dc897eUL, 0x4fb64b7fUL, 0x16080d7dUL,
+ 0x2162cf7cUL, 0xa4748079UL, 0x931e4278UL, 0xcaa0047aUL, 0xfdcac67bUL,
+ 0xb02ebc6cUL, 0x87447e6dUL, 0xdefa386fUL, 0xe990fa6eUL, 0x6c86b56bUL,
+ 0x5bec776aUL, 0x02523168UL, 0x3538f369UL, 0x087faf62UL, 0x3f156d63UL,
+ 0x66ab2b61UL, 0x51c1e960UL, 0xd4d7a665UL, 0xe3bd6464UL, 0xba032266UL,
+ 0x8d69e067UL, 0x20cbd748UL, 0x17a11549UL, 0x4e1f534bUL, 0x7975914aUL,
+ 0xfc63de4fUL, 0xcb091c4eUL, 0x92b75a4cUL, 0xa5dd984dUL, 0x989ac446UL,
+ 0xaff00647UL, 0xf64e4045UL, 0xc1248244UL, 0x4432cd41UL, 0x73580f40UL,
+ 0x2ae64942UL, 0x1d8c8b43UL, 0x5068f154UL, 0x67023355UL, 0x3ebc7557UL,
+ 0x09d6b756UL, 0x8cc0f853UL, 0xbbaa3a52UL, 0xe2147c50UL, 0xd57ebe51UL,
+ 0xe839e25aUL, 0xdf53205bUL, 0x86ed6659UL, 0xb187a458UL, 0x3491eb5dUL,
+ 0x03fb295cUL, 0x5a456f5eUL, 0x6d2fad5fUL, 0x801b35e1UL, 0xb771f7e0UL,
+ 0xeecfb1e2UL, 0xd9a573e3UL, 0x5cb33ce6UL, 0x6bd9fee7UL, 0x3267b8e5UL,
+ 0x050d7ae4UL, 0x384a26efUL, 0x0f20e4eeUL, 0x569ea2ecUL, 0x61f460edUL,
+ 0xe4e22fe8UL, 0xd388ede9UL, 0x8a36abebUL, 0xbd5c69eaUL, 0xf0b813fdUL,
+ 0xc7d2d1fcUL, 0x9e6c97feUL, 0xa90655ffUL, 0x2c101afaUL, 0x1b7ad8fbUL,
+ 0x42c49ef9UL, 0x75ae5cf8UL, 0x48e900f3UL, 0x7f83c2f2UL, 0x263d84f0UL,
+ 0x115746f1UL, 0x944109f4UL, 0xa32bcbf5UL, 0xfa958df7UL, 0xcdff4ff6UL,
+ 0x605d78d9UL, 0x5737bad8UL, 0x0e89fcdaUL, 0x39e33edbUL, 0xbcf571deUL,
+ 0x8b9fb3dfUL, 0xd221f5ddUL, 0xe54b37dcUL, 0xd80c6bd7UL, 0xef66a9d6UL,
+ 0xb6d8efd4UL, 0x81b22dd5UL, 0x04a462d0UL, 0x33cea0d1UL, 0x6a70e6d3UL,
+ 0x5d1a24d2UL, 0x10fe5ec5UL, 0x27949cc4UL, 0x7e2adac6UL, 0x494018c7UL,
+ 0xcc5657c2UL, 0xfb3c95c3UL, 0xa282d3c1UL, 0x95e811c0UL, 0xa8af4dcbUL,
+ 0x9fc58fcaUL, 0xc67bc9c8UL, 0xf1110bc9UL, 0x740744ccUL, 0x436d86cdUL,
+ 0x1ad3c0cfUL, 0x2db902ceUL, 0x4096af91UL, 0x77fc6d90UL, 0x2e422b92UL,
+ 0x1928e993UL, 0x9c3ea696UL, 0xab546497UL, 0xf2ea2295UL, 0xc580e094UL,
+ 0xf8c7bc9fUL, 0xcfad7e9eUL, 0x9613389cUL, 0xa179fa9dUL, 0x246fb598UL,
+ 0x13057799UL, 0x4abb319bUL, 0x7dd1f39aUL, 0x3035898dUL, 0x075f4b8cUL,
+ 0x5ee10d8eUL, 0x698bcf8fUL, 0xec9d808aUL, 0xdbf7428bUL, 0x82490489UL,
+ 0xb523c688UL, 0x88649a83UL, 0xbf0e5882UL, 0xe6b01e80UL, 0xd1dadc81UL,
+ 0x54cc9384UL, 0x63a65185UL, 0x3a181787UL, 0x0d72d586UL, 0xa0d0e2a9UL,
+ 0x97ba20a8UL, 0xce0466aaUL, 0xf96ea4abUL, 0x7c78ebaeUL, 0x4b1229afUL,
+ 0x12ac6fadUL, 0x25c6adacUL, 0x1881f1a7UL, 0x2feb33a6UL, 0x765575a4UL,
+ 0x413fb7a5UL, 0xc429f8a0UL, 0xf3433aa1UL, 0xaafd7ca3UL, 0x9d97bea2UL,
+ 0xd073c4b5UL, 0xe71906b4UL, 0xbea740b6UL, 0x89cd82b7UL, 0x0cdbcdb2UL,
+ 0x3bb10fb3UL, 0x620f49b1UL, 0x55658bb0UL, 0x6822d7bbUL, 0x5f4815baUL,
+ 0x06f653b8UL, 0x319c91b9UL, 0xb48adebcUL, 0x83e01cbdUL, 0xda5e5abfUL,
+ 0xed3498beUL
+ },
+ {
+ 0x00000000UL, 0x6567bcb8UL, 0x8bc809aaUL, 0xeeafb512UL, 0x5797628fUL,
+ 0x32f0de37UL, 0xdc5f6b25UL, 0xb938d79dUL, 0xef28b4c5UL, 0x8a4f087dUL,
+ 0x64e0bd6fUL, 0x018701d7UL, 0xb8bfd64aUL, 0xddd86af2UL, 0x3377dfe0UL,
+ 0x56106358UL, 0x9f571950UL, 0xfa30a5e8UL, 0x149f10faUL, 0x71f8ac42UL,
+ 0xc8c07bdfUL, 0xada7c767UL, 0x43087275UL, 0x266fcecdUL, 0x707fad95UL,
+ 0x1518112dUL, 0xfbb7a43fUL, 0x9ed01887UL, 0x27e8cf1aUL, 0x428f73a2UL,
+ 0xac20c6b0UL, 0xc9477a08UL, 0x3eaf32a0UL, 0x5bc88e18UL, 0xb5673b0aUL,
+ 0xd00087b2UL, 0x6938502fUL, 0x0c5fec97UL, 0xe2f05985UL, 0x8797e53dUL,
+ 0xd1878665UL, 0xb4e03addUL, 0x5a4f8fcfUL, 0x3f283377UL, 0x8610e4eaUL,
+ 0xe3775852UL, 0x0dd8ed40UL, 0x68bf51f8UL, 0xa1f82bf0UL, 0xc49f9748UL,
+ 0x2a30225aUL, 0x4f579ee2UL, 0xf66f497fUL, 0x9308f5c7UL, 0x7da740d5UL,
+ 0x18c0fc6dUL, 0x4ed09f35UL, 0x2bb7238dUL, 0xc518969fUL, 0xa07f2a27UL,
+ 0x1947fdbaUL, 0x7c204102UL, 0x928ff410UL, 0xf7e848a8UL, 0x3d58149bUL,
+ 0x583fa823UL, 0xb6901d31UL, 0xd3f7a189UL, 0x6acf7614UL, 0x0fa8caacUL,
+ 0xe1077fbeUL, 0x8460c306UL, 0xd270a05eUL, 0xb7171ce6UL, 0x59b8a9f4UL,
+ 0x3cdf154cUL, 0x85e7c2d1UL, 0xe0807e69UL, 0x0e2fcb7bUL, 0x6b4877c3UL,
+ 0xa20f0dcbUL, 0xc768b173UL, 0x29c70461UL, 0x4ca0b8d9UL, 0xf5986f44UL,
+ 0x90ffd3fcUL, 0x7e5066eeUL, 0x1b37da56UL, 0x4d27b90eUL, 0x284005b6UL,
+ 0xc6efb0a4UL, 0xa3880c1cUL, 0x1ab0db81UL, 0x7fd76739UL, 0x9178d22bUL,
+ 0xf41f6e93UL, 0x03f7263bUL, 0x66909a83UL, 0x883f2f91UL, 0xed589329UL,
+ 0x546044b4UL, 0x3107f80cUL, 0xdfa84d1eUL, 0xbacff1a6UL, 0xecdf92feUL,
+ 0x89b82e46UL, 0x67179b54UL, 0x027027ecUL, 0xbb48f071UL, 0xde2f4cc9UL,
+ 0x3080f9dbUL, 0x55e74563UL, 0x9ca03f6bUL, 0xf9c783d3UL, 0x176836c1UL,
+ 0x720f8a79UL, 0xcb375de4UL, 0xae50e15cUL, 0x40ff544eUL, 0x2598e8f6UL,
+ 0x73888baeUL, 0x16ef3716UL, 0xf8408204UL, 0x9d273ebcUL, 0x241fe921UL,
+ 0x41785599UL, 0xafd7e08bUL, 0xcab05c33UL, 0x3bb659edUL, 0x5ed1e555UL,
+ 0xb07e5047UL, 0xd519ecffUL, 0x6c213b62UL, 0x094687daUL, 0xe7e932c8UL,
+ 0x828e8e70UL, 0xd49eed28UL, 0xb1f95190UL, 0x5f56e482UL, 0x3a31583aUL,
+ 0x83098fa7UL, 0xe66e331fUL, 0x08c1860dUL, 0x6da63ab5UL, 0xa4e140bdUL,
+ 0xc186fc05UL, 0x2f294917UL, 0x4a4ef5afUL, 0xf3762232UL, 0x96119e8aUL,
+ 0x78be2b98UL, 0x1dd99720UL, 0x4bc9f478UL, 0x2eae48c0UL, 0xc001fdd2UL,
+ 0xa566416aUL, 0x1c5e96f7UL, 0x79392a4fUL, 0x97969f5dUL, 0xf2f123e5UL,
+ 0x05196b4dUL, 0x607ed7f5UL, 0x8ed162e7UL, 0xebb6de5fUL, 0x528e09c2UL,
+ 0x37e9b57aUL, 0xd9460068UL, 0xbc21bcd0UL, 0xea31df88UL, 0x8f566330UL,
+ 0x61f9d622UL, 0x049e6a9aUL, 0xbda6bd07UL, 0xd8c101bfUL, 0x366eb4adUL,
+ 0x53090815UL, 0x9a4e721dUL, 0xff29cea5UL, 0x11867bb7UL, 0x74e1c70fUL,
+ 0xcdd91092UL, 0xa8beac2aUL, 0x46111938UL, 0x2376a580UL, 0x7566c6d8UL,
+ 0x10017a60UL, 0xfeaecf72UL, 0x9bc973caUL, 0x22f1a457UL, 0x479618efUL,
+ 0xa939adfdUL, 0xcc5e1145UL, 0x06ee4d76UL, 0x6389f1ceUL, 0x8d2644dcUL,
+ 0xe841f864UL, 0x51792ff9UL, 0x341e9341UL, 0xdab12653UL, 0xbfd69aebUL,
+ 0xe9c6f9b3UL, 0x8ca1450bUL, 0x620ef019UL, 0x07694ca1UL, 0xbe519b3cUL,
+ 0xdb362784UL, 0x35999296UL, 0x50fe2e2eUL, 0x99b95426UL, 0xfcdee89eUL,
+ 0x12715d8cUL, 0x7716e134UL, 0xce2e36a9UL, 0xab498a11UL, 0x45e63f03UL,
+ 0x208183bbUL, 0x7691e0e3UL, 0x13f65c5bUL, 0xfd59e949UL, 0x983e55f1UL,
+ 0x2106826cUL, 0x44613ed4UL, 0xaace8bc6UL, 0xcfa9377eUL, 0x38417fd6UL,
+ 0x5d26c36eUL, 0xb389767cUL, 0xd6eecac4UL, 0x6fd61d59UL, 0x0ab1a1e1UL,
+ 0xe41e14f3UL, 0x8179a84bUL, 0xd769cb13UL, 0xb20e77abUL, 0x5ca1c2b9UL,
+ 0x39c67e01UL, 0x80fea99cUL, 0xe5991524UL, 0x0b36a036UL, 0x6e511c8eUL,
+ 0xa7166686UL, 0xc271da3eUL, 0x2cde6f2cUL, 0x49b9d394UL, 0xf0810409UL,
+ 0x95e6b8b1UL, 0x7b490da3UL, 0x1e2eb11bUL, 0x483ed243UL, 0x2d596efbUL,
+ 0xc3f6dbe9UL, 0xa6916751UL, 0x1fa9b0ccUL, 0x7ace0c74UL, 0x9461b966UL,
+ 0xf10605deUL
+#endif
+ }
+};
--- /dev/null
+/* deflate.c -- compress data using the deflation algorithm
+ * Copyright (C) 1995-2005 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/*
+ * ALGORITHM
+ *
+ * The "deflation" process depends on being able to identify portions
+ * of the input text which are identical to earlier input (within a
+ * sliding window trailing behind the input currently being processed).
+ *
+ * The most straightforward technique turns out to be the fastest for
+ * most input files: try all possible matches and select the longest.
+ * The key feature of this algorithm is that insertions into the string
+ * dictionary are very simple and thus fast, and deletions are avoided
+ * completely. Insertions are performed at each input character, whereas
+ * string matches are performed only when the previous match ends. So it
+ * is preferable to spend more time in matches to allow very fast string
+ * insertions and avoid deletions. The matching algorithm for small
+ * strings is inspired from that of Rabin & Karp. A brute force approach
+ * is used to find longer strings when a small match has been found.
+ * A similar algorithm is used in comic (by Jan-Mark Wams) and freeze
+ * (by Leonid Broukhis).
+ * A previous version of this file used a more sophisticated algorithm
+ * (by Fiala and Greene) which is guaranteed to run in linear amortized
+ * time, but has a larger average cost, uses more memory and is patented.
+ * However the F&G algorithm may be faster for some highly redundant
+ * files if the parameter max_chain_length (described below) is too large.
+ *
+ * ACKNOWLEDGEMENTS
+ *
+ * The idea of lazy evaluation of matches is due to Jan-Mark Wams, and
+ * I found it in 'freeze' written by Leonid Broukhis.
+ * Thanks to many people for bug reports and testing.
+ *
+ * REFERENCES
+ *
+ * Deutsch, L.P.,"DEFLATE Compressed Data Format Specification".
+ * Available in http://www.ietf.org/rfc/rfc1951.txt
+ *
+ * A description of the Rabin and Karp algorithm is given in the book
+ * "Algorithms" by R. Sedgewick, Addison-Wesley, p252.
+ *
+ * Fiala,E.R., and Greene,D.H.
+ * Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595
+ *
+ */
+
+/* @(#) $Id$ */
+
+#include "deflate.h"
+
+const char deflate_copyright[] =
+ " deflate 1.2.3 Copyright 1995-2005 Jean-loup Gailly ";
+/*
+ If you use the zlib library in a product, an acknowledgment is welcome
+ in the documentation of your product. If for some reason you cannot
+ include such an acknowledgment, I would appreciate that you keep this
+ copyright string in the executable of your product.
+ */
+
+/* ===========================================================================
+ * Function prototypes.
+ */
+typedef enum {
+ need_more, /* block not completed, need more input or more output */
+ block_done, /* block flush performed */
+ finish_started, /* finish started, need only more output at next deflate */
+ finish_done /* finish done, accept no more input or output */
+} block_state;
+
+typedef block_state (*compress_func) OF((deflate_state *s, int flush));
+/* Compression function. Returns the block state after the call. */
+
+local void fill_window OF((deflate_state *s));
+local block_state deflate_stored OF((deflate_state *s, int flush));
+local block_state deflate_fast OF((deflate_state *s, int flush));
+#ifndef FASTEST
+local block_state deflate_slow OF((deflate_state *s, int flush));
+#endif
+local void lm_init OF((deflate_state *s));
+local void putShortMSB OF((deflate_state *s, uInt b));
+local void flush_pending OF((z_streamp strm));
+local int read_buf OF((z_streamp strm, Bytef *buf, unsigned size));
+#ifndef FASTEST
+#ifdef ASMV
+ void match_init OF((void)); /* asm code initialization */
+ uInt longest_match OF((deflate_state *s, IPos cur_match));
+#else
+local uInt longest_match OF((deflate_state *s, IPos cur_match));
+#endif
+#endif
+local uInt longest_match_fast OF((deflate_state *s, IPos cur_match));
+
+#ifdef DEBUG
+local void check_match OF((deflate_state *s, IPos start, IPos match,
+ int length));
+#endif
+
+/* ===========================================================================
+ * Local data
+ */
+
+#define NIL 0
+/* Tail of hash chains */
+
+#ifndef TOO_FAR
+# define TOO_FAR 4096
+#endif
+/* Matches of length 3 are discarded if their distance exceeds TOO_FAR */
+
+#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
+/* Minimum amount of lookahead, except at the end of the input file.
+ * See deflate.c for comments about the MIN_MATCH+1.
+ */
+
+/* Values for max_lazy_match, good_match and max_chain_length, depending on
+ * the desired pack level (0..9). The values given below have been tuned to
+ * exclude worst case performance for pathological files. Better values may be
+ * found for specific files.
+ */
+typedef struct config_s {
+ ush good_length; /* reduce lazy search above this match length */
+ ush max_lazy; /* do not perform lazy search above this match length */
+ ush nice_length; /* quit search above this match length */
+ ush max_chain;
+ compress_func func;
+} config;
+
+#ifdef FASTEST
+local const config configuration_table[2] = {
+/* good lazy nice chain */
+/* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */
+/* 1 */ {4, 4, 8, 4, deflate_fast}}; /* max speed, no lazy matches */
+#else
+local const config configuration_table[10] = {
+/* good lazy nice chain */
+/* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */
+/* 1 */ {4, 4, 8, 4, deflate_fast}, /* max speed, no lazy matches */
+/* 2 */ {4, 5, 16, 8, deflate_fast},
+/* 3 */ {4, 6, 32, 32, deflate_fast},
+
+/* 4 */ {4, 4, 16, 16, deflate_slow}, /* lazy matches */
+/* 5 */ {8, 16, 32, 32, deflate_slow},
+/* 6 */ {8, 16, 128, 128, deflate_slow},
+/* 7 */ {8, 32, 128, 256, deflate_slow},
+/* 8 */ {32, 128, 258, 1024, deflate_slow},
+/* 9 */ {32, 258, 258, 4096, deflate_slow}}; /* max compression */
+#endif
+
+/* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
+ * For deflate_fast() (levels <= 3) good is ignored and lazy has a different
+ * meaning.
+ */
+
+#define EQUAL 0
+/* result of memcmp for equal strings */
+
+#ifndef NO_DUMMY_DECL
+struct static_tree_desc_s {int dummy;}; /* for buggy compilers */
+#endif
+
+/* ===========================================================================
+ * Update a hash value with the given input byte
+ * IN assertion: all calls to to UPDATE_HASH are made with consecutive
+ * input characters, so that a running hash key can be computed from the
+ * previous key instead of complete recalculation each time.
+ */
+#define UPDATE_HASH(s,h,c) (h = (((h)<<s->hash_shift) ^ (c)) & s->hash_mask)
+
+
+/* ===========================================================================
+ * Insert string str in the dictionary and set match_head to the previous head
+ * of the hash chain (the most recent string with same hash key). Return
+ * the previous length of the hash chain.
+ * If this file is compiled with -DFASTEST, the compression level is forced
+ * to 1, and no hash chains are maintained.
+ * IN assertion: all calls to to INSERT_STRING are made with consecutive
+ * input characters and the first MIN_MATCH bytes of str are valid
+ * (except for the last MIN_MATCH-1 bytes of the input file).
+ */
+#ifdef FASTEST
+#define INSERT_STRING(s, str, match_head) \
+ (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \
+ match_head = s->head[s->ins_h], \
+ s->head[s->ins_h] = (Pos)(str))
+#else
+#define INSERT_STRING(s, str, match_head) \
+ (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \
+ match_head = s->prev[(str) & s->w_mask] = s->head[s->ins_h], \
+ s->head[s->ins_h] = (Pos)(str))
+#endif
+
+/* ===========================================================================
+ * Initialize the hash table (avoiding 64K overflow for 16 bit systems).
+ * prev[] will be initialized on the fly.
+ */
+#define CLEAR_HASH(s) \
+ s->head[s->hash_size-1] = NIL; \
+ zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head));
+
+/* ========================================================================= */
+int ZEXPORT deflateInit_(strm, level, version, stream_size)
+ z_streamp strm;
+ int level;
+ const char *version;
+ int stream_size;
+{
+ return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL,
+ Z_DEFAULT_STRATEGY, version, stream_size);
+ /* To do: ignore strm->next_in if we use it as window */
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
+ version, stream_size)
+ z_streamp strm;
+ int level;
+ int method;
+ int windowBits;
+ int memLevel;
+ int strategy;
+ const char *version;
+ int stream_size;
+{
+ deflate_state *s;
+ int wrap = 1;
+ static const char my_version[] = ZLIB_VERSION;
+
+ ushf *overlay;
+ /* We overlay pending_buf and d_buf+l_buf. This works since the average
+ * output size for (length,distance) codes is <= 24 bits.
+ */
+
+ if (version == Z_NULL || version[0] != my_version[0] ||
+ stream_size != sizeof(z_stream)) {
+ return Z_VERSION_ERROR;
+ }
+ if (strm == Z_NULL) return Z_STREAM_ERROR;
+
+ strm->msg = Z_NULL;
+ if (strm->zalloc == (alloc_func)0) {
+ strm->zalloc = zcalloc;
+ strm->opaque = (voidpf)0;
+ }
+ if (strm->zfree == (free_func)0) strm->zfree = zcfree;
+
+#ifdef FASTEST
+ if (level != 0) level = 1;
+#else
+ if (level == Z_DEFAULT_COMPRESSION) level = 6;
+#endif
+
+ if (windowBits < 0) { /* suppress zlib wrapper */
+ wrap = 0;
+ windowBits = -windowBits;
+ }
+#ifdef GZIP
+ else if (windowBits > 15) {
+ wrap = 2; /* write gzip wrapper instead */
+ windowBits -= 16;
+ }
+#endif
+ if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED ||
+ windowBits < 8 || windowBits > 15 || level < 0 || level > 9 ||
+ strategy < 0 || strategy > Z_FIXED) {
+ return Z_STREAM_ERROR;
+ }
+ if (windowBits == 8) windowBits = 9; /* until 256-byte window bug fixed */
+ s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state));
+ if (s == Z_NULL) return Z_MEM_ERROR;
+ strm->state = (struct internal_state FAR *)s;
+ s->strm = strm;
+
+ s->wrap = wrap;
+ s->gzhead = Z_NULL;
+ s->w_bits = windowBits;
+ s->w_size = 1 << s->w_bits;
+ s->w_mask = s->w_size - 1;
+
+ s->hash_bits = memLevel + 7;
+ s->hash_size = 1 << s->hash_bits;
+ s->hash_mask = s->hash_size - 1;
+ s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH);
+
+ s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte));
+ s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos));
+ s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos));
+
+ s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */
+
+ overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);
+ s->pending_buf = (uchf *) overlay;
+ s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L);
+
+ if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL ||
+ s->pending_buf == Z_NULL) {
+ s->status = FINISH_STATE;
+ strm->msg = (char*)ERR_MSG(Z_MEM_ERROR);
+ deflateEnd (strm);
+ return Z_MEM_ERROR;
+ }
+ s->d_buf = overlay + s->lit_bufsize/sizeof(ush);
+ s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;
+
+ s->level = level;
+ s->strategy = strategy;
+ s->method = (Byte)method;
+
+ return deflateReset(strm);
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength)
+ z_streamp strm;
+ const Bytef *dictionary;
+ uInt dictLength;
+{
+ deflate_state *s;
+ uInt length = dictLength;
+ uInt n;
+ IPos hash_head = 0;
+
+ if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL ||
+ strm->state->wrap == 2 ||
+ (strm->state->wrap == 1 && strm->state->status != INIT_STATE))
+ return Z_STREAM_ERROR;
+
+ s = strm->state;
+ if (s->wrap)
+ strm->adler = adler32(strm->adler, dictionary, dictLength);
+
+ if (length < MIN_MATCH) return Z_OK;
+ if (length > MAX_DIST(s)) {
+ length = MAX_DIST(s);
+ dictionary += dictLength - length; /* use the tail of the dictionary */
+ }
+ zmemcpy(s->window, dictionary, length);
+ s->strstart = length;
+ s->block_start = (long)length;
+
+ /* Insert all strings in the hash table (except for the last two bytes).
+ * s->lookahead stays null, so s->ins_h will be recomputed at the next
+ * call of fill_window.
+ */
+ s->ins_h = s->window[0];
+ UPDATE_HASH(s, s->ins_h, s->window[1]);
+ for (n = 0; n <= length - MIN_MATCH; n++) {
+ INSERT_STRING(s, n, hash_head);
+ }
+ if (hash_head) hash_head = 0; /* to make compiler happy */
+ return Z_OK;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateReset (strm)
+ z_streamp strm;
+{
+ deflate_state *s;
+
+ if (strm == Z_NULL || strm->state == Z_NULL ||
+ strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) {
+ return Z_STREAM_ERROR;
+ }
+
+ strm->total_in = strm->total_out = 0;
+ strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */
+ strm->data_type = Z_UNKNOWN;
+
+ s = (deflate_state *)strm->state;
+ s->pending = 0;
+ s->pending_out = s->pending_buf;
+
+ if (s->wrap < 0) {
+ s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */
+ }
+ s->status = s->wrap ? INIT_STATE : BUSY_STATE;
+ strm->adler =
+#ifdef GZIP
+ s->wrap == 2 ? crc32(0L, Z_NULL, 0) :
+#endif
+ adler32(0L, Z_NULL, 0);
+ s->last_flush = Z_NO_FLUSH;
+
+ _tr_init(s);
+ lm_init(s);
+
+ return Z_OK;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateSetHeader (strm, head)
+ z_streamp strm;
+ gz_headerp head;
+{
+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (strm->state->wrap != 2) return Z_STREAM_ERROR;
+ strm->state->gzhead = head;
+ return Z_OK;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflatePrime (strm, bits, value)
+ z_streamp strm;
+ int bits;
+ int value;
+{
+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ strm->state->bi_valid = bits;
+ strm->state->bi_buf = (ush)(value & ((1 << bits) - 1));
+ return Z_OK;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateParams(strm, level, strategy)
+ z_streamp strm;
+ int level;
+ int strategy;
+{
+ deflate_state *s;
+ compress_func func;
+ int err = Z_OK;
+
+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ s = strm->state;
+
+#ifdef FASTEST
+ if (level != 0) level = 1;
+#else
+ if (level == Z_DEFAULT_COMPRESSION) level = 6;
+#endif
+ if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) {
+ return Z_STREAM_ERROR;
+ }
+ func = configuration_table[s->level].func;
+
+ if (func != configuration_table[level].func && strm->total_in != 0) {
+ /* Flush the last buffer: */
+ err = deflate(strm, Z_PARTIAL_FLUSH);
+ }
+ if (s->level != level) {
+ s->level = level;
+ s->max_lazy_match = configuration_table[level].max_lazy;
+ s->good_match = configuration_table[level].good_length;
+ s->nice_match = configuration_table[level].nice_length;
+ s->max_chain_length = configuration_table[level].max_chain;
+ }
+ s->strategy = strategy;
+ return err;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain)
+ z_streamp strm;
+ int good_length;
+ int max_lazy;
+ int nice_length;
+ int max_chain;
+{
+ deflate_state *s;
+
+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ s = strm->state;
+ s->good_match = good_length;
+ s->max_lazy_match = max_lazy;
+ s->nice_match = nice_length;
+ s->max_chain_length = max_chain;
+ return Z_OK;
+}
+
+/* =========================================================================
+ * For the default windowBits of 15 and memLevel of 8, this function returns
+ * a close to exact, as well as small, upper bound on the compressed size.
+ * They are coded as constants here for a reason--if the #define's are
+ * changed, then this function needs to be changed as well. The return
+ * value for 15 and 8 only works for those exact settings.
+ *
+ * For any setting other than those defaults for windowBits and memLevel,
+ * the value returned is a conservative worst case for the maximum expansion
+ * resulting from using fixed blocks instead of stored blocks, which deflate
+ * can emit on compressed data for some combinations of the parameters.
+ *
+ * This function could be more sophisticated to provide closer upper bounds
+ * for every combination of windowBits and memLevel, as well as wrap.
+ * But even the conservative upper bound of about 14% expansion does not
+ * seem onerous for output buffer allocation.
+ */
+uLong ZEXPORT deflateBound(strm, sourceLen)
+ z_streamp strm;
+ uLong sourceLen;
+{
+ deflate_state *s;
+ uLong destLen;
+
+ /* conservative upper bound */
+ destLen = sourceLen +
+ ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 11;
+
+ /* if can't get parameters, return conservative bound */
+ if (strm == Z_NULL || strm->state == Z_NULL)
+ return destLen;
+
+ /* if not default parameters, return conservative bound */
+ s = strm->state;
+ if (s->w_bits != 15 || s->hash_bits != 8 + 7)
+ return destLen;
+
+ /* default settings: return tight bound for that case */
+ return compressBound(sourceLen);
+}
+
+/* =========================================================================
+ * Put a short in the pending buffer. The 16-bit value is put in MSB order.
+ * IN assertion: the stream state is correct and there is enough room in
+ * pending_buf.
+ */
+local void putShortMSB (s, b)
+ deflate_state *s;
+ uInt b;
+{
+ put_byte(s, (Byte)(b >> 8));
+ put_byte(s, (Byte)(b & 0xff));
+}
+
+/* =========================================================================
+ * Flush as much pending output as possible. All deflate() output goes
+ * through this function so some applications may wish to modify it
+ * to avoid allocating a large strm->next_out buffer and copying into it.
+ * (See also read_buf()).
+ */
+local void flush_pending(strm)
+ z_streamp strm;
+{
+ unsigned len = strm->state->pending;
+
+ if (len > strm->avail_out) len = strm->avail_out;
+ if (len == 0) return;
+
+ zmemcpy(strm->next_out, strm->state->pending_out, len);
+ strm->next_out += len;
+ strm->state->pending_out += len;
+ strm->total_out += len;
+ strm->avail_out -= len;
+ strm->state->pending -= len;
+ if (strm->state->pending == 0) {
+ strm->state->pending_out = strm->state->pending_buf;
+ }
+}
+
+/* ========================================================================= */
+int ZEXPORT deflate (strm, flush)
+ z_streamp strm;
+ int flush;
+{
+ int old_flush; /* value of flush param for previous deflate call */
+ deflate_state *s;
+
+ if (strm == Z_NULL || strm->state == Z_NULL ||
+ flush > Z_FINISH || flush < 0) {
+ return Z_STREAM_ERROR;
+ }
+ s = strm->state;
+
+ if (strm->next_out == Z_NULL ||
+ (strm->next_in == Z_NULL && strm->avail_in != 0) ||
+ (s->status == FINISH_STATE && flush != Z_FINISH)) {
+ ERR_RETURN(strm, Z_STREAM_ERROR);
+ }
+ if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR);
+
+ s->strm = strm; /* just in case */
+ old_flush = s->last_flush;
+ s->last_flush = flush;
+
+ /* Write the header */
+ if (s->status == INIT_STATE) {
+#ifdef GZIP
+ if (s->wrap == 2) {
+ strm->adler = crc32(0L, Z_NULL, 0);
+ put_byte(s, 31);
+ put_byte(s, 139);
+ put_byte(s, 8);
+ if (s->gzhead == NULL) {
+ put_byte(s, 0);
+ put_byte(s, 0);
+ put_byte(s, 0);
+ put_byte(s, 0);
+ put_byte(s, 0);
+ put_byte(s, s->level == 9 ? 2 :
+ (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
+ 4 : 0));
+ put_byte(s, OS_CODE);
+ s->status = BUSY_STATE;
+ }
+ else {
+ put_byte(s, (s->gzhead->text ? 1 : 0) +
+ (s->gzhead->hcrc ? 2 : 0) +
+ (s->gzhead->extra == Z_NULL ? 0 : 4) +
+ (s->gzhead->name == Z_NULL ? 0 : 8) +
+ (s->gzhead->comment == Z_NULL ? 0 : 16)
+ );
+ put_byte(s, (Byte)(s->gzhead->time & 0xff));
+ put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff));
+ put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff));
+ put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff));
+ put_byte(s, s->level == 9 ? 2 :
+ (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
+ 4 : 0));
+ put_byte(s, s->gzhead->os & 0xff);
+ if (s->gzhead->extra != NULL) {
+ put_byte(s, s->gzhead->extra_len & 0xff);
+ put_byte(s, (s->gzhead->extra_len >> 8) & 0xff);
+ }
+ if (s->gzhead->hcrc)
+ strm->adler = crc32(strm->adler, s->pending_buf,
+ s->pending);
+ s->gzindex = 0;
+ s->status = EXTRA_STATE;
+ }
+ }
+ else
+#endif
+ {
+ uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8;
+ uInt level_flags;
+
+ if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2)
+ level_flags = 0;
+ else if (s->level < 6)
+ level_flags = 1;
+ else if (s->level == 6)
+ level_flags = 2;
+ else
+ level_flags = 3;
+ header |= (level_flags << 6);
+ if (s->strstart != 0) header |= PRESET_DICT;
+ header += 31 - (header % 31);
+
+ s->status = BUSY_STATE;
+ putShortMSB(s, header);
+
+ /* Save the adler32 of the preset dictionary: */
+ if (s->strstart != 0) {
+ putShortMSB(s, (uInt)(strm->adler >> 16));
+ putShortMSB(s, (uInt)(strm->adler & 0xffff));
+ }
+ strm->adler = adler32(0L, Z_NULL, 0);
+ }
+ }
+#ifdef GZIP
+ if (s->status == EXTRA_STATE) {
+ if (s->gzhead->extra != NULL) {
+ uInt beg = s->pending; /* start of bytes to update crc */
+
+ while (s->gzindex < (s->gzhead->extra_len & 0xffff)) {
+ if (s->pending == s->pending_buf_size) {
+ if (s->gzhead->hcrc && s->pending > beg)
+ strm->adler = crc32(strm->adler, s->pending_buf + beg,
+ s->pending - beg);
+ flush_pending(strm);
+ beg = s->pending;
+ if (s->pending == s->pending_buf_size)
+ break;
+ }
+ put_byte(s, s->gzhead->extra[s->gzindex]);
+ s->gzindex++;
+ }
+ if (s->gzhead->hcrc && s->pending > beg)
+ strm->adler = crc32(strm->adler, s->pending_buf + beg,
+ s->pending - beg);
+ if (s->gzindex == s->gzhead->extra_len) {
+ s->gzindex = 0;
+ s->status = NAME_STATE;
+ }
+ }
+ else
+ s->status = NAME_STATE;
+ }
+ if (s->status == NAME_STATE) {
+ if (s->gzhead->name != NULL) {
+ uInt beg = s->pending; /* start of bytes to update crc */
+ int val;
+
+ do {
+ if (s->pending == s->pending_buf_size) {
+ if (s->gzhead->hcrc && s->pending > beg)
+ strm->adler = crc32(strm->adler, s->pending_buf + beg,
+ s->pending - beg);
+ flush_pending(strm);
+ beg = s->pending;
+ if (s->pending == s->pending_buf_size) {
+ val = 1;
+ break;
+ }
+ }
+ val = s->gzhead->name[s->gzindex++];
+ put_byte(s, val);
+ } while (val != 0);
+ if (s->gzhead->hcrc && s->pending > beg)
+ strm->adler = crc32(strm->adler, s->pending_buf + beg,
+ s->pending - beg);
+ if (val == 0) {
+ s->gzindex = 0;
+ s->status = COMMENT_STATE;
+ }
+ }
+ else
+ s->status = COMMENT_STATE;
+ }
+ if (s->status == COMMENT_STATE) {
+ if (s->gzhead->comment != NULL) {
+ uInt beg = s->pending; /* start of bytes to update crc */
+ int val;
+
+ do {
+ if (s->pending == s->pending_buf_size) {
+ if (s->gzhead->hcrc && s->pending > beg)
+ strm->adler = crc32(strm->adler, s->pending_buf + beg,
+ s->pending - beg);
+ flush_pending(strm);
+ beg = s->pending;
+ if (s->pending == s->pending_buf_size) {
+ val = 1;
+ break;
+ }
+ }
+ val = s->gzhead->comment[s->gzindex++];
+ put_byte(s, val);
+ } while (val != 0);
+ if (s->gzhead->hcrc && s->pending > beg)
+ strm->adler = crc32(strm->adler, s->pending_buf + beg,
+ s->pending - beg);
+ if (val == 0)
+ s->status = HCRC_STATE;
+ }
+ else
+ s->status = HCRC_STATE;
+ }
+ if (s->status == HCRC_STATE) {
+ if (s->gzhead->hcrc) {
+ if (s->pending + 2 > s->pending_buf_size)
+ flush_pending(strm);
+ if (s->pending + 2 <= s->pending_buf_size) {
+ put_byte(s, (Byte)(strm->adler & 0xff));
+ put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
+ strm->adler = crc32(0L, Z_NULL, 0);
+ s->status = BUSY_STATE;
+ }
+ }
+ else
+ s->status = BUSY_STATE;
+ }
+#endif
+
+ /* Flush as much pending output as possible */
+ if (s->pending != 0) {
+ flush_pending(strm);
+ if (strm->avail_out == 0) {
+ /* Since avail_out is 0, deflate will be called again with
+ * more output space, but possibly with both pending and
+ * avail_in equal to zero. There won't be anything to do,
+ * but this is not an error situation so make sure we
+ * return OK instead of BUF_ERROR at next call of deflate:
+ */
+ s->last_flush = -1;
+ return Z_OK;
+ }
+
+ /* Make sure there is something to do and avoid duplicate consecutive
+ * flushes. For repeated and useless calls with Z_FINISH, we keep
+ * returning Z_STREAM_END instead of Z_BUF_ERROR.
+ */
+ } else if (strm->avail_in == 0 && flush <= old_flush &&
+ flush != Z_FINISH) {
+ ERR_RETURN(strm, Z_BUF_ERROR);
+ }
+
+ /* User must not provide more input after the first FINISH: */
+ if (s->status == FINISH_STATE && strm->avail_in != 0) {
+ ERR_RETURN(strm, Z_BUF_ERROR);
+ }
+
+ /* Start a new block or continue the current one.
+ */
+ if (strm->avail_in != 0 || s->lookahead != 0 ||
+ (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) {
+ block_state bstate;
+
+ bstate = (*(configuration_table[s->level].func))(s, flush);
+
+ if (bstate == finish_started || bstate == finish_done) {
+ s->status = FINISH_STATE;
+ }
+ if (bstate == need_more || bstate == finish_started) {
+ if (strm->avail_out == 0) {
+ s->last_flush = -1; /* avoid BUF_ERROR next call, see above */
+ }
+ return Z_OK;
+ /* If flush != Z_NO_FLUSH && avail_out == 0, the next call
+ * of deflate should use the same flush parameter to make sure
+ * that the flush is complete. So we don't have to output an
+ * empty block here, this will be done at next call. This also
+ * ensures that for a very small output buffer, we emit at most
+ * one empty block.
+ */
+ }
+ if (bstate == block_done) {
+ if (flush == Z_PARTIAL_FLUSH) {
+ _tr_align(s);
+ } else { /* FULL_FLUSH or SYNC_FLUSH */
+ _tr_stored_block(s, (char*)0, 0L, 0);
+ /* For a full flush, this empty block will be recognized
+ * as a special marker by inflate_sync().
+ */
+ if (flush == Z_FULL_FLUSH) {
+ CLEAR_HASH(s); /* forget history */
+ }
+ }
+ flush_pending(strm);
+ if (strm->avail_out == 0) {
+ s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */
+ return Z_OK;
+ }
+ }
+ }
+ Assert(strm->avail_out > 0, "bug2");
+
+ if (flush != Z_FINISH) return Z_OK;
+ if (s->wrap <= 0) return Z_STREAM_END;
+
+ /* Write the trailer */
+#ifdef GZIP
+ if (s->wrap == 2) {
+ put_byte(s, (Byte)(strm->adler & 0xff));
+ put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
+ put_byte(s, (Byte)((strm->adler >> 16) & 0xff));
+ put_byte(s, (Byte)((strm->adler >> 24) & 0xff));
+ put_byte(s, (Byte)(strm->total_in & 0xff));
+ put_byte(s, (Byte)((strm->total_in >> 8) & 0xff));
+ put_byte(s, (Byte)((strm->total_in >> 16) & 0xff));
+ put_byte(s, (Byte)((strm->total_in >> 24) & 0xff));
+ }
+ else
+#endif
+ {
+ putShortMSB(s, (uInt)(strm->adler >> 16));
+ putShortMSB(s, (uInt)(strm->adler & 0xffff));
+ }
+ flush_pending(strm);
+ /* If avail_out is zero, the application will call deflate again
+ * to flush the rest.
+ */
+ if (s->wrap > 0) s->wrap = -s->wrap; /* write the trailer only once! */
+ return s->pending != 0 ? Z_OK : Z_STREAM_END;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateEnd (strm)
+ z_streamp strm;
+{
+ int status;
+
+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+
+ status = strm->state->status;
+ if (status != INIT_STATE &&
+ status != EXTRA_STATE &&
+ status != NAME_STATE &&
+ status != COMMENT_STATE &&
+ status != HCRC_STATE &&
+ status != BUSY_STATE &&
+ status != FINISH_STATE) {
+ return Z_STREAM_ERROR;
+ }
+
+ /* Deallocate in reverse order of allocations: */
+ TRY_FREE(strm, strm->state->pending_buf);
+ TRY_FREE(strm, strm->state->head);
+ TRY_FREE(strm, strm->state->prev);
+ TRY_FREE(strm, strm->state->window);
+
+ ZFREE(strm, strm->state);
+ strm->state = Z_NULL;
+
+ return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK;
+}
+
+/* =========================================================================
+ * Copy the source state to the destination state.
+ * To simplify the source, this is not supported for 16-bit MSDOS (which
+ * doesn't have enough memory anyway to duplicate compression states).
+ */
+int ZEXPORT deflateCopy (dest, source)
+ z_streamp dest;
+ z_streamp source;
+{
+#ifdef MAXSEG_64K
+ return Z_STREAM_ERROR;
+#else
+ deflate_state *ds;
+ deflate_state *ss;
+ ushf *overlay;
+
+
+ if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) {
+ return Z_STREAM_ERROR;
+ }
+
+ ss = source->state;
+
+ zmemcpy(dest, source, sizeof(z_stream));
+
+ ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state));
+ if (ds == Z_NULL) return Z_MEM_ERROR;
+ dest->state = (struct internal_state FAR *) ds;
+ zmemcpy(ds, ss, sizeof(deflate_state));
+ ds->strm = dest;
+
+ ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte));
+ ds->prev = (Posf *) ZALLOC(dest, ds->w_size, sizeof(Pos));
+ ds->head = (Posf *) ZALLOC(dest, ds->hash_size, sizeof(Pos));
+ overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof(ush)+2);
+ ds->pending_buf = (uchf *) overlay;
+
+ if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL ||
+ ds->pending_buf == Z_NULL) {
+ deflateEnd (dest);
+ return Z_MEM_ERROR;
+ }
+ /* following zmemcpy do not work for 16-bit MSDOS */
+ zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte));
+ zmemcpy(ds->prev, ss->prev, ds->w_size * sizeof(Pos));
+ zmemcpy(ds->head, ss->head, ds->hash_size * sizeof(Pos));
+ zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size);
+
+ ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf);
+ ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush);
+ ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize;
+
+ ds->l_desc.dyn_tree = ds->dyn_ltree;
+ ds->d_desc.dyn_tree = ds->dyn_dtree;
+ ds->bl_desc.dyn_tree = ds->bl_tree;
+
+ return Z_OK;
+#endif /* MAXSEG_64K */
+}
+
+/* ===========================================================================
+ * Read a new buffer from the current input stream, update the adler32
+ * and total number of bytes read. All deflate() input goes through
+ * this function so some applications may wish to modify it to avoid
+ * allocating a large strm->next_in buffer and copying from it.
+ * (See also flush_pending()).
+ */
+local int read_buf(strm, buf, size)
+ z_streamp strm;
+ Bytef *buf;
+ unsigned size;
+{
+ unsigned len = strm->avail_in;
+
+ if (len > size) len = size;
+ if (len == 0) return 0;
+
+ strm->avail_in -= len;
+
+ if (strm->state->wrap == 1) {
+ strm->adler = adler32(strm->adler, strm->next_in, len);
+ }
+#ifdef GZIP
+ else if (strm->state->wrap == 2) {
+ strm->adler = crc32(strm->adler, strm->next_in, len);
+ }
+#endif
+ zmemcpy(buf, strm->next_in, len);
+ strm->next_in += len;
+ strm->total_in += len;
+
+ return (int)len;
+}
+
+/* ===========================================================================
+ * Initialize the "longest match" routines for a new zlib stream
+ */
+local void lm_init (s)
+ deflate_state *s;
+{
+ s->window_size = (ulg)2L*s->w_size;
+
+ CLEAR_HASH(s);
+
+ /* Set the default configuration parameters:
+ */
+ s->max_lazy_match = configuration_table[s->level].max_lazy;
+ s->good_match = configuration_table[s->level].good_length;
+ s->nice_match = configuration_table[s->level].nice_length;
+ s->max_chain_length = configuration_table[s->level].max_chain;
+
+ s->strstart = 0;
+ s->block_start = 0L;
+ s->lookahead = 0;
+ s->match_length = s->prev_length = MIN_MATCH-1;
+ s->match_available = 0;
+ s->ins_h = 0;
+#ifndef FASTEST
+#ifdef ASMV
+ match_init(); /* initialize the asm code */
+#endif
+#endif
+}
+
+#ifndef FASTEST
+/* ===========================================================================
+ * Set match_start to the longest match starting at the given string and
+ * return its length. Matches shorter or equal to prev_length are discarded,
+ * in which case the result is equal to prev_length and match_start is
+ * garbage.
+ * IN assertions: cur_match is the head of the hash chain for the current
+ * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
+ * OUT assertion: the match length is not greater than s->lookahead.
+ */
+#ifndef ASMV
+/* For 80x86 and 680x0, an optimized version will be provided in match.asm or
+ * match.S. The code will be functionally equivalent.
+ */
+local uInt longest_match(s, cur_match)
+ deflate_state *s;
+ IPos cur_match; /* current match */
+{
+ unsigned chain_length = s->max_chain_length;/* max hash chain length */
+ register Bytef *scan = s->window + s->strstart; /* current string */
+ register Bytef *match; /* matched string */
+ register int len; /* length of current match */
+ int best_len = s->prev_length; /* best match length so far */
+ int nice_match = s->nice_match; /* stop if match long enough */
+ IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
+ s->strstart - (IPos)MAX_DIST(s) : NIL;
+ /* Stop when cur_match becomes <= limit. To simplify the code,
+ * we prevent matches with the string of window index 0.
+ */
+ Posf *prev = s->prev;
+ uInt wmask = s->w_mask;
+
+#ifdef UNALIGNED_OK
+ /* Compare two bytes at a time. Note: this is not always beneficial.
+ * Try with and without -DUNALIGNED_OK to check.
+ */
+ register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
+ register ush scan_start = *(ushf*)scan;
+ register ush scan_end = *(ushf*)(scan+best_len-1);
+#else
+ register Bytef *strend = s->window + s->strstart + MAX_MATCH;
+ register Byte scan_end1 = scan[best_len-1];
+ register Byte scan_end = scan[best_len];
+#endif
+
+ /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
+ * It is easy to get rid of this optimization if necessary.
+ */
+ Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
+
+ /* Do not waste too much time if we already have a good match: */
+ if (s->prev_length >= s->good_match) {
+ chain_length >>= 2;
+ }
+ /* Do not look for matches beyond the end of the input. This is necessary
+ * to make deflate deterministic.
+ */
+ if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
+
+ Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
+
+ do {
+ Assert(cur_match < s->strstart, "no future");
+ match = s->window + cur_match;
+
+ /* Skip to next match if the match length cannot increase
+ * or if the match length is less than 2. Note that the checks below
+ * for insufficient lookahead only occur occasionally for performance
+ * reasons. Therefore uninitialized memory will be accessed, and
+ * conditional jumps will be made that depend on those values.
+ * However the length of the match is limited to the lookahead, so
+ * the output of deflate is not affected by the uninitialized values.
+ */
+#if (defined(UNALIGNED_OK) && MAX_MATCH == 258)
+ /* This code assumes sizeof(unsigned short) == 2. Do not use
+ * UNALIGNED_OK if your compiler uses a different size.
+ */
+ if (*(ushf*)(match+best_len-1) != scan_end ||
+ *(ushf*)match != scan_start) continue;
+
+ /* It is not necessary to compare scan[2] and match[2] since they are
+ * always equal when the other bytes match, given that the hash keys
+ * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at
+ * strstart+3, +5, ... up to strstart+257. We check for insufficient
+ * lookahead only every 4th comparison; the 128th check will be made
+ * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is
+ * necessary to put more guard bytes at the end of the window, or
+ * to check more often for insufficient lookahead.
+ */
+ Assert(scan[2] == match[2], "scan[2]?");
+ scan++, match++;
+ do {
+ } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
+ *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
+ *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
+ *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
+ scan < strend);
+ /* The funny "do {}" generates better code on most compilers */
+
+ /* Here, scan <= window+strstart+257 */
+ Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
+ if (*scan == *match) scan++;
+
+ len = (MAX_MATCH - 1) - (int)(strend-scan);
+ scan = strend - (MAX_MATCH-1);
+
+#else /* UNALIGNED_OK */
+
+ if (match[best_len] != scan_end ||
+ match[best_len-1] != scan_end1 ||
+ *match != *scan ||
+ *++match != scan[1]) continue;
+
+ /* The check at best_len-1 can be removed because it will be made
+ * again later. (This heuristic is not always a win.)
+ * It is not necessary to compare scan[2] and match[2] since they
+ * are always equal when the other bytes match, given that
+ * the hash keys are equal and that HASH_BITS >= 8.
+ */
+ scan += 2, match++;
+ Assert(*scan == *match, "match[2]?");
+
+ /* We check for insufficient lookahead only every 8th comparison;
+ * the 256th check will be made at strstart+258.
+ */
+ do {
+ } while (*++scan == *++match && *++scan == *++match &&
+ *++scan == *++match && *++scan == *++match &&
+ *++scan == *++match && *++scan == *++match &&
+ *++scan == *++match && *++scan == *++match &&
+ scan < strend);
+
+ Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
+
+ len = MAX_MATCH - (int)(strend - scan);
+ scan = strend - MAX_MATCH;
+
+#endif /* UNALIGNED_OK */
+
+ if (len > best_len) {
+ s->match_start = cur_match;
+ best_len = len;
+ if (len >= nice_match) break;
+#ifdef UNALIGNED_OK
+ scan_end = *(ushf*)(scan+best_len-1);
+#else
+ scan_end1 = scan[best_len-1];
+ scan_end = scan[best_len];
+#endif
+ }
+ } while ((cur_match = prev[cur_match & wmask]) > limit
+ && --chain_length != 0);
+
+ if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
+ return s->lookahead;
+}
+#endif /* ASMV */
+#endif /* FASTEST */
+
+/* ---------------------------------------------------------------------------
+ * Optimized version for level == 1 or strategy == Z_RLE only
+ */
+local uInt longest_match_fast(s, cur_match)
+ deflate_state *s;
+ IPos cur_match; /* current match */
+{
+ register Bytef *scan = s->window + s->strstart; /* current string */
+ register Bytef *match; /* matched string */
+ register int len; /* length of current match */
+ register Bytef *strend = s->window + s->strstart + MAX_MATCH;
+
+ /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
+ * It is easy to get rid of this optimization if necessary.
+ */
+ Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
+
+ Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
+
+ Assert(cur_match < s->strstart, "no future");
+
+ match = s->window + cur_match;
+
+ /* Return failure if the match length is less than 2:
+ */
+ if (match[0] != scan[0] || match[1] != scan[1]) return MIN_MATCH-1;
+
+ /* The check at best_len-1 can be removed because it will be made
+ * again later. (This heuristic is not always a win.)
+ * It is not necessary to compare scan[2] and match[2] since they
+ * are always equal when the other bytes match, given that
+ * the hash keys are equal and that HASH_BITS >= 8.
+ */
+ scan += 2, match += 2;
+ Assert(*scan == *match, "match[2]?");
+
+ /* We check for insufficient lookahead only every 8th comparison;
+ * the 256th check will be made at strstart+258.
+ */
+ do {
+ } while (*++scan == *++match && *++scan == *++match &&
+ *++scan == *++match && *++scan == *++match &&
+ *++scan == *++match && *++scan == *++match &&
+ *++scan == *++match && *++scan == *++match &&
+ scan < strend);
+
+ Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
+
+ len = MAX_MATCH - (int)(strend - scan);
+
+ if (len < MIN_MATCH) return MIN_MATCH - 1;
+
+ s->match_start = cur_match;
+ return (uInt)len <= s->lookahead ? (uInt)len : s->lookahead;
+}
+
+#ifdef DEBUG
+/* ===========================================================================
+ * Check that the match at match_start is indeed a match.
+ */
+local void check_match(s, start, match, length)
+ deflate_state *s;
+ IPos start, match;
+ int length;
+{
+ /* check that the match is indeed a match */
+ if (zmemcmp(s->window + match,
+ s->window + start, length) != EQUAL) {
+ fprintf(stderr, " start %u, match %u, length %d\n",
+ start, match, length);
+ do {
+ fprintf(stderr, "%c%c", s->window[match++], s->window[start++]);
+ } while (--length != 0);
+ z_error("invalid match");
+ }
+ if (z_verbose > 1) {
+ fprintf(stderr,"\\[%d,%d]", start-match, length);
+ do { putc(s->window[start++], stderr); } while (--length != 0);
+ }
+}
+#else
+# define check_match(s, start, match, length)
+#endif /* DEBUG */
+
+/* ===========================================================================
+ * Fill the window when the lookahead becomes insufficient.
+ * Updates strstart and lookahead.
+ *
+ * IN assertion: lookahead < MIN_LOOKAHEAD
+ * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
+ * At least one byte has been read, or avail_in == 0; reads are
+ * performed for at least two bytes (required for the zip translate_eol
+ * option -- not supported here).
+ */
+local void fill_window(s)
+ deflate_state *s;
+{
+ register unsigned n, m;
+ register Posf *p;
+ unsigned more; /* Amount of free space at the end of the window. */
+ uInt wsize = s->w_size;
+
+ do {
+ more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart);
+
+ /* Deal with !@#$% 64K limit: */
+ if (sizeof(int) <= 2) {
+ if (more == 0 && s->strstart == 0 && s->lookahead == 0) {
+ more = wsize;
+
+ } else if (more == (unsigned)(-1)) {
+ /* Very unlikely, but possible on 16 bit machine if
+ * strstart == 0 && lookahead == 1 (input done a byte at time)
+ */
+ more--;
+ }
+ }
+
+ /* If the window is almost full and there is insufficient lookahead,
+ * move the upper half to the lower one to make room in the upper half.
+ */
+ if (s->strstart >= wsize+MAX_DIST(s)) {
+
+ zmemcpy(s->window, s->window+wsize, (unsigned)wsize);
+ s->match_start -= wsize;
+ s->strstart -= wsize; /* we now have strstart >= MAX_DIST */
+ s->block_start -= (long) wsize;
+
+ /* Slide the hash table (could be avoided with 32 bit values
+ at the expense of memory usage). We slide even when level == 0
+ to keep the hash table consistent if we switch back to level > 0
+ later. (Using level 0 permanently is not an optimal usage of
+ zlib, so we don't care about this pathological case.)
+ */
+ /* %%% avoid this when Z_RLE */
+ n = s->hash_size;
+ p = &s->head[n];
+ do {
+ m = *--p;
+ *p = (Pos)(m >= wsize ? m-wsize : NIL);
+ } while (--n);
+
+ n = wsize;
+#ifndef FASTEST
+ p = &s->prev[n];
+ do {
+ m = *--p;
+ *p = (Pos)(m >= wsize ? m-wsize : NIL);
+ /* If n is not on any hash chain, prev[n] is garbage but
+ * its value will never be used.
+ */
+ } while (--n);
+#endif
+ more += wsize;
+ }
+ if (s->strm->avail_in == 0) return;
+
+ /* If there was no sliding:
+ * strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
+ * more == window_size - lookahead - strstart
+ * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
+ * => more >= window_size - 2*WSIZE + 2
+ * In the BIG_MEM or MMAP case (not yet supported),
+ * window_size == input_size + MIN_LOOKAHEAD &&
+ * strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.
+ * Otherwise, window_size == 2*WSIZE so more >= 2.
+ * If there was sliding, more >= WSIZE. So in all cases, more >= 2.
+ */
+ Assert(more >= 2, "more < 2");
+
+ n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more);
+ s->lookahead += n;
+
+ /* Initialize the hash value now that we have some input: */
+ if (s->lookahead >= MIN_MATCH) {
+ s->ins_h = s->window[s->strstart];
+ UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
+#if MIN_MATCH != 3
+ Call UPDATE_HASH() MIN_MATCH-3 more times
+#endif
+ }
+ /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
+ * but this is not important since only literal bytes will be emitted.
+ */
+
+ } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0);
+}
+
+/* ===========================================================================
+ * Flush the current block, with given end-of-file flag.
+ * IN assertion: strstart is set to the end of the current match.
+ */
+#define FLUSH_BLOCK_ONLY(s, eof) { \
+ _tr_flush_block(s, (s->block_start >= 0L ? \
+ (charf *)&s->window[(unsigned)s->block_start] : \
+ (charf *)Z_NULL), \
+ (ulg)((long)s->strstart - s->block_start), \
+ (eof)); \
+ s->block_start = s->strstart; \
+ flush_pending(s->strm); \
+ Tracev((stderr,"[FLUSH]")); \
+}
+
+/* Same but force premature exit if necessary. */
+#define FLUSH_BLOCK(s, eof) { \
+ FLUSH_BLOCK_ONLY(s, eof); \
+ if (s->strm->avail_out == 0) return (eof) ? finish_started : need_more; \
+}
+
+/* ===========================================================================
+ * Copy without compression as much as possible from the input stream, return
+ * the current block state.
+ * This function does not insert new strings in the dictionary since
+ * uncompressible data is probably not useful. This function is used
+ * only for the level=0 compression option.
+ * NOTE: this function should be optimized to avoid extra copying from
+ * window to pending_buf.
+ */
+local block_state deflate_stored(s, flush)
+ deflate_state *s;
+ int flush;
+{
+ /* Stored blocks are limited to 0xffff bytes, pending_buf is limited
+ * to pending_buf_size, and each stored block has a 5 byte header:
+ */
+ ulg max_block_size = 0xffff;
+ ulg max_start;
+
+ if (max_block_size > s->pending_buf_size - 5) {
+ max_block_size = s->pending_buf_size - 5;
+ }
+
+ /* Copy as much as possible from input to output: */
+ for (;;) {
+ /* Fill the window as much as possible: */
+ if (s->lookahead <= 1) {
+
+ Assert(s->strstart < s->w_size+MAX_DIST(s) ||
+ s->block_start >= (long)s->w_size, "slide too late");
+
+ fill_window(s);
+ if (s->lookahead == 0 && flush == Z_NO_FLUSH) return need_more;
+
+ if (s->lookahead == 0) break; /* flush the current block */
+ }
+ Assert(s->block_start >= 0L, "block gone");
+
+ s->strstart += s->lookahead;
+ s->lookahead = 0;
+
+ /* Emit a stored block if pending_buf will be full: */
+ max_start = s->block_start + max_block_size;
+ if (s->strstart == 0 || (ulg)s->strstart >= max_start) {
+ /* strstart == 0 is possible when wraparound on 16-bit machine */
+ s->lookahead = (uInt)(s->strstart - max_start);
+ s->strstart = (uInt)max_start;
+ FLUSH_BLOCK(s, 0);
+ }
+ /* Flush if we may have to slide, otherwise block_start may become
+ * negative and the data will be gone:
+ */
+ if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) {
+ FLUSH_BLOCK(s, 0);
+ }
+ }
+ FLUSH_BLOCK(s, flush == Z_FINISH);
+ return flush == Z_FINISH ? finish_done : block_done;
+}
+
+/* ===========================================================================
+ * Compress as much as possible from the input stream, return the current
+ * block state.
+ * This function does not perform lazy evaluation of matches and inserts
+ * new strings in the dictionary only for unmatched strings or for short
+ * matches. It is used only for the fast compression options.
+ */
+local block_state deflate_fast(s, flush)
+ deflate_state *s;
+ int flush;
+{
+ IPos hash_head = NIL; /* head of the hash chain */
+ int bflush; /* set if current block must be flushed */
+
+ for (;;) {
+ /* Make sure that we always have enough lookahead, except
+ * at the end of the input file. We need MAX_MATCH bytes
+ * for the next match, plus MIN_MATCH bytes to insert the
+ * string following the next match.
+ */
+ if (s->lookahead < MIN_LOOKAHEAD) {
+ fill_window(s);
+ if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
+ return need_more;
+ }
+ if (s->lookahead == 0) break; /* flush the current block */
+ }
+
+ /* Insert the string window[strstart .. strstart+2] in the
+ * dictionary, and set hash_head to the head of the hash chain:
+ */
+ if (s->lookahead >= MIN_MATCH) {
+ INSERT_STRING(s, s->strstart, hash_head);
+ }
+
+ /* Find the longest match, discarding those <= prev_length.
+ * At this point we have always match_length < MIN_MATCH
+ */
+ if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) {
+ /* To simplify the code, we prevent matches with the string
+ * of window index 0 (in particular we have to avoid a match
+ * of the string with itself at the start of the input file).
+ */
+#ifdef FASTEST
+ if ((s->strategy != Z_HUFFMAN_ONLY && s->strategy != Z_RLE) ||
+ (s->strategy == Z_RLE && s->strstart - hash_head == 1)) {
+ s->match_length = longest_match_fast (s, hash_head);
+ }
+#else
+ if (s->strategy != Z_HUFFMAN_ONLY && s->strategy != Z_RLE) {
+ s->match_length = longest_match (s, hash_head);
+ } else if (s->strategy == Z_RLE && s->strstart - hash_head == 1) {
+ s->match_length = longest_match_fast (s, hash_head);
+ }
+#endif
+ /* longest_match() or longest_match_fast() sets match_start */
+ }
+ if (s->match_length >= MIN_MATCH) {
+ check_match(s, s->strstart, s->match_start, s->match_length);
+
+ _tr_tally_dist(s, s->strstart - s->match_start,
+ s->match_length - MIN_MATCH, bflush);
+
+ s->lookahead -= s->match_length;
+
+ /* Insert new strings in the hash table only if the match length
+ * is not too large. This saves time but degrades compression.
+ */
+#ifndef FASTEST
+ if (s->match_length <= s->max_insert_length &&
+ s->lookahead >= MIN_MATCH) {
+ s->match_length--; /* string at strstart already in table */
+ do {
+ s->strstart++;
+ INSERT_STRING(s, s->strstart, hash_head);
+ /* strstart never exceeds WSIZE-MAX_MATCH, so there are
+ * always MIN_MATCH bytes ahead.
+ */
+ } while (--s->match_length != 0);
+ s->strstart++;
+ } else
+#endif
+ {
+ s->strstart += s->match_length;
+ s->match_length = 0;
+ s->ins_h = s->window[s->strstart];
+ UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
+#if MIN_MATCH != 3
+ Call UPDATE_HASH() MIN_MATCH-3 more times
+#endif
+ /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not
+ * matter since it will be recomputed at next deflate call.
+ */
+ }
+ } else {
+ /* No match, output a literal byte */
+ Tracevv((stderr,"%c", s->window[s->strstart]));
+ _tr_tally_lit (s, s->window[s->strstart], bflush);
+ s->lookahead--;
+ s->strstart++;
+ }
+ if (bflush) FLUSH_BLOCK(s, 0);
+ }
+ FLUSH_BLOCK(s, flush == Z_FINISH);
+ return flush == Z_FINISH ? finish_done : block_done;
+}
+
+#ifndef FASTEST
+/* ===========================================================================
+ * Same as above, but achieves better compression. We use a lazy
+ * evaluation for matches: a match is finally adopted only if there is
+ * no better match at the next window position.
+ */
+local block_state deflate_slow(s, flush)
+ deflate_state *s;
+ int flush;
+{
+ IPos hash_head = NIL; /* head of hash chain */
+ int bflush; /* set if current block must be flushed */
+
+ /* Process the input block. */
+ for (;;) {
+ /* Make sure that we always have enough lookahead, except
+ * at the end of the input file. We need MAX_MATCH bytes
+ * for the next match, plus MIN_MATCH bytes to insert the
+ * string following the next match.
+ */
+ if (s->lookahead < MIN_LOOKAHEAD) {
+ fill_window(s);
+ if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
+ return need_more;
+ }
+ if (s->lookahead == 0) break; /* flush the current block */
+ }
+
+ /* Insert the string window[strstart .. strstart+2] in the
+ * dictionary, and set hash_head to the head of the hash chain:
+ */
+ if (s->lookahead >= MIN_MATCH) {
+ INSERT_STRING(s, s->strstart, hash_head);
+ }
+
+ /* Find the longest match, discarding those <= prev_length.
+ */
+ s->prev_length = s->match_length, s->prev_match = s->match_start;
+ s->match_length = MIN_MATCH-1;
+
+ if (hash_head != NIL && s->prev_length < s->max_lazy_match &&
+ s->strstart - hash_head <= MAX_DIST(s)) {
+ /* To simplify the code, we prevent matches with the string
+ * of window index 0 (in particular we have to avoid a match
+ * of the string with itself at the start of the input file).
+ */
+ if (s->strategy != Z_HUFFMAN_ONLY && s->strategy != Z_RLE) {
+ s->match_length = longest_match (s, hash_head);
+ } else if (s->strategy == Z_RLE && s->strstart - hash_head == 1) {
+ s->match_length = longest_match_fast (s, hash_head);
+ }
+ /* longest_match() or longest_match_fast() sets match_start */
+
+ if (s->match_length <= 5 && (s->strategy == Z_FILTERED
+#if TOO_FAR <= 32767
+ || (s->match_length == MIN_MATCH &&
+ s->strstart - s->match_start > TOO_FAR)
+#endif
+ )) {
+
+ /* If prev_match is also MIN_MATCH, match_start is garbage
+ * but we will ignore the current match anyway.
+ */
+ s->match_length = MIN_MATCH-1;
+ }
+ }
+ /* If there was a match at the previous step and the current
+ * match is not better, output the previous match:
+ */
+ if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) {
+ uInt max_insert = s->strstart + s->lookahead - MIN_MATCH;
+ /* Do not insert strings in hash table beyond this. */
+
+ check_match(s, s->strstart-1, s->prev_match, s->prev_length);
+
+ _tr_tally_dist(s, s->strstart -1 - s->prev_match,
+ s->prev_length - MIN_MATCH, bflush);
+
+ /* Insert in hash table all strings up to the end of the match.
+ * strstart-1 and strstart are already inserted. If there is not
+ * enough lookahead, the last two strings are not inserted in
+ * the hash table.
+ */
+ s->lookahead -= s->prev_length-1;
+ s->prev_length -= 2;
+ do {
+ if (++s->strstart <= max_insert) {
+ INSERT_STRING(s, s->strstart, hash_head);
+ }
+ } while (--s->prev_length != 0);
+ s->match_available = 0;
+ s->match_length = MIN_MATCH-1;
+ s->strstart++;
+
+ if (bflush) FLUSH_BLOCK(s, 0);
+
+ } else if (s->match_available) {
+ /* If there was no match at the previous position, output a
+ * single literal. If there was a match but the current match
+ * is longer, truncate the previous match to a single literal.
+ */
+ Tracevv((stderr,"%c", s->window[s->strstart-1]));
+ _tr_tally_lit(s, s->window[s->strstart-1], bflush);
+ if (bflush) {
+ FLUSH_BLOCK_ONLY(s, 0);
+ }
+ s->strstart++;
+ s->lookahead--;
+ if (s->strm->avail_out == 0) return need_more;
+ } else {
+ /* There is no previous match to compare with, wait for
+ * the next step to decide.
+ */
+ s->match_available = 1;
+ s->strstart++;
+ s->lookahead--;
+ }
+ }
+ Assert (flush != Z_NO_FLUSH, "no flush?");
+ if (s->match_available) {
+ Tracevv((stderr,"%c", s->window[s->strstart-1]));
+ _tr_tally_lit(s, s->window[s->strstart-1], bflush);
+ s->match_available = 0;
+ }
+ FLUSH_BLOCK(s, flush == Z_FINISH);
+ return flush == Z_FINISH ? finish_done : block_done;
+}
+#endif /* FASTEST */
+
+#if 0
+/* ===========================================================================
+ * For Z_RLE, simply look for runs of bytes, generate matches only of distance
+ * one. Do not maintain a hash table. (It will be regenerated if this run of
+ * deflate switches away from Z_RLE.)
+ */
+local block_state deflate_rle(s, flush)
+ deflate_state *s;
+ int flush;
+{
+ int bflush; /* set if current block must be flushed */
+ uInt run; /* length of run */
+ uInt max; /* maximum length of run */
+ uInt prev; /* byte at distance one to match */
+ Bytef *scan; /* scan for end of run */
+
+ for (;;) {
+ /* Make sure that we always have enough lookahead, except
+ * at the end of the input file. We need MAX_MATCH bytes
+ * for the longest encodable run.
+ */
+ if (s->lookahead < MAX_MATCH) {
+ fill_window(s);
+ if (s->lookahead < MAX_MATCH && flush == Z_NO_FLUSH) {
+ return need_more;
+ }
+ if (s->lookahead == 0) break; /* flush the current block */
+ }
+
+ /* See how many times the previous byte repeats */
+ run = 0;
+ if (s->strstart > 0) { /* if there is a previous byte, that is */
+ max = s->lookahead < MAX_MATCH ? s->lookahead : MAX_MATCH;
+ scan = s->window + s->strstart - 1;
+ prev = *scan++;
+ do {
+ if (*scan++ != prev)
+ break;
+ } while (++run < max);
+ }
+
+ /* Emit match if have run of MIN_MATCH or longer, else emit literal */
+ if (run >= MIN_MATCH) {
+ check_match(s, s->strstart, s->strstart - 1, run);
+ _tr_tally_dist(s, 1, run - MIN_MATCH, bflush);
+ s->lookahead -= run;
+ s->strstart += run;
+ } else {
+ /* No match, output a literal byte */
+ Tracevv((stderr,"%c", s->window[s->strstart]));
+ _tr_tally_lit (s, s->window[s->strstart], bflush);
+ s->lookahead--;
+ s->strstart++;
+ }
+ if (bflush) FLUSH_BLOCK(s, 0);
+ }
+ FLUSH_BLOCK(s, flush == Z_FINISH);
+ return flush == Z_FINISH ? finish_done : block_done;
+}
+#endif
--- /dev/null
+/* deflate.h -- internal compression state
+ * Copyright (C) 1995-2004 Jean-loup Gailly
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+ part of the implementation of the compression library and is
+ subject to change. Applications should only use zlib.h.
+ */
+
+/* @(#) $Id$ */
+
+#ifndef DEFLATE_H
+#define DEFLATE_H
+
+#include "zutil.h"
+
+/* define NO_GZIP when compiling if you want to disable gzip header and
+ trailer creation by deflate(). NO_GZIP would be used to avoid linking in
+ the crc code when it is not needed. For shared libraries, gzip encoding
+ should be left enabled. */
+#ifndef NO_GZIP
+# define GZIP
+#endif
+
+/* ===========================================================================
+ * Internal compression state.
+ */
+
+#define LENGTH_CODES 29
+/* number of length codes, not counting the special END_BLOCK code */
+
+#define LITERALS 256
+/* number of literal bytes 0..255 */
+
+#define L_CODES (LITERALS+1+LENGTH_CODES)
+/* number of Literal or Length codes, including the END_BLOCK code */
+
+#define D_CODES 30
+/* number of distance codes */
+
+#define BL_CODES 19
+/* number of codes used to transfer the bit lengths */
+
+#define HEAP_SIZE (2*L_CODES+1)
+/* maximum heap size */
+
+#define MAX_BITS 15
+/* All codes must not exceed MAX_BITS bits */
+
+#define INIT_STATE 42
+#define EXTRA_STATE 69
+#define NAME_STATE 73
+#define COMMENT_STATE 91
+#define HCRC_STATE 103
+#define BUSY_STATE 113
+#define FINISH_STATE 666
+/* Stream status */
+
+
+/* Data structure describing a single value and its code string. */
+typedef struct ct_data_s {
+ union {
+ ush freq; /* frequency count */
+ ush code; /* bit string */
+ } fc;
+ union {
+ ush dad; /* father node in Huffman tree */
+ ush len; /* length of bit string */
+ } dl;
+} FAR ct_data;
+
+#define Freq fc.freq
+#define Code fc.code
+#define Dad dl.dad
+#define Len dl.len
+
+typedef struct static_tree_desc_s static_tree_desc;
+
+typedef struct tree_desc_s {
+ ct_data *dyn_tree; /* the dynamic tree */
+ int max_code; /* largest code with non zero frequency */
+ static_tree_desc *stat_desc; /* the corresponding static tree */
+} FAR tree_desc;
+
+typedef ush Pos;
+typedef Pos FAR Posf;
+typedef unsigned IPos;
+
+/* A Pos is an index in the character window. We use short instead of int to
+ * save space in the various tables. IPos is used only for parameter passing.
+ */
+
+typedef struct internal_state {
+ z_streamp strm; /* pointer back to this zlib stream */
+ int status; /* as the name implies */
+ Bytef *pending_buf; /* output still pending */
+ ulg pending_buf_size; /* size of pending_buf */
+ Bytef *pending_out; /* next pending byte to output to the stream */
+ uInt pending; /* nb of bytes in the pending buffer */
+ int wrap; /* bit 0 true for zlib, bit 1 true for gzip */
+ gz_headerp gzhead; /* gzip header information to write */
+ uInt gzindex; /* where in extra, name, or comment */
+ Byte method; /* STORED (for zip only) or DEFLATED */
+ int last_flush; /* value of flush param for previous deflate call */
+
+ /* used by deflate.c: */
+
+ uInt w_size; /* LZ77 window size (32K by default) */
+ uInt w_bits; /* log2(w_size) (8..16) */
+ uInt w_mask; /* w_size - 1 */
+
+ Bytef *window;
+ /* Sliding window. Input bytes are read into the second half of the window,
+ * and move to the first half later to keep a dictionary of at least wSize
+ * bytes. With this organization, matches are limited to a distance of
+ * wSize-MAX_MATCH bytes, but this ensures that IO is always
+ * performed with a length multiple of the block size. Also, it limits
+ * the window size to 64K, which is quite useful on MSDOS.
+ * To do: use the user input buffer as sliding window.
+ */
+
+ ulg window_size;
+ /* Actual size of window: 2*wSize, except when the user input buffer
+ * is directly used as sliding window.
+ */
+
+ Posf *prev;
+ /* Link to older string with same hash index. To limit the size of this
+ * array to 64K, this link is maintained only for the last 32K strings.
+ * An index in this array is thus a window index modulo 32K.
+ */
+
+ Posf *head; /* Heads of the hash chains or NIL. */
+
+ uInt ins_h; /* hash index of string to be inserted */
+ uInt hash_size; /* number of elements in hash table */
+ uInt hash_bits; /* log2(hash_size) */
+ uInt hash_mask; /* hash_size-1 */
+
+ uInt hash_shift;
+ /* Number of bits by which ins_h must be shifted at each input
+ * step. It must be such that after MIN_MATCH steps, the oldest
+ * byte no longer takes part in the hash key, that is:
+ * hash_shift * MIN_MATCH >= hash_bits
+ */
+
+ long block_start;
+ /* Window position at the beginning of the current output block. Gets
+ * negative when the window is moved backwards.
+ */
+
+ uInt match_length; /* length of best match */
+ IPos prev_match; /* previous match */
+ int match_available; /* set if previous match exists */
+ uInt strstart; /* start of string to insert */
+ uInt match_start; /* start of matching string */
+ uInt lookahead; /* number of valid bytes ahead in window */
+
+ uInt prev_length;
+ /* Length of the best match at previous step. Matches not greater than this
+ * are discarded. This is used in the lazy match evaluation.
+ */
+
+ uInt max_chain_length;
+ /* To speed up deflation, hash chains are never searched beyond this
+ * length. A higher limit improves compression ratio but degrades the
+ * speed.
+ */
+
+ uInt max_lazy_match;
+ /* Attempt to find a better match only when the current match is strictly
+ * smaller than this value. This mechanism is used only for compression
+ * levels >= 4.
+ */
+# define max_insert_length max_lazy_match
+ /* Insert new strings in the hash table only if the match length is not
+ * greater than this length. This saves time but degrades compression.
+ * max_insert_length is used only for compression levels <= 3.
+ */
+
+ int level; /* compression level (1..9) */
+ int strategy; /* favor or force Huffman coding*/
+
+ uInt good_match;
+ /* Use a faster search when the previous match is longer than this */
+
+ int nice_match; /* Stop searching when current match exceeds this */
+
+ /* used by trees.c: */
+ /* Didn't use ct_data typedef below to supress compiler warning */
+ struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */
+ struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */
+ struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */
+
+ struct tree_desc_s l_desc; /* desc. for literal tree */
+ struct tree_desc_s d_desc; /* desc. for distance tree */
+ struct tree_desc_s bl_desc; /* desc. for bit length tree */
+
+ ush bl_count[MAX_BITS+1];
+ /* number of codes at each bit length for an optimal tree */
+
+ int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */
+ int heap_len; /* number of elements in the heap */
+ int heap_max; /* element of largest frequency */
+ /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
+ * The same heap array is used to build all trees.
+ */
+
+ uch depth[2*L_CODES+1];
+ /* Depth of each subtree used as tie breaker for trees of equal frequency
+ */
+
+ uchf *l_buf; /* buffer for literals or lengths */
+
+ uInt lit_bufsize;
+ /* Size of match buffer for literals/lengths. There are 4 reasons for
+ * limiting lit_bufsize to 64K:
+ * - frequencies can be kept in 16 bit counters
+ * - if compression is not successful for the first block, all input
+ * data is still in the window so we can still emit a stored block even
+ * when input comes from standard input. (This can also be done for
+ * all blocks if lit_bufsize is not greater than 32K.)
+ * - if compression is not successful for a file smaller than 64K, we can
+ * even emit a stored file instead of a stored block (saving 5 bytes).
+ * This is applicable only for zip (not gzip or zlib).
+ * - creating new Huffman trees less frequently may not provide fast
+ * adaptation to changes in the input data statistics. (Take for
+ * example a binary file with poorly compressible code followed by
+ * a highly compressible string table.) Smaller buffer sizes give
+ * fast adaptation but have of course the overhead of transmitting
+ * trees more frequently.
+ * - I can't count above 4
+ */
+
+ uInt last_lit; /* running index in l_buf */
+
+ ushf *d_buf;
+ /* Buffer for distances. To simplify the code, d_buf and l_buf have
+ * the same number of elements. To use different lengths, an extra flag
+ * array would be necessary.
+ */
+
+ ulg opt_len; /* bit length of current block with optimal trees */
+ ulg static_len; /* bit length of current block with static trees */
+ uInt matches; /* number of string matches in current block */
+ int last_eob_len; /* bit length of EOB code for last block */
+
+#ifdef DEBUG
+ ulg compressed_len; /* total bit length of compressed file mod 2^32 */
+ ulg bits_sent; /* bit length of compressed data sent mod 2^32 */
+#endif
+
+ ush bi_buf;
+ /* Output buffer. bits are inserted starting at the bottom (least
+ * significant bits).
+ */
+ int bi_valid;
+ /* Number of valid bits in bi_buf. All bits above the last valid bit
+ * are always zero.
+ */
+
+} FAR deflate_state;
+
+/* Output a byte on the stream.
+ * IN assertion: there is enough room in pending_buf.
+ */
+#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);}
+
+
+#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
+/* Minimum amount of lookahead, except at the end of the input file.
+ * See deflate.c for comments about the MIN_MATCH+1.
+ */
+
+#define MAX_DIST(s) ((s)->w_size-MIN_LOOKAHEAD)
+/* In order to simplify the code, particularly on 16 bit machines, match
+ * distances are limited to MAX_DIST instead of WSIZE.
+ */
+
+ /* in trees.c */
+void _tr_init OF((deflate_state *s));
+int _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc));
+void _tr_flush_block OF((deflate_state *s, charf *buf, ulg stored_len,
+ int eof));
+void _tr_align OF((deflate_state *s));
+void _tr_stored_block OF((deflate_state *s, charf *buf, ulg stored_len,
+ int eof));
+
+#define d_code(dist) \
+ ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)])
+/* Mapping from a distance to a distance code. dist is the distance - 1 and
+ * must not have side effects. _dist_code[256] and _dist_code[257] are never
+ * used.
+ */
+
+#ifndef DEBUG
+/* Inline versions of _tr_tally for speed: */
+
+#if defined(GEN_TREES_H) || !defined(STDC)
+ extern uch _length_code[];
+ extern uch _dist_code[];
+#else
+ extern const uch _length_code[];
+ extern const uch _dist_code[];
+#endif
+
+# define _tr_tally_lit(s, c, flush) \
+ { uch cc = (c); \
+ s->d_buf[s->last_lit] = 0; \
+ s->l_buf[s->last_lit++] = cc; \
+ s->dyn_ltree[cc].Freq++; \
+ flush = (s->last_lit == s->lit_bufsize-1); \
+ }
+# define _tr_tally_dist(s, distance, length, flush) \
+ { uch len = (length); \
+ ush dist = (distance); \
+ s->d_buf[s->last_lit] = dist; \
+ s->l_buf[s->last_lit++] = len; \
+ dist--; \
+ s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \
+ s->dyn_dtree[d_code(dist)].Freq++; \
+ flush = (s->last_lit == s->lit_bufsize-1); \
+ }
+#else
+# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c)
+# define _tr_tally_dist(s, distance, length, flush) \
+ flush = _tr_tally(s, distance, length)
+#endif
+
+#endif /* DEFLATE_H */
--- /dev/null
+/* gzio.c -- IO on .gz files
+ * Copyright (C) 1995-2005 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ *
+ * Compile this file with -DNO_GZCOMPRESS to avoid the compression code.
+ */
+
+/* @(#) $Id$ */
+
+#include <stdio.h>
+
+#include "zutil.h"
+
+#ifdef NO_DEFLATE /* for compatibility with old definition */
+# define NO_GZCOMPRESS
+#endif
+
+#ifndef NO_DUMMY_DECL
+struct internal_state {int dummy;}; /* for buggy compilers */
+#endif
+
+#ifndef Z_BUFSIZE
+# ifdef MAXSEG_64K
+# define Z_BUFSIZE 4096 /* minimize memory usage for 16-bit DOS */
+# else
+# define Z_BUFSIZE 16384
+# endif
+#endif
+#ifndef Z_PRINTF_BUFSIZE
+# define Z_PRINTF_BUFSIZE 4096
+#endif
+
+#ifdef __MVS__
+# pragma map (fdopen , "\174\174FDOPEN")
+ FILE *fdopen(int, const char *);
+#endif
+
+#ifndef STDC
+extern voidp malloc OF((uInt size));
+extern void free OF((voidpf ptr));
+#endif
+
+#define ALLOC(size) malloc(size)
+#define TRYFREE(p) {if (p) free(p);}
+
+static int const gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */
+
+/* gzip flag byte */
+#define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */
+#define HEAD_CRC 0x02 /* bit 1 set: header CRC present */
+#define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */
+#define ORIG_NAME 0x08 /* bit 3 set: original file name present */
+#define COMMENT 0x10 /* bit 4 set: file comment present */
+#define RESERVED 0xE0 /* bits 5..7: reserved */
+
+typedef struct gz_stream {
+ z_stream stream;
+ int z_err; /* error code for last stream operation */
+ int z_eof; /* set if end of input file */
+ FILE *file; /* .gz file */
+ Byte *inbuf; /* input buffer */
+ Byte *outbuf; /* output buffer */
+ uLong crc; /* crc32 of uncompressed data */
+ char *msg; /* error message */
+ char *path; /* path name for debugging only */
+ int transparent; /* 1 if input file is not a .gz file */
+ char mode; /* 'w' or 'r' */
+ z_off_t start; /* start of compressed data in file (header skipped) */
+ z_off_t in; /* bytes into deflate or inflate */
+ z_off_t out; /* bytes out of deflate or inflate */
+ int back; /* one character push-back */
+ int last; /* true if push-back is last character */
+} gz_stream;
+
+
+local gzFile gz_open OF((const char *path, const char *mode, int fd));
+local int do_flush OF((gzFile file, int flush));
+local int get_byte OF((gz_stream *s));
+local void check_header OF((gz_stream *s));
+local int destroy OF((gz_stream *s));
+local void putLong OF((FILE *file, uLong x));
+local uLong getLong OF((gz_stream *s));
+
+/* ===========================================================================
+ Opens a gzip (.gz) file for reading or writing. The mode parameter
+ is as in fopen ("rb" or "wb"). The file is given either by file descriptor
+ or path name (if fd == -1).
+ gz_open returns NULL if the file could not be opened or if there was
+ insufficient memory to allocate the (de)compression state; errno
+ can be checked to distinguish the two cases (if errno is zero, the
+ zlib error is Z_MEM_ERROR).
+*/
+local gzFile gz_open (path, mode, fd)
+ const char *path;
+ const char *mode;
+ int fd;
+{
+ int err;
+ int level = Z_DEFAULT_COMPRESSION; /* compression level */
+ int strategy = Z_DEFAULT_STRATEGY; /* compression strategy */
+ char *p = (char*)mode;
+ gz_stream *s;
+ char fmode[80]; /* copy of mode, without the compression level */
+ char *m = fmode;
+
+ if (!path || !mode) return Z_NULL;
+
+ s = (gz_stream *)ALLOC(sizeof(gz_stream));
+ if (!s) return Z_NULL;
+
+ s->stream.zalloc = (alloc_func)0;
+ s->stream.zfree = (free_func)0;
+ s->stream.opaque = (voidpf)0;
+ s->stream.next_in = s->inbuf = Z_NULL;
+ s->stream.next_out = s->outbuf = Z_NULL;
+ s->stream.avail_in = s->stream.avail_out = 0;
+ s->file = NULL;
+ s->z_err = Z_OK;
+ s->z_eof = 0;
+ s->in = 0;
+ s->out = 0;
+ s->back = EOF;
+ s->crc = crc32(0L, Z_NULL, 0);
+ s->msg = NULL;
+ s->transparent = 0;
+
+ s->path = (char*)ALLOC(strlen(path)+1);
+ if (s->path == NULL) {
+ return destroy(s), (gzFile)Z_NULL;
+ }
+ strcpy(s->path, path); /* do this early for debugging */
+
+ s->mode = '\0';
+ do {
+ if (*p == 'r') s->mode = 'r';
+ if (*p == 'w' || *p == 'a') s->mode = 'w';
+ if (*p >= '0' && *p <= '9') {
+ level = *p - '0';
+ } else if (*p == 'f') {
+ strategy = Z_FILTERED;
+ } else if (*p == 'h') {
+ strategy = Z_HUFFMAN_ONLY;
+ } else if (*p == 'R') {
+ strategy = Z_RLE;
+ } else {
+ *m++ = *p; /* copy the mode */
+ }
+ } while (*p++ && m != fmode + sizeof(fmode));
+ if (s->mode == '\0') return destroy(s), (gzFile)Z_NULL;
+
+ if (s->mode == 'w') {
+#ifdef NO_GZCOMPRESS
+ err = Z_STREAM_ERROR;
+#else
+ err = deflateInit2(&(s->stream), level,
+ Z_DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, strategy);
+ /* windowBits is passed < 0 to suppress zlib header */
+
+ s->stream.next_out = s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
+#endif
+ if (err != Z_OK || s->outbuf == Z_NULL) {
+ return destroy(s), (gzFile)Z_NULL;
+ }
+ } else {
+ s->stream.next_in = s->inbuf = (Byte*)ALLOC(Z_BUFSIZE);
+
+ err = inflateInit2(&(s->stream), -MAX_WBITS);
+ /* windowBits is passed < 0 to tell that there is no zlib header.
+ * Note that in this case inflate *requires* an extra "dummy" byte
+ * after the compressed stream in order to complete decompression and
+ * return Z_STREAM_END. Here the gzip CRC32 ensures that 4 bytes are
+ * present after the compressed stream.
+ */
+ if (err != Z_OK || s->inbuf == Z_NULL) {
+ return destroy(s), (gzFile)Z_NULL;
+ }
+ }
+ s->stream.avail_out = Z_BUFSIZE;
+
+ errno = 0;
+ s->file = fd < 0 ? F_OPEN(path, fmode) : (FILE*)fdopen(fd, fmode);
+
+ if (s->file == NULL) {
+ return destroy(s), (gzFile)Z_NULL;
+ }
+ if (s->mode == 'w') {
+ /* Write a very simple .gz header:
+ */
+ fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", gz_magic[0], gz_magic[1],
+ Z_DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE);
+ s->start = 10L;
+ /* We use 10L instead of ftell(s->file) to because ftell causes an
+ * fflush on some systems. This version of the library doesn't use
+ * start anyway in write mode, so this initialization is not
+ * necessary.
+ */
+ } else {
+ check_header(s); /* skip the .gz header */
+ s->start = ftell(s->file) - s->stream.avail_in;
+ }
+
+ return (gzFile)s;
+}
+
+/* ===========================================================================
+ Opens a gzip (.gz) file for reading or writing.
+*/
+gzFile ZEXPORT gzopen (path, mode)
+ const char *path;
+ const char *mode;
+{
+ return gz_open (path, mode, -1);
+}
+
+/* ===========================================================================
+ Associate a gzFile with the file descriptor fd. fd is not dup'ed here
+ to mimic the behavio(u)r of fdopen.
+*/
+gzFile ZEXPORT gzdopen (fd, mode)
+ int fd;
+ const char *mode;
+{
+ char name[46]; /* allow for up to 128-bit integers */
+
+ if (fd < 0) return (gzFile)Z_NULL;
+ sprintf(name, "<fd:%d>", fd); /* for debugging */
+
+ return gz_open (name, mode, fd);
+}
+
+/* ===========================================================================
+ * Update the compression level and strategy
+ */
+int ZEXPORT gzsetparams (file, level, strategy)
+ gzFile file;
+ int level;
+ int strategy;
+{
+ gz_stream *s = (gz_stream*)file;
+
+ if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
+
+ /* Make room to allow flushing */
+ if (s->stream.avail_out == 0) {
+
+ s->stream.next_out = s->outbuf;
+ if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
+ s->z_err = Z_ERRNO;
+ }
+ s->stream.avail_out = Z_BUFSIZE;
+ }
+
+ return deflateParams (&(s->stream), level, strategy);
+}
+
+/* ===========================================================================
+ Read a byte from a gz_stream; update next_in and avail_in. Return EOF
+ for end of file.
+ IN assertion: the stream s has been sucessfully opened for reading.
+*/
+local int get_byte(s)
+ gz_stream *s;
+{
+ if (s->z_eof) return EOF;
+ if (s->stream.avail_in == 0) {
+ errno = 0;
+ s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file);
+ if (s->stream.avail_in == 0) {
+ s->z_eof = 1;
+ if (ferror(s->file)) s->z_err = Z_ERRNO;
+ return EOF;
+ }
+ s->stream.next_in = s->inbuf;
+ }
+ s->stream.avail_in--;
+ return *(s->stream.next_in)++;
+}
+
+/* ===========================================================================
+ Check the gzip header of a gz_stream opened for reading. Set the stream
+ mode to transparent if the gzip magic header is not present; set s->err
+ to Z_DATA_ERROR if the magic header is present but the rest of the header
+ is incorrect.
+ IN assertion: the stream s has already been created sucessfully;
+ s->stream.avail_in is zero for the first time, but may be non-zero
+ for concatenated .gz files.
+*/
+local void check_header(s)
+ gz_stream *s;
+{
+ int method; /* method byte */
+ int flags; /* flags byte */
+ uInt len;
+ int c;
+
+ /* Assure two bytes in the buffer so we can peek ahead -- handle case
+ where first byte of header is at the end of the buffer after the last
+ gzip segment */
+ len = s->stream.avail_in;
+ if (len < 2) {
+ if (len) s->inbuf[0] = s->stream.next_in[0];
+ errno = 0;
+ len = (uInt)fread(s->inbuf + len, 1, Z_BUFSIZE >> len, s->file);
+ if (len == 0 && ferror(s->file)) s->z_err = Z_ERRNO;
+ s->stream.avail_in += len;
+ s->stream.next_in = s->inbuf;
+ if (s->stream.avail_in < 2) {
+ s->transparent = s->stream.avail_in;
+ return;
+ }
+ }
+
+ /* Peek ahead to check the gzip magic header */
+ if (s->stream.next_in[0] != gz_magic[0] ||
+ s->stream.next_in[1] != gz_magic[1]) {
+ s->transparent = 1;
+ return;
+ }
+ s->stream.avail_in -= 2;
+ s->stream.next_in += 2;
+
+ /* Check the rest of the gzip header */
+ method = get_byte(s);
+ flags = get_byte(s);
+ if (method != Z_DEFLATED || (flags & RESERVED) != 0) {
+ s->z_err = Z_DATA_ERROR;
+ return;
+ }
+
+ /* Discard time, xflags and OS code: */
+ for (len = 0; len < 6; len++) (void)get_byte(s);
+
+ if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */
+ len = (uInt)get_byte(s);
+ len += ((uInt)get_byte(s))<<8;
+ /* len is garbage if EOF but the loop below will quit anyway */
+ while (len-- != 0 && get_byte(s) != EOF) ;
+ }
+ if ((flags & ORIG_NAME) != 0) { /* skip the original file name */
+ while ((c = get_byte(s)) != 0 && c != EOF) ;
+ }
+ if ((flags & COMMENT) != 0) { /* skip the .gz file comment */
+ while ((c = get_byte(s)) != 0 && c != EOF) ;
+ }
+ if ((flags & HEAD_CRC) != 0) { /* skip the header crc */
+ for (len = 0; len < 2; len++) (void)get_byte(s);
+ }
+ s->z_err = s->z_eof ? Z_DATA_ERROR : Z_OK;
+}
+
+ /* ===========================================================================
+ * Cleanup then free the given gz_stream. Return a zlib error code.
+ Try freeing in the reverse order of allocations.
+ */
+local int destroy (s)
+ gz_stream *s;
+{
+ int err = Z_OK;
+
+ if (!s) return Z_STREAM_ERROR;
+
+ TRYFREE(s->msg);
+
+ if (s->stream.state != NULL) {
+ if (s->mode == 'w') {
+#ifdef NO_GZCOMPRESS
+ err = Z_STREAM_ERROR;
+#else
+ err = deflateEnd(&(s->stream));
+#endif
+ } else if (s->mode == 'r') {
+ err = inflateEnd(&(s->stream));
+ }
+ }
+ if (s->file != NULL && fclose(s->file)) {
+#ifdef ESPIPE
+ if (errno != ESPIPE) /* fclose is broken for pipes in HP/UX */
+#endif
+ err = Z_ERRNO;
+ }
+ if (s->z_err < 0) err = s->z_err;
+
+ TRYFREE(s->inbuf);
+ TRYFREE(s->outbuf);
+ TRYFREE(s->path);
+ TRYFREE(s);
+ return err;
+}
+
+/* ===========================================================================
+ Reads the given number of uncompressed bytes from the compressed file.
+ gzread returns the number of bytes actually read (0 for end of file).
+*/
+int ZEXPORT gzread (file, buf, len)
+ gzFile file;
+ voidp buf;
+ unsigned len;
+{
+ gz_stream *s = (gz_stream*)file;
+ Bytef *start = (Bytef*)buf; /* starting point for crc computation */
+ Byte *next_out; /* == stream.next_out but not forced far (for MSDOS) */
+
+ if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR;
+
+ if (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO) return -1;
+ if (s->z_err == Z_STREAM_END) return 0; /* EOF */
+
+ next_out = (Byte*)buf;
+ s->stream.next_out = (Bytef*)buf;
+ s->stream.avail_out = len;
+
+ if (s->stream.avail_out && s->back != EOF) {
+ *next_out++ = s->back;
+ s->stream.next_out++;
+ s->stream.avail_out--;
+ s->back = EOF;
+ s->out++;
+ start++;
+ if (s->last) {
+ s->z_err = Z_STREAM_END;
+ return 1;
+ }
+ }
+
+ while (s->stream.avail_out != 0) {
+
+ if (s->transparent) {
+ /* Copy first the lookahead bytes: */
+ uInt n = s->stream.avail_in;
+ if (n > s->stream.avail_out) n = s->stream.avail_out;
+ if (n > 0) {
+ zmemcpy(s->stream.next_out, s->stream.next_in, n);
+ next_out += n;
+ s->stream.next_out = next_out;
+ s->stream.next_in += n;
+ s->stream.avail_out -= n;
+ s->stream.avail_in -= n;
+ }
+ if (s->stream.avail_out > 0) {
+ s->stream.avail_out -=
+ (uInt)fread(next_out, 1, s->stream.avail_out, s->file);
+ }
+ len -= s->stream.avail_out;
+ s->in += len;
+ s->out += len;
+ if (len == 0) s->z_eof = 1;
+ return (int)len;
+ }
+ if (s->stream.avail_in == 0 && !s->z_eof) {
+
+ errno = 0;
+ s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file);
+ if (s->stream.avail_in == 0) {
+ s->z_eof = 1;
+ if (ferror(s->file)) {
+ s->z_err = Z_ERRNO;
+ break;
+ }
+ }
+ s->stream.next_in = s->inbuf;
+ }
+ s->in += s->stream.avail_in;
+ s->out += s->stream.avail_out;
+ s->z_err = inflate(&(s->stream), Z_NO_FLUSH);
+ s->in -= s->stream.avail_in;
+ s->out -= s->stream.avail_out;
+
+ if (s->z_err == Z_STREAM_END) {
+ /* Check CRC and original size */
+ s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
+ start = s->stream.next_out;
+
+ if (getLong(s) != s->crc) {
+ s->z_err = Z_DATA_ERROR;
+ } else {
+ (void)getLong(s);
+ /* The uncompressed length returned by above getlong() may be
+ * different from s->out in case of concatenated .gz files.
+ * Check for such files:
+ */
+ check_header(s);
+ if (s->z_err == Z_OK) {
+ inflateReset(&(s->stream));
+ s->crc = crc32(0L, Z_NULL, 0);
+ }
+ }
+ }
+ if (s->z_err != Z_OK || s->z_eof) break;
+ }
+ s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
+
+ if (len == s->stream.avail_out &&
+ (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO))
+ return -1;
+ return (int)(len - s->stream.avail_out);
+}
+
+
+/* ===========================================================================
+ Reads one byte from the compressed file. gzgetc returns this byte
+ or -1 in case of end of file or error.
+*/
+int ZEXPORT gzgetc(file)
+ gzFile file;
+{
+ unsigned char c;
+
+ return gzread(file, &c, 1) == 1 ? c : -1;
+}
+
+
+/* ===========================================================================
+ Push one byte back onto the stream.
+*/
+int ZEXPORT gzungetc(c, file)
+ int c;
+ gzFile file;
+{
+ gz_stream *s = (gz_stream*)file;
+
+ if (s == NULL || s->mode != 'r' || c == EOF || s->back != EOF) return EOF;
+ s->back = c;
+ s->out--;
+ s->last = (s->z_err == Z_STREAM_END);
+ if (s->last) s->z_err = Z_OK;
+ s->z_eof = 0;
+ return c;
+}
+
+
+/* ===========================================================================
+ Reads bytes from the compressed file until len-1 characters are
+ read, or a newline character is read and transferred to buf, or an
+ end-of-file condition is encountered. The string is then terminated
+ with a null character.
+ gzgets returns buf, or Z_NULL in case of error.
+
+ The current implementation is not optimized at all.
+*/
+char * ZEXPORT gzgets(file, buf, len)
+ gzFile file;
+ char *buf;
+ int len;
+{
+ char *b = buf;
+ if (buf == Z_NULL || len <= 0) return Z_NULL;
+
+ while (--len > 0 && gzread(file, buf, 1) == 1 && *buf++ != '\n') ;
+ *buf = '\0';
+ return b == buf && len > 0 ? Z_NULL : b;
+}
+
+
+#ifndef NO_GZCOMPRESS
+/* ===========================================================================
+ Writes the given number of uncompressed bytes into the compressed file.
+ gzwrite returns the number of bytes actually written (0 in case of error).
+*/
+int ZEXPORT gzwrite (file, buf, len)
+ gzFile file;
+ voidpc buf;
+ unsigned len;
+{
+ gz_stream *s = (gz_stream*)file;
+
+ if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
+
+ s->stream.next_in = (Bytef*)buf;
+ s->stream.avail_in = len;
+
+ while (s->stream.avail_in != 0) {
+
+ if (s->stream.avail_out == 0) {
+
+ s->stream.next_out = s->outbuf;
+ if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
+ s->z_err = Z_ERRNO;
+ break;
+ }
+ s->stream.avail_out = Z_BUFSIZE;
+ }
+ s->in += s->stream.avail_in;
+ s->out += s->stream.avail_out;
+ s->z_err = deflate(&(s->stream), Z_NO_FLUSH);
+ s->in -= s->stream.avail_in;
+ s->out -= s->stream.avail_out;
+ if (s->z_err != Z_OK) break;
+ }
+ s->crc = crc32(s->crc, (const Bytef *)buf, len);
+
+ return (int)(len - s->stream.avail_in);
+}
+
+
+/* ===========================================================================
+ Converts, formats, and writes the args to the compressed file under
+ control of the format string, as in fprintf. gzprintf returns the number of
+ uncompressed bytes actually written (0 in case of error).
+*/
+#ifdef STDC
+#include <stdarg.h>
+
+int ZEXPORTVA gzprintf (gzFile file, const char *format, /* args */ ...)
+{
+ char buf[Z_PRINTF_BUFSIZE];
+ va_list va;
+ int len;
+
+ buf[sizeof(buf) - 1] = 0;
+ va_start(va, format);
+#ifdef NO_vsnprintf
+# ifdef HAS_vsprintf_void
+ (void)vsprintf(buf, format, va);
+ va_end(va);
+ for (len = 0; len < sizeof(buf); len++)
+ if (buf[len] == 0) break;
+# else
+ len = vsprintf(buf, format, va);
+ va_end(va);
+# endif
+#else
+# ifdef HAS_vsnprintf_void
+ (void)vsnprintf(buf, sizeof(buf), format, va);
+ va_end(va);
+ len = strlen(buf);
+# else
+ len = vsnprintf(buf, sizeof(buf), format, va);
+ va_end(va);
+# endif
+#endif
+ if (len <= 0 || len >= (int)sizeof(buf) || buf[sizeof(buf) - 1] != 0)
+ return 0;
+ return gzwrite(file, buf, (unsigned)len);
+}
+#else /* not ANSI C */
+
+int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
+ a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
+ gzFile file;
+ const char *format;
+ int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
+ a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;
+{
+ char buf[Z_PRINTF_BUFSIZE];
+ int len;
+
+ buf[sizeof(buf) - 1] = 0;
+#ifdef NO_snprintf
+# ifdef HAS_sprintf_void
+ sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
+ a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+ for (len = 0; len < sizeof(buf); len++)
+ if (buf[len] == 0) break;
+# else
+ len = sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
+ a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+# endif
+#else
+# ifdef HAS_snprintf_void
+ snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
+ a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+ len = strlen(buf);
+# else
+ len = snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
+ a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+# endif
+#endif
+ if (len <= 0 || len >= sizeof(buf) || buf[sizeof(buf) - 1] != 0)
+ return 0;
+ return gzwrite(file, buf, len);
+}
+#endif
+
+/* ===========================================================================
+ Writes c, converted to an unsigned char, into the compressed file.
+ gzputc returns the value that was written, or -1 in case of error.
+*/
+int ZEXPORT gzputc(file, c)
+ gzFile file;
+ int c;
+{
+ unsigned char cc = (unsigned char) c; /* required for big endian systems */
+
+ return gzwrite(file, &cc, 1) == 1 ? (int)cc : -1;
+}
+
+
+/* ===========================================================================
+ Writes the given null-terminated string to the compressed file, excluding
+ the terminating null character.
+ gzputs returns the number of characters written, or -1 in case of error.
+*/
+int ZEXPORT gzputs(file, s)
+ gzFile file;
+ const char *s;
+{
+ return gzwrite(file, (char*)s, (unsigned)strlen(s));
+}
+
+
+/* ===========================================================================
+ Flushes all pending output into the compressed file. The parameter
+ flush is as in the deflate() function.
+*/
+local int do_flush (file, flush)
+ gzFile file;
+ int flush;
+{
+ uInt len;
+ int done = 0;
+ gz_stream *s = (gz_stream*)file;
+
+ if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
+
+ s->stream.avail_in = 0; /* should be zero already anyway */
+
+ for (;;) {
+ len = Z_BUFSIZE - s->stream.avail_out;
+
+ if (len != 0) {
+ if ((uInt)fwrite(s->outbuf, 1, len, s->file) != len) {
+ s->z_err = Z_ERRNO;
+ return Z_ERRNO;
+ }
+ s->stream.next_out = s->outbuf;
+ s->stream.avail_out = Z_BUFSIZE;
+ }
+ if (done) break;
+ s->out += s->stream.avail_out;
+ s->z_err = deflate(&(s->stream), flush);
+ s->out -= s->stream.avail_out;
+
+ /* Ignore the second of two consecutive flushes: */
+ if (len == 0 && s->z_err == Z_BUF_ERROR) s->z_err = Z_OK;
+
+ /* deflate has finished flushing only when it hasn't used up
+ * all the available space in the output buffer:
+ */
+ done = (s->stream.avail_out != 0 || s->z_err == Z_STREAM_END);
+
+ if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) break;
+ }
+ return s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
+}
+
+int ZEXPORT gzflush (file, flush)
+ gzFile file;
+ int flush;
+{
+ gz_stream *s = (gz_stream*)file;
+ int err = do_flush (file, flush);
+
+ if (err) return err;
+ fflush(s->file);
+ return s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
+}
+#endif /* NO_GZCOMPRESS */
+
+/* ===========================================================================
+ Sets the starting position for the next gzread or gzwrite on the given
+ compressed file. The offset represents a number of bytes in the
+ gzseek returns the resulting offset location as measured in bytes from
+ the beginning of the uncompressed stream, or -1 in case of error.
+ SEEK_END is not implemented, returns error.
+ In this version of the library, gzseek can be extremely slow.
+*/
+z_off_t ZEXPORT gzseek (file, offset, whence)
+ gzFile file;
+ z_off_t offset;
+ int whence;
+{
+ gz_stream *s = (gz_stream*)file;
+
+ if (s == NULL || whence == SEEK_END ||
+ s->z_err == Z_ERRNO || s->z_err == Z_DATA_ERROR) {
+ return -1L;
+ }
+
+ if (s->mode == 'w') {
+#ifdef NO_GZCOMPRESS
+ return -1L;
+#else
+ if (whence == SEEK_SET) {
+ offset -= s->in;
+ }
+ if (offset < 0) return -1L;
+
+ /* At this point, offset is the number of zero bytes to write. */
+ if (s->inbuf == Z_NULL) {
+ s->inbuf = (Byte*)ALLOC(Z_BUFSIZE); /* for seeking */
+ if (s->inbuf == Z_NULL) return -1L;
+ zmemzero(s->inbuf, Z_BUFSIZE);
+ }
+ while (offset > 0) {
+ uInt size = Z_BUFSIZE;
+ if (offset < Z_BUFSIZE) size = (uInt)offset;
+
+ size = gzwrite(file, s->inbuf, size);
+ if (size == 0) return -1L;
+
+ offset -= size;
+ }
+ return s->in;
+#endif
+ }
+ /* Rest of function is for reading only */
+
+ /* compute absolute position */
+ if (whence == SEEK_CUR) {
+ offset += s->out;
+ }
+ if (offset < 0) return -1L;
+
+ if (s->transparent) {
+ /* map to fseek */
+ s->back = EOF;
+ s->stream.avail_in = 0;
+ s->stream.next_in = s->inbuf;
+ if (fseek(s->file, offset, SEEK_SET) < 0) return -1L;
+
+ s->in = s->out = offset;
+ return offset;
+ }
+
+ /* For a negative seek, rewind and use positive seek */
+ if (offset >= s->out) {
+ offset -= s->out;
+ } else if (gzrewind(file) < 0) {
+ return -1L;
+ }
+ /* offset is now the number of bytes to skip. */
+
+ if (offset != 0 && s->outbuf == Z_NULL) {
+ s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
+ if (s->outbuf == Z_NULL) return -1L;
+ }
+ if (offset && s->back != EOF) {
+ s->back = EOF;
+ s->out++;
+ offset--;
+ if (s->last) s->z_err = Z_STREAM_END;
+ }
+ while (offset > 0) {
+ int size = Z_BUFSIZE;
+ if (offset < Z_BUFSIZE) size = (int)offset;
+
+ size = gzread(file, s->outbuf, (uInt)size);
+ if (size <= 0) return -1L;
+ offset -= size;
+ }
+ return s->out;
+}
+
+/* ===========================================================================
+ Rewinds input file.
+*/
+int ZEXPORT gzrewind (file)
+ gzFile file;
+{
+ gz_stream *s = (gz_stream*)file;
+
+ if (s == NULL || s->mode != 'r') return -1;
+
+ s->z_err = Z_OK;
+ s->z_eof = 0;
+ s->back = EOF;
+ s->stream.avail_in = 0;
+ s->stream.next_in = s->inbuf;
+ s->crc = crc32(0L, Z_NULL, 0);
+ if (!s->transparent) (void)inflateReset(&s->stream);
+ s->in = 0;
+ s->out = 0;
+ return fseek(s->file, s->start, SEEK_SET);
+}
+
+/* ===========================================================================
+ Returns the starting position for the next gzread or gzwrite on the
+ given compressed file. This position represents a number of bytes in the
+ uncompressed data stream.
+*/
+z_off_t ZEXPORT gztell (file)
+ gzFile file;
+{
+ return gzseek(file, 0L, SEEK_CUR);
+}
+
+/* ===========================================================================
+ Returns 1 when EOF has previously been detected reading the given
+ input stream, otherwise zero.
+*/
+int ZEXPORT gzeof (file)
+ gzFile file;
+{
+ gz_stream *s = (gz_stream*)file;
+
+ /* With concatenated compressed files that can have embedded
+ * crc trailers, z_eof is no longer the only/best indicator of EOF
+ * on a gz_stream. Handle end-of-stream error explicitly here.
+ */
+ if (s == NULL || s->mode != 'r') return 0;
+ if (s->z_eof) return 1;
+ return s->z_err == Z_STREAM_END;
+}
+
+/* ===========================================================================
+ Returns 1 if reading and doing so transparently, otherwise zero.
+*/
+int ZEXPORT gzdirect (file)
+ gzFile file;
+{
+ gz_stream *s = (gz_stream*)file;
+
+ if (s == NULL || s->mode != 'r') return 0;
+ return s->transparent;
+}
+
+/* ===========================================================================
+ Outputs a long in LSB order to the given file
+*/
+local void putLong (file, x)
+ FILE *file;
+ uLong x;
+{
+ int n;
+ for (n = 0; n < 4; n++) {
+ fputc((int)(x & 0xff), file);
+ x >>= 8;
+ }
+}
+
+/* ===========================================================================
+ Reads a long in LSB order from the given gz_stream. Sets z_err in case
+ of error.
+*/
+local uLong getLong (s)
+ gz_stream *s;
+{
+ uLong x = (uLong)get_byte(s);
+ int c;
+
+ x += ((uLong)get_byte(s))<<8;
+ x += ((uLong)get_byte(s))<<16;
+ c = get_byte(s);
+ if (c == EOF) s->z_err = Z_DATA_ERROR;
+ x += ((uLong)c)<<24;
+ return x;
+}
+
+/* ===========================================================================
+ Flushes all pending output if necessary, closes the compressed file
+ and deallocates all the (de)compression state.
+*/
+int ZEXPORT gzclose (file)
+ gzFile file;
+{
+ gz_stream *s = (gz_stream*)file;
+
+ if (s == NULL) return Z_STREAM_ERROR;
+
+ if (s->mode == 'w') {
+#ifdef NO_GZCOMPRESS
+ return Z_STREAM_ERROR;
+#else
+ if (do_flush (file, Z_FINISH) != Z_OK)
+ return destroy((gz_stream*)file);
+
+ putLong (s->file, s->crc);
+ putLong (s->file, (uLong)(s->in & 0xffffffff));
+#endif
+ }
+ return destroy((gz_stream*)file);
+}
+
+#ifdef STDC
+# define zstrerror(errnum) strerror(errnum)
+#else
+# define zstrerror(errnum) ""
+#endif
+
+/* ===========================================================================
+ Returns the error message for the last error which occurred on the
+ given compressed file. errnum is set to zlib error number. If an
+ error occurred in the file system and not in the compression library,
+ errnum is set to Z_ERRNO and the application may consult errno
+ to get the exact error code.
+*/
+const char * ZEXPORT gzerror (file, errnum)
+ gzFile file;
+ int *errnum;
+{
+ char *m;
+ gz_stream *s = (gz_stream*)file;
+
+ if (s == NULL) {
+ *errnum = Z_STREAM_ERROR;
+ return (const char*)ERR_MSG(Z_STREAM_ERROR);
+ }
+ *errnum = s->z_err;
+ if (*errnum == Z_OK) return (const char*)"";
+
+ m = (char*)(*errnum == Z_ERRNO ? zstrerror(errno) : s->stream.msg);
+
+ if (m == NULL || *m == '\0') m = (char*)ERR_MSG(s->z_err);
+
+ TRYFREE(s->msg);
+ s->msg = (char*)ALLOC(strlen(s->path) + strlen(m) + 3);
+ if (s->msg == Z_NULL) return (const char*)ERR_MSG(Z_MEM_ERROR);
+ strcpy(s->msg, s->path);
+ strcat(s->msg, ": ");
+ strcat(s->msg, m);
+ return (const char*)s->msg;
+}
+
+/* ===========================================================================
+ Clear the error and end-of-file flags, and do the same for the real file.
+*/
+void ZEXPORT gzclearerr (file)
+ gzFile file;
+{
+ gz_stream *s = (gz_stream*)file;
+
+ if (s == NULL) return;
+ if (s->z_err != Z_STREAM_END) s->z_err = Z_OK;
+ s->z_eof = 0;
+ clearerr(s->file);
+}
--- /dev/null
+/* infback.c -- inflate using a call-back interface
+ * Copyright (C) 1995-2005 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/*
+ This code is largely copied from inflate.c. Normally either infback.o or
+ inflate.o would be linked into an application--not both. The interface
+ with inffast.c is retained so that optimized assembler-coded versions of
+ inflate_fast() can be used with either inflate.c or infback.c.
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+#include "inflate.h"
+#include "inffast.h"
+
+/* function prototypes */
+local void fixedtables OF((struct inflate_state FAR *state));
+
+/*
+ strm provides memory allocation functions in zalloc and zfree, or
+ Z_NULL to use the library memory allocation functions.
+
+ windowBits is in the range 8..15, and window is a user-supplied
+ window and output buffer that is 2**windowBits bytes.
+ */
+int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size)
+z_streamp strm;
+int windowBits;
+unsigned char FAR *window;
+const char *version;
+int stream_size;
+{
+ struct inflate_state FAR *state;
+
+ if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
+ stream_size != (int)(sizeof(z_stream)))
+ return Z_VERSION_ERROR;
+ if (strm == Z_NULL || window == Z_NULL ||
+ windowBits < 8 || windowBits > 15)
+ return Z_STREAM_ERROR;
+ strm->msg = Z_NULL; /* in case we return an error */
+ if (strm->zalloc == (alloc_func)0) {
+ strm->zalloc = zcalloc;
+ strm->opaque = (voidpf)0;
+ }
+ if (strm->zfree == (free_func)0) strm->zfree = zcfree;
+ state = (struct inflate_state FAR *)ZALLOC(strm, 1,
+ sizeof(struct inflate_state));
+ if (state == Z_NULL) return Z_MEM_ERROR;
+ Tracev((stderr, "inflate: allocated\n"));
+ strm->state = (struct internal_state FAR *)state;
+ state->dmax = 32768U;
+ state->wbits = windowBits;
+ state->wsize = 1U << windowBits;
+ state->window = window;
+ state->write = 0;
+ state->whave = 0;
+ return Z_OK;
+}
+
+/*
+ Return state with length and distance decoding tables and index sizes set to
+ fixed code decoding. Normally this returns fixed tables from inffixed.h.
+ If BUILDFIXED is defined, then instead this routine builds the tables the
+ first time it's called, and returns those tables the first time and
+ thereafter. This reduces the size of the code by about 2K bytes, in
+ exchange for a little execution time. However, BUILDFIXED should not be
+ used for threaded applications, since the rewriting of the tables and virgin
+ may not be thread-safe.
+ */
+local void fixedtables(state)
+struct inflate_state FAR *state;
+{
+#ifdef BUILDFIXED
+ static int virgin = 1;
+ static code *lenfix, *distfix;
+ static code fixed[544];
+
+ /* build fixed huffman tables if first call (may not be thread safe) */
+ if (virgin) {
+ unsigned sym, bits;
+ static code *next;
+
+ /* literal/length table */
+ sym = 0;
+ while (sym < 144) state->lens[sym++] = 8;
+ while (sym < 256) state->lens[sym++] = 9;
+ while (sym < 280) state->lens[sym++] = 7;
+ while (sym < 288) state->lens[sym++] = 8;
+ next = fixed;
+ lenfix = next;
+ bits = 9;
+ inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
+
+ /* distance table */
+ sym = 0;
+ while (sym < 32) state->lens[sym++] = 5;
+ distfix = next;
+ bits = 5;
+ inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
+
+ /* do this just once */
+ virgin = 0;
+ }
+#else /* !BUILDFIXED */
+# include "inffixed.h"
+#endif /* BUILDFIXED */
+ state->lencode = lenfix;
+ state->lenbits = 9;
+ state->distcode = distfix;
+ state->distbits = 5;
+}
+
+/* Macros for inflateBack(): */
+
+/* Load returned state from inflate_fast() */
+#define LOAD() \
+ do { \
+ put = strm->next_out; \
+ left = strm->avail_out; \
+ next = strm->next_in; \
+ have = strm->avail_in; \
+ hold = state->hold; \
+ bits = state->bits; \
+ } while (0)
+
+/* Set state from registers for inflate_fast() */
+#define RESTORE() \
+ do { \
+ strm->next_out = put; \
+ strm->avail_out = left; \
+ strm->next_in = next; \
+ strm->avail_in = have; \
+ state->hold = hold; \
+ state->bits = bits; \
+ } while (0)
+
+/* Clear the input bit accumulator */
+#define INITBITS() \
+ do { \
+ hold = 0; \
+ bits = 0; \
+ } while (0)
+
+/* Assure that some input is available. If input is requested, but denied,
+ then return a Z_BUF_ERROR from inflateBack(). */
+#define PULL() \
+ do { \
+ if (have == 0) { \
+ have = in(in_desc, &next); \
+ if (have == 0) { \
+ next = Z_NULL; \
+ ret = Z_BUF_ERROR; \
+ goto inf_leave; \
+ } \
+ } \
+ } while (0)
+
+/* Get a byte of input into the bit accumulator, or return from inflateBack()
+ with an error if there is no input available. */
+#define PULLBYTE() \
+ do { \
+ PULL(); \
+ have--; \
+ hold += (unsigned long)(*next++) << bits; \
+ bits += 8; \
+ } while (0)
+
+/* Assure that there are at least n bits in the bit accumulator. If there is
+ not enough available input to do that, then return from inflateBack() with
+ an error. */
+#define NEEDBITS(n) \
+ do { \
+ while (bits < (unsigned)(n)) \
+ PULLBYTE(); \
+ } while (0)
+
+/* Return the low n bits of the bit accumulator (n < 16) */
+#define BITS(n) \
+ ((unsigned)hold & ((1U << (n)) - 1))
+
+/* Remove n bits from the bit accumulator */
+#define DROPBITS(n) \
+ do { \
+ hold >>= (n); \
+ bits -= (unsigned)(n); \
+ } while (0)
+
+/* Remove zero to seven bits as needed to go to a byte boundary */
+#define BYTEBITS() \
+ do { \
+ hold >>= bits & 7; \
+ bits -= bits & 7; \
+ } while (0)
+
+/* Assure that some output space is available, by writing out the window
+ if it's full. If the write fails, return from inflateBack() with a
+ Z_BUF_ERROR. */
+#define ROOM() \
+ do { \
+ if (left == 0) { \
+ put = state->window; \
+ left = state->wsize; \
+ state->whave = left; \
+ if (out(out_desc, put, left)) { \
+ ret = Z_BUF_ERROR; \
+ goto inf_leave; \
+ } \
+ } \
+ } while (0)
+
+/*
+ strm provides the memory allocation functions and window buffer on input,
+ and provides information on the unused input on return. For Z_DATA_ERROR
+ returns, strm will also provide an error message.
+
+ in() and out() are the call-back input and output functions. When
+ inflateBack() needs more input, it calls in(). When inflateBack() has
+ filled the window with output, or when it completes with data in the
+ window, it calls out() to write out the data. The application must not
+ change the provided input until in() is called again or inflateBack()
+ returns. The application must not change the window/output buffer until
+ inflateBack() returns.
+
+ in() and out() are called with a descriptor parameter provided in the
+ inflateBack() call. This parameter can be a structure that provides the
+ information required to do the read or write, as well as accumulated
+ information on the input and output such as totals and check values.
+
+ in() should return zero on failure. out() should return non-zero on
+ failure. If either in() or out() fails, than inflateBack() returns a
+ Z_BUF_ERROR. strm->next_in can be checked for Z_NULL to see whether it
+ was in() or out() that caused in the error. Otherwise, inflateBack()
+ returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format
+ error, or Z_MEM_ERROR if it could not allocate memory for the state.
+ inflateBack() can also return Z_STREAM_ERROR if the input parameters
+ are not correct, i.e. strm is Z_NULL or the state was not initialized.
+ */
+int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc)
+z_streamp strm;
+in_func in;
+void FAR *in_desc;
+out_func out;
+void FAR *out_desc;
+{
+ struct inflate_state FAR *state;
+ unsigned char FAR *next; /* next input */
+ unsigned char FAR *put; /* next output */
+ unsigned have, left; /* available input and output */
+ unsigned long hold; /* bit buffer */
+ unsigned bits; /* bits in bit buffer */
+ unsigned copy; /* number of stored or match bytes to copy */
+ unsigned char FAR *from; /* where to copy match bytes from */
+ code this; /* current decoding table entry */
+ code last; /* parent table entry */
+ unsigned len; /* length to copy for repeats, bits to drop */
+ int ret; /* return code */
+ static const unsigned short order[19] = /* permutation of code lengths */
+ {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
+
+ /* Check that the strm exists and that the state was initialized */
+ if (strm == Z_NULL || strm->state == Z_NULL)
+ return Z_STREAM_ERROR;
+ state = (struct inflate_state FAR *)strm->state;
+
+ /* Reset the state */
+ strm->msg = Z_NULL;
+ state->mode = TYPE;
+ state->last = 0;
+ state->whave = 0;
+ next = strm->next_in;
+ have = next != Z_NULL ? strm->avail_in : 0;
+ hold = 0;
+ bits = 0;
+ put = state->window;
+ left = state->wsize;
+
+ /* Inflate until end of block marked as last */
+ for (;;)
+ switch (state->mode) {
+ case TYPE:
+ /* determine and dispatch block type */
+ if (state->last) {
+ BYTEBITS();
+ state->mode = DONE;
+ break;
+ }
+ NEEDBITS(3);
+ state->last = BITS(1);
+ DROPBITS(1);
+ switch (BITS(2)) {
+ case 0: /* stored block */
+ Tracev((stderr, "inflate: stored block%s\n",
+ state->last ? " (last)" : ""));
+ state->mode = STORED;
+ break;
+ case 1: /* fixed block */
+ fixedtables(state);
+ Tracev((stderr, "inflate: fixed codes block%s\n",
+ state->last ? " (last)" : ""));
+ state->mode = LEN; /* decode codes */
+ break;
+ case 2: /* dynamic block */
+ Tracev((stderr, "inflate: dynamic codes block%s\n",
+ state->last ? " (last)" : ""));
+ state->mode = TABLE;
+ break;
+ case 3:
+ strm->msg = (char *)"invalid block type";
+ state->mode = BAD;
+ }
+ DROPBITS(2);
+ break;
+
+ case STORED:
+ /* get and verify stored block length */
+ BYTEBITS(); /* go to byte boundary */
+ NEEDBITS(32);
+ if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
+ strm->msg = (char *)"invalid stored block lengths";
+ state->mode = BAD;
+ break;
+ }
+ state->length = (unsigned)hold & 0xffff;
+ Tracev((stderr, "inflate: stored length %u\n",
+ state->length));
+ INITBITS();
+
+ /* copy stored block from input to output */
+ while (state->length != 0) {
+ copy = state->length;
+ PULL();
+ ROOM();
+ if (copy > have) copy = have;
+ if (copy > left) copy = left;
+ zmemcpy(put, next, copy);
+ have -= copy;
+ next += copy;
+ left -= copy;
+ put += copy;
+ state->length -= copy;
+ }
+ Tracev((stderr, "inflate: stored end\n"));
+ state->mode = TYPE;
+ break;
+
+ case TABLE:
+ /* get dynamic table entries descriptor */
+ NEEDBITS(14);
+ state->nlen = BITS(5) + 257;
+ DROPBITS(5);
+ state->ndist = BITS(5) + 1;
+ DROPBITS(5);
+ state->ncode = BITS(4) + 4;
+ DROPBITS(4);
+#ifndef PKZIP_BUG_WORKAROUND
+ if (state->nlen > 286 || state->ndist > 30) {
+ strm->msg = (char *)"too many length or distance symbols";
+ state->mode = BAD;
+ break;
+ }
+#endif
+ Tracev((stderr, "inflate: table sizes ok\n"));
+
+ /* get code length code lengths (not a typo) */
+ state->have = 0;
+ while (state->have < state->ncode) {
+ NEEDBITS(3);
+ state->lens[order[state->have++]] = (unsigned short)BITS(3);
+ DROPBITS(3);
+ }
+ while (state->have < 19)
+ state->lens[order[state->have++]] = 0;
+ state->next = state->codes;
+ state->lencode = (code const FAR *)(state->next);
+ state->lenbits = 7;
+ ret = inflate_table(CODES, state->lens, 19, &(state->next),
+ &(state->lenbits), state->work);
+ if (ret) {
+ strm->msg = (char *)"invalid code lengths set";
+ state->mode = BAD;
+ break;
+ }
+ Tracev((stderr, "inflate: code lengths ok\n"));
+
+ /* get length and distance code code lengths */
+ state->have = 0;
+ while (state->have < state->nlen + state->ndist) {
+ for (;;) {
+ this = state->lencode[BITS(state->lenbits)];
+ if ((unsigned)(this.bits) <= bits) break;
+ PULLBYTE();
+ }
+ if (this.val < 16) {
+ NEEDBITS(this.bits);
+ DROPBITS(this.bits);
+ state->lens[state->have++] = this.val;
+ }
+ else {
+ if (this.val == 16) {
+ NEEDBITS(this.bits + 2);
+ DROPBITS(this.bits);
+ if (state->have == 0) {
+ strm->msg = (char *)"invalid bit length repeat";
+ state->mode = BAD;
+ break;
+ }
+ len = (unsigned)(state->lens[state->have - 1]);
+ copy = 3 + BITS(2);
+ DROPBITS(2);
+ }
+ else if (this.val == 17) {
+ NEEDBITS(this.bits + 3);
+ DROPBITS(this.bits);
+ len = 0;
+ copy = 3 + BITS(3);
+ DROPBITS(3);
+ }
+ else {
+ NEEDBITS(this.bits + 7);
+ DROPBITS(this.bits);
+ len = 0;
+ copy = 11 + BITS(7);
+ DROPBITS(7);
+ }
+ if (state->have + copy > state->nlen + state->ndist) {
+ strm->msg = (char *)"invalid bit length repeat";
+ state->mode = BAD;
+ break;
+ }
+ while (copy--)
+ state->lens[state->have++] = (unsigned short)len;
+ }
+ }
+
+ /* handle error breaks in while */
+ if (state->mode == BAD) break;
+
+ /* build code tables */
+ state->next = state->codes;
+ state->lencode = (code const FAR *)(state->next);
+ state->lenbits = 9;
+ ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
+ &(state->lenbits), state->work);
+ if (ret) {
+ strm->msg = (char *)"invalid literal/lengths set";
+ state->mode = BAD;
+ break;
+ }
+ state->distcode = (code const FAR *)(state->next);
+ state->distbits = 6;
+ ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
+ &(state->next), &(state->distbits), state->work);
+ if (ret) {
+ strm->msg = (char *)"invalid distances set";
+ state->mode = BAD;
+ break;
+ }
+ Tracev((stderr, "inflate: codes ok\n"));
+ state->mode = LEN;
+
+ case LEN:
+ /* use inflate_fast() if we have enough input and output */
+ if (have >= 6 && left >= 258) {
+ RESTORE();
+ if (state->whave < state->wsize)
+ state->whave = state->wsize - left;
+ inflate_fast(strm, state->wsize);
+ LOAD();
+ break;
+ }
+
+ /* get a literal, length, or end-of-block code */
+ for (;;) {
+ this = state->lencode[BITS(state->lenbits)];
+ if ((unsigned)(this.bits) <= bits) break;
+ PULLBYTE();
+ }
+ if (this.op && (this.op & 0xf0) == 0) {
+ last = this;
+ for (;;) {
+ this = state->lencode[last.val +
+ (BITS(last.bits + last.op) >> last.bits)];
+ if ((unsigned)(last.bits + this.bits) <= bits) break;
+ PULLBYTE();
+ }
+ DROPBITS(last.bits);
+ }
+ DROPBITS(this.bits);
+ state->length = (unsigned)this.val;
+
+ /* process literal */
+ if (this.op == 0) {
+ Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
+ "inflate: literal '%c'\n" :
+ "inflate: literal 0x%02x\n", this.val));
+ ROOM();
+ *put++ = (unsigned char)(state->length);
+ left--;
+ state->mode = LEN;
+ break;
+ }
+
+ /* process end of block */
+ if (this.op & 32) {
+ Tracevv((stderr, "inflate: end of block\n"));
+ state->mode = TYPE;
+ break;
+ }
+
+ /* invalid code */
+ if (this.op & 64) {
+ strm->msg = (char *)"invalid literal/length code";
+ state->mode = BAD;
+ break;
+ }
+
+ /* length code -- get extra bits, if any */
+ state->extra = (unsigned)(this.op) & 15;
+ if (state->extra != 0) {
+ NEEDBITS(state->extra);
+ state->length += BITS(state->extra);
+ DROPBITS(state->extra);
+ }
+ Tracevv((stderr, "inflate: length %u\n", state->length));
+
+ /* get distance code */
+ for (;;) {
+ this = state->distcode[BITS(state->distbits)];
+ if ((unsigned)(this.bits) <= bits) break;
+ PULLBYTE();
+ }
+ if ((this.op & 0xf0) == 0) {
+ last = this;
+ for (;;) {
+ this = state->distcode[last.val +
+ (BITS(last.bits + last.op) >> last.bits)];
+ if ((unsigned)(last.bits + this.bits) <= bits) break;
+ PULLBYTE();
+ }
+ DROPBITS(last.bits);
+ }
+ DROPBITS(this.bits);
+ if (this.op & 64) {
+ strm->msg = (char *)"invalid distance code";
+ state->mode = BAD;
+ break;
+ }
+ state->offset = (unsigned)this.val;
+
+ /* get distance extra bits, if any */
+ state->extra = (unsigned)(this.op) & 15;
+ if (state->extra != 0) {
+ NEEDBITS(state->extra);
+ state->offset += BITS(state->extra);
+ DROPBITS(state->extra);
+ }
+ if (state->offset > state->wsize - (state->whave < state->wsize ?
+ left : 0)) {
+ strm->msg = (char *)"invalid distance too far back";
+ state->mode = BAD;
+ break;
+ }
+ Tracevv((stderr, "inflate: distance %u\n", state->offset));
+
+ /* copy match from window to output */
+ do {
+ ROOM();
+ copy = state->wsize - state->offset;
+ if (copy < left) {
+ from = put + copy;
+ copy = left - copy;
+ }
+ else {
+ from = put - state->offset;
+ copy = left;
+ }
+ if (copy > state->length) copy = state->length;
+ state->length -= copy;
+ left -= copy;
+ do {
+ *put++ = *from++;
+ } while (--copy);
+ } while (state->length != 0);
+ break;
+
+ case DONE:
+ /* inflate stream terminated properly -- write leftover output */
+ ret = Z_STREAM_END;
+ if (left < state->wsize) {
+ if (out(out_desc, state->window, state->wsize - left))
+ ret = Z_BUF_ERROR;
+ }
+ goto inf_leave;
+
+ case BAD:
+ ret = Z_DATA_ERROR;
+ goto inf_leave;
+
+ default: /* can't happen, but makes compilers happy */
+ ret = Z_STREAM_ERROR;
+ goto inf_leave;
+ }
+
+ /* Return unused input */
+ inf_leave:
+ strm->next_in = next;
+ strm->avail_in = have;
+ return ret;
+}
+
+int ZEXPORT inflateBackEnd(strm)
+z_streamp strm;
+{
+ if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
+ return Z_STREAM_ERROR;
+ ZFREE(strm, strm->state);
+ strm->state = Z_NULL;
+ Tracev((stderr, "inflate: end\n"));
+ return Z_OK;
+}
--- /dev/null
+/* inffast.c -- fast decoding
+ * Copyright (C) 1995-2004 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+#include "inflate.h"
+#include "inffast.h"
+
+#ifndef ASMINF
+
+/* Allow machine dependent optimization for post-increment or pre-increment.
+ Based on testing to date,
+ Pre-increment preferred for:
+ - PowerPC G3 (Adler)
+ - MIPS R5000 (Randers-Pehrson)
+ Post-increment preferred for:
+ - none
+ No measurable difference:
+ - Pentium III (Anderson)
+ - M68060 (Nikl)
+ */
+#ifdef POSTINC
+# define OFF 0
+# define PUP(a) *(a)++
+#else
+# define OFF 1
+# define PUP(a) *++(a)
+#endif
+
+/*
+ Decode literal, length, and distance codes and write out the resulting
+ literal and match bytes until either not enough input or output is
+ available, an end-of-block is encountered, or a data error is encountered.
+ When large enough input and output buffers are supplied to inflate(), for
+ example, a 16K input buffer and a 64K output buffer, more than 95% of the
+ inflate execution time is spent in this routine.
+
+ Entry assumptions:
+
+ state->mode == LEN
+ strm->avail_in >= 6
+ strm->avail_out >= 258
+ start >= strm->avail_out
+ state->bits < 8
+
+ On return, state->mode is one of:
+
+ LEN -- ran out of enough output space or enough available input
+ TYPE -- reached end of block code, inflate() to interpret next block
+ BAD -- error in block data
+
+ Notes:
+
+ - The maximum input bits used by a length/distance pair is 15 bits for the
+ length code, 5 bits for the length extra, 15 bits for the distance code,
+ and 13 bits for the distance extra. This totals 48 bits, or six bytes.
+ Therefore if strm->avail_in >= 6, then there is enough input to avoid
+ checking for available input while decoding.
+
+ - The maximum bytes that a single length/distance pair can output is 258
+ bytes, which is the maximum length that can be coded. inflate_fast()
+ requires strm->avail_out >= 258 for each loop to avoid checking for
+ output space.
+ */
+void inflate_fast(strm, start)
+z_streamp strm;
+unsigned start; /* inflate()'s starting value for strm->avail_out */
+{
+ struct inflate_state FAR *state;
+ unsigned char FAR *in; /* local strm->next_in */
+ unsigned char FAR *last; /* while in < last, enough input available */
+ unsigned char FAR *out; /* local strm->next_out */
+ unsigned char FAR *beg; /* inflate()'s initial strm->next_out */
+ unsigned char FAR *end; /* while out < end, enough space available */
+#ifdef INFLATE_STRICT
+ unsigned dmax; /* maximum distance from zlib header */
+#endif
+ unsigned wsize; /* window size or zero if not using window */
+ unsigned whave; /* valid bytes in the window */
+ unsigned write; /* window write index */
+ unsigned char FAR *window; /* allocated sliding window, if wsize != 0 */
+ unsigned long hold; /* local strm->hold */
+ unsigned bits; /* local strm->bits */
+ code const FAR *lcode; /* local strm->lencode */
+ code const FAR *dcode; /* local strm->distcode */
+ unsigned lmask; /* mask for first level of length codes */
+ unsigned dmask; /* mask for first level of distance codes */
+ code this; /* retrieved table entry */
+ unsigned op; /* code bits, operation, extra bits, or */
+ /* window position, window bytes to copy */
+ unsigned len; /* match length, unused bytes */
+ unsigned dist; /* match distance */
+ unsigned char FAR *from; /* where to copy match from */
+
+ /* copy state to local variables */
+ state = (struct inflate_state FAR *)strm->state;
+ in = strm->next_in - OFF;
+ last = in + (strm->avail_in - 5);
+ out = strm->next_out - OFF;
+ beg = out - (start - strm->avail_out);
+ end = out + (strm->avail_out - 257);
+#ifdef INFLATE_STRICT
+ dmax = state->dmax;
+#endif
+ wsize = state->wsize;
+ whave = state->whave;
+ write = state->write;
+ window = state->window;
+ hold = state->hold;
+ bits = state->bits;
+ lcode = state->lencode;
+ dcode = state->distcode;
+ lmask = (1U << state->lenbits) - 1;
+ dmask = (1U << state->distbits) - 1;
+
+ /* decode literals and length/distances until end-of-block or not enough
+ input data or output space */
+ do {
+ if (bits < 15) {
+ hold += (unsigned long)(PUP(in)) << bits;
+ bits += 8;
+ hold += (unsigned long)(PUP(in)) << bits;
+ bits += 8;
+ }
+ this = lcode[hold & lmask];
+ dolen:
+ op = (unsigned)(this.bits);
+ hold >>= op;
+ bits -= op;
+ op = (unsigned)(this.op);
+ if (op == 0) { /* literal */
+ Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
+ "inflate: literal '%c'\n" :
+ "inflate: literal 0x%02x\n", this.val));
+ PUP(out) = (unsigned char)(this.val);
+ }
+ else if (op & 16) { /* length base */
+ len = (unsigned)(this.val);
+ op &= 15; /* number of extra bits */
+ if (op) {
+ if (bits < op) {
+ hold += (unsigned long)(PUP(in)) << bits;
+ bits += 8;
+ }
+ len += (unsigned)hold & ((1U << op) - 1);
+ hold >>= op;
+ bits -= op;
+ }
+ Tracevv((stderr, "inflate: length %u\n", len));
+ if (bits < 15) {
+ hold += (unsigned long)(PUP(in)) << bits;
+ bits += 8;
+ hold += (unsigned long)(PUP(in)) << bits;
+ bits += 8;
+ }
+ this = dcode[hold & dmask];
+ dodist:
+ op = (unsigned)(this.bits);
+ hold >>= op;
+ bits -= op;
+ op = (unsigned)(this.op);
+ if (op & 16) { /* distance base */
+ dist = (unsigned)(this.val);
+ op &= 15; /* number of extra bits */
+ if (bits < op) {
+ hold += (unsigned long)(PUP(in)) << bits;
+ bits += 8;
+ if (bits < op) {
+ hold += (unsigned long)(PUP(in)) << bits;
+ bits += 8;
+ }
+ }
+ dist += (unsigned)hold & ((1U << op) - 1);
+#ifdef INFLATE_STRICT
+ if (dist > dmax) {
+ strm->msg = (char *)"invalid distance too far back";
+ state->mode = BAD;
+ break;
+ }
+#endif
+ hold >>= op;
+ bits -= op;
+ Tracevv((stderr, "inflate: distance %u\n", dist));
+ op = (unsigned)(out - beg); /* max distance in output */
+ if (dist > op) { /* see if copy from window */
+ op = dist - op; /* distance back in window */
+ if (op > whave) {
+ strm->msg = (char *)"invalid distance too far back";
+ state->mode = BAD;
+ break;
+ }
+ from = window - OFF;
+ if (write == 0) { /* very common case */
+ from += wsize - op;
+ if (op < len) { /* some from window */
+ len -= op;
+ do {
+ PUP(out) = PUP(from);
+ } while (--op);
+ from = out - dist; /* rest from output */
+ }
+ }
+ else if (write < op) { /* wrap around window */
+ from += wsize + write - op;
+ op -= write;
+ if (op < len) { /* some from end of window */
+ len -= op;
+ do {
+ PUP(out) = PUP(from);
+ } while (--op);
+ from = window - OFF;
+ if (write < len) { /* some from start of window */
+ op = write;
+ len -= op;
+ do {
+ PUP(out) = PUP(from);
+ } while (--op);
+ from = out - dist; /* rest from output */
+ }
+ }
+ }
+ else { /* contiguous in window */
+ from += write - op;
+ if (op < len) { /* some from window */
+ len -= op;
+ do {
+ PUP(out) = PUP(from);
+ } while (--op);
+ from = out - dist; /* rest from output */
+ }
+ }
+ while (len > 2) {
+ PUP(out) = PUP(from);
+ PUP(out) = PUP(from);
+ PUP(out) = PUP(from);
+ len -= 3;
+ }
+ if (len) {
+ PUP(out) = PUP(from);
+ if (len > 1)
+ PUP(out) = PUP(from);
+ }
+ }
+ else {
+ from = out - dist; /* copy direct from output */
+ do { /* minimum length is three */
+ PUP(out) = PUP(from);
+ PUP(out) = PUP(from);
+ PUP(out) = PUP(from);
+ len -= 3;
+ } while (len > 2);
+ if (len) {
+ PUP(out) = PUP(from);
+ if (len > 1)
+ PUP(out) = PUP(from);
+ }
+ }
+ }
+ else if ((op & 64) == 0) { /* 2nd level distance code */
+ this = dcode[this.val + (hold & ((1U << op) - 1))];
+ goto dodist;
+ }
+ else {
+ strm->msg = (char *)"invalid distance code";
+ state->mode = BAD;
+ break;
+ }
+ }
+ else if ((op & 64) == 0) { /* 2nd level length code */
+ this = lcode[this.val + (hold & ((1U << op) - 1))];
+ goto dolen;
+ }
+ else if (op & 32) { /* end-of-block */
+ Tracevv((stderr, "inflate: end of block\n"));
+ state->mode = TYPE;
+ break;
+ }
+ else {
+ strm->msg = (char *)"invalid literal/length code";
+ state->mode = BAD;
+ break;
+ }
+ } while (in < last && out < end);
+
+ /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
+ len = bits >> 3;
+ in -= len;
+ bits -= len << 3;
+ hold &= (1U << bits) - 1;
+
+ /* update state and return */
+ strm->next_in = in + OFF;
+ strm->next_out = out + OFF;
+ strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last));
+ strm->avail_out = (unsigned)(out < end ?
+ 257 + (end - out) : 257 - (out - end));
+ state->hold = hold;
+ state->bits = bits;
+ return;
+}
+
+/*
+ inflate_fast() speedups that turned out slower (on a PowerPC G3 750CXe):
+ - Using bit fields for code structure
+ - Different op definition to avoid & for extra bits (do & for table bits)
+ - Three separate decoding do-loops for direct, window, and write == 0
+ - Special case for distance > 1 copies to do overlapped load and store copy
+ - Explicit branch predictions (based on measured branch probabilities)
+ - Deferring match copy and interspersed it with decoding subsequent codes
+ - Swapping literal/length else
+ - Swapping window/direct else
+ - Larger unrolled copy loops (three is about right)
+ - Moving len -= 3 statement into middle of loop
+ */
+
+#endif /* !ASMINF */
--- /dev/null
+/* inffast.h -- header to use inffast.c
+ * Copyright (C) 1995-2003 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+ part of the implementation of the compression library and is
+ subject to change. Applications should only use zlib.h.
+ */
+
+void inflate_fast OF((z_streamp strm, unsigned start));
--- /dev/null
+ /* inffixed.h -- table for decoding fixed codes
+ * Generated automatically by makefixed().
+ */
+
+ /* WARNING: this file should *not* be used by applications. It
+ is part of the implementation of the compression library and
+ is subject to change. Applications should only use zlib.h.
+ */
+
+ static const code lenfix[512] = {
+ {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48},
+ {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128},
+ {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59},
+ {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176},
+ {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20},
+ {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100},
+ {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8},
+ {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216},
+ {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76},
+ {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114},
+ {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2},
+ {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148},
+ {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42},
+ {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86},
+ {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15},
+ {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236},
+ {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62},
+ {0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142},
+ {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31},
+ {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162},
+ {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25},
+ {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105},
+ {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4},
+ {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202},
+ {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69},
+ {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125},
+ {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13},
+ {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195},
+ {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35},
+ {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91},
+ {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19},
+ {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246},
+ {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55},
+ {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135},
+ {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99},
+ {0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190},
+ {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16},
+ {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96},
+ {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6},
+ {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209},
+ {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72},
+ {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116},
+ {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4},
+ {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153},
+ {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44},
+ {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82},
+ {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11},
+ {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229},
+ {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58},
+ {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138},
+ {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51},
+ {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173},
+ {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30},
+ {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110},
+ {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0},
+ {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195},
+ {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65},
+ {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121},
+ {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9},
+ {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258},
+ {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37},
+ {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93},
+ {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23},
+ {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251},
+ {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51},
+ {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131},
+ {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67},
+ {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183},
+ {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23},
+ {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103},
+ {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9},
+ {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223},
+ {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79},
+ {0,9,255}
+ };
+
+ static const code distfix[32] = {
+ {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025},
+ {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193},
+ {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385},
+ {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577},
+ {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073},
+ {22,5,193},{64,5,0}
+ };
--- /dev/null
+/* inflate.c -- zlib decompression
+ * Copyright (C) 1995-2005 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/*
+ * Change history:
+ *
+ * 1.2.beta0 24 Nov 2002
+ * - First version -- complete rewrite of inflate to simplify code, avoid
+ * creation of window when not needed, minimize use of window when it is
+ * needed, make inffast.c even faster, implement gzip decoding, and to
+ * improve code readability and style over the previous zlib inflate code
+ *
+ * 1.2.beta1 25 Nov 2002
+ * - Use pointers for available input and output checking in inffast.c
+ * - Remove input and output counters in inffast.c
+ * - Change inffast.c entry and loop from avail_in >= 7 to >= 6
+ * - Remove unnecessary second byte pull from length extra in inffast.c
+ * - Unroll direct copy to three copies per loop in inffast.c
+ *
+ * 1.2.beta2 4 Dec 2002
+ * - Change external routine names to reduce potential conflicts
+ * - Correct filename to inffixed.h for fixed tables in inflate.c
+ * - Make hbuf[] unsigned char to match parameter type in inflate.c
+ * - Change strm->next_out[-state->offset] to *(strm->next_out - state->offset)
+ * to avoid negation problem on Alphas (64 bit) in inflate.c
+ *
+ * 1.2.beta3 22 Dec 2002
+ * - Add comments on state->bits assertion in inffast.c
+ * - Add comments on op field in inftrees.h
+ * - Fix bug in reuse of allocated window after inflateReset()
+ * - Remove bit fields--back to byte structure for speed
+ * - Remove distance extra == 0 check in inflate_fast()--only helps for lengths
+ * - Change post-increments to pre-increments in inflate_fast(), PPC biased?
+ * - Add compile time option, POSTINC, to use post-increments instead (Intel?)
+ * - Make MATCH copy in inflate() much faster for when inflate_fast() not used
+ * - Use local copies of stream next and avail values, as well as local bit
+ * buffer and bit count in inflate()--for speed when inflate_fast() not used
+ *
+ * 1.2.beta4 1 Jan 2003
+ * - Split ptr - 257 statements in inflate_table() to avoid compiler warnings
+ * - Move a comment on output buffer sizes from inffast.c to inflate.c
+ * - Add comments in inffast.c to introduce the inflate_fast() routine
+ * - Rearrange window copies in inflate_fast() for speed and simplification
+ * - Unroll last copy for window match in inflate_fast()
+ * - Use local copies of window variables in inflate_fast() for speed
+ * - Pull out common write == 0 case for speed in inflate_fast()
+ * - Make op and len in inflate_fast() unsigned for consistency
+ * - Add FAR to lcode and dcode declarations in inflate_fast()
+ * - Simplified bad distance check in inflate_fast()
+ * - Added inflateBackInit(), inflateBack(), and inflateBackEnd() in new
+ * source file infback.c to provide a call-back interface to inflate for
+ * programs like gzip and unzip -- uses window as output buffer to avoid
+ * window copying
+ *
+ * 1.2.beta5 1 Jan 2003
+ * - Improved inflateBack() interface to allow the caller to provide initial
+ * input in strm.
+ * - Fixed stored blocks bug in inflateBack()
+ *
+ * 1.2.beta6 4 Jan 2003
+ * - Added comments in inffast.c on effectiveness of POSTINC
+ * - Typecasting all around to reduce compiler warnings
+ * - Changed loops from while (1) or do {} while (1) to for (;;), again to
+ * make compilers happy
+ * - Changed type of window in inflateBackInit() to unsigned char *
+ *
+ * 1.2.beta7 27 Jan 2003
+ * - Changed many types to unsigned or unsigned short to avoid warnings
+ * - Added inflateCopy() function
+ *
+ * 1.2.0 9 Mar 2003
+ * - Changed inflateBack() interface to provide separate opaque descriptors
+ * for the in() and out() functions
+ * - Changed inflateBack() argument and in_func typedef to swap the length
+ * and buffer address return values for the input function
+ * - Check next_in and next_out for Z_NULL on entry to inflate()
+ *
+ * The history for versions after 1.2.0 are in ChangeLog in zlib distribution.
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+#include "inflate.h"
+#include "inffast.h"
+
+#ifdef MAKEFIXED
+# ifndef BUILDFIXED
+# define BUILDFIXED
+# endif
+#endif
+
+/* function prototypes */
+local void fixedtables OF((struct inflate_state FAR *state));
+local int updatewindow OF((z_streamp strm, unsigned out));
+#ifdef BUILDFIXED
+ void makefixed OF((void));
+#endif
+local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf,
+ unsigned len));
+
+int ZEXPORT inflateReset(strm)
+z_streamp strm;
+{
+ struct inflate_state FAR *state;
+
+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ state = (struct inflate_state FAR *)strm->state;
+ strm->total_in = strm->total_out = state->total = 0;
+ strm->msg = Z_NULL;
+ strm->adler = 1; /* to support ill-conceived Java test suite */
+ state->mode = HEAD;
+ state->last = 0;
+ state->havedict = 0;
+ state->dmax = 32768U;
+ state->head = Z_NULL;
+ state->wsize = 0;
+ state->whave = 0;
+ state->write = 0;
+ state->hold = 0;
+ state->bits = 0;
+ state->lencode = state->distcode = state->next = state->codes;
+ Tracev((stderr, "inflate: reset\n"));
+ return Z_OK;
+}
+
+int ZEXPORT inflatePrime(strm, bits, value)
+z_streamp strm;
+int bits;
+int value;
+{
+ struct inflate_state FAR *state;
+
+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ state = (struct inflate_state FAR *)strm->state;
+ if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR;
+ value &= (1L << bits) - 1;
+ state->hold += value << state->bits;
+ state->bits += bits;
+ return Z_OK;
+}
+
+int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size)
+z_streamp strm;
+int windowBits;
+const char *version;
+int stream_size;
+{
+ struct inflate_state FAR *state;
+
+ if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
+ stream_size != (int)(sizeof(z_stream)))
+ return Z_VERSION_ERROR;
+ if (strm == Z_NULL) return Z_STREAM_ERROR;
+ strm->msg = Z_NULL; /* in case we return an error */
+ if (strm->zalloc == (alloc_func)0) {
+ strm->zalloc = zcalloc;
+ strm->opaque = (voidpf)0;
+ }
+ if (strm->zfree == (free_func)0) strm->zfree = zcfree;
+ state = (struct inflate_state FAR *)
+ ZALLOC(strm, 1, sizeof(struct inflate_state));
+ if (state == Z_NULL) return Z_MEM_ERROR;
+ Tracev((stderr, "inflate: allocated\n"));
+ strm->state = (struct internal_state FAR *)state;
+ if (windowBits < 0) {
+ state->wrap = 0;
+ windowBits = -windowBits;
+ }
+ else {
+ state->wrap = (windowBits >> 4) + 1;
+#ifdef GUNZIP
+ if (windowBits < 48) windowBits &= 15;
+#endif
+ }
+ if (windowBits < 8 || windowBits > 15) {
+ ZFREE(strm, state);
+ strm->state = Z_NULL;
+ return Z_STREAM_ERROR;
+ }
+ state->wbits = (unsigned)windowBits;
+ state->window = Z_NULL;
+ return inflateReset(strm);
+}
+
+int ZEXPORT inflateInit_(strm, version, stream_size)
+z_streamp strm;
+const char *version;
+int stream_size;
+{
+ return inflateInit2_(strm, DEF_WBITS, version, stream_size);
+}
+
+/*
+ Return state with length and distance decoding tables and index sizes set to
+ fixed code decoding. Normally this returns fixed tables from inffixed.h.
+ If BUILDFIXED is defined, then instead this routine builds the tables the
+ first time it's called, and returns those tables the first time and
+ thereafter. This reduces the size of the code by about 2K bytes, in
+ exchange for a little execution time. However, BUILDFIXED should not be
+ used for threaded applications, since the rewriting of the tables and virgin
+ may not be thread-safe.
+ */
+local void fixedtables(state)
+struct inflate_state FAR *state;
+{
+#ifdef BUILDFIXED
+ static int virgin = 1;
+ static code *lenfix, *distfix;
+ static code fixed[544];
+
+ /* build fixed huffman tables if first call (may not be thread safe) */
+ if (virgin) {
+ unsigned sym, bits;
+ static code *next;
+
+ /* literal/length table */
+ sym = 0;
+ while (sym < 144) state->lens[sym++] = 8;
+ while (sym < 256) state->lens[sym++] = 9;
+ while (sym < 280) state->lens[sym++] = 7;
+ while (sym < 288) state->lens[sym++] = 8;
+ next = fixed;
+ lenfix = next;
+ bits = 9;
+ inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
+
+ /* distance table */
+ sym = 0;
+ while (sym < 32) state->lens[sym++] = 5;
+ distfix = next;
+ bits = 5;
+ inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
+
+ /* do this just once */
+ virgin = 0;
+ }
+#else /* !BUILDFIXED */
+# include "inffixed.h"
+#endif /* BUILDFIXED */
+ state->lencode = lenfix;
+ state->lenbits = 9;
+ state->distcode = distfix;
+ state->distbits = 5;
+}
+
+#ifdef MAKEFIXED
+#include <stdio.h>
+
+/*
+ Write out the inffixed.h that is #include'd above. Defining MAKEFIXED also
+ defines BUILDFIXED, so the tables are built on the fly. makefixed() writes
+ those tables to stdout, which would be piped to inffixed.h. A small program
+ can simply call makefixed to do this:
+
+ void makefixed(void);
+
+ int main(void)
+ {
+ makefixed();
+ return 0;
+ }
+
+ Then that can be linked with zlib built with MAKEFIXED defined and run:
+
+ a.out > inffixed.h
+ */
+void makefixed()
+{
+ unsigned low, size;
+ struct inflate_state state;
+
+ fixedtables(&state);
+ puts(" /* inffixed.h -- table for decoding fixed codes");
+ puts(" * Generated automatically by makefixed().");
+ puts(" */");
+ puts("");
+ puts(" /* WARNING: this file should *not* be used by applications.");
+ puts(" It is part of the implementation of this library and is");
+ puts(" subject to change. Applications should only use zlib.h.");
+ puts(" */");
+ puts("");
+ size = 1U << 9;
+ printf(" static const code lenfix[%u] = {", size);
+ low = 0;
+ for (;;) {
+ if ((low % 7) == 0) printf("\n ");
+ printf("{%u,%u,%d}", state.lencode[low].op, state.lencode[low].bits,
+ state.lencode[low].val);
+ if (++low == size) break;
+ putchar(',');
+ }
+ puts("\n };");
+ size = 1U << 5;
+ printf("\n static const code distfix[%u] = {", size);
+ low = 0;
+ for (;;) {
+ if ((low % 6) == 0) printf("\n ");
+ printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits,
+ state.distcode[low].val);
+ if (++low == size) break;
+ putchar(',');
+ }
+ puts("\n };");
+}
+#endif /* MAKEFIXED */
+
+/*
+ Update the window with the last wsize (normally 32K) bytes written before
+ returning. If window does not exist yet, create it. This is only called
+ when a window is already in use, or when output has been written during this
+ inflate call, but the end of the deflate stream has not been reached yet.
+ It is also called to create a window for dictionary data when a dictionary
+ is loaded.
+
+ Providing output buffers larger than 32K to inflate() should provide a speed
+ advantage, since only the last 32K of output is copied to the sliding window
+ upon return from inflate(), and since all distances after the first 32K of
+ output will fall in the output data, making match copies simpler and faster.
+ The advantage may be dependent on the size of the processor's data caches.
+ */
+local int updatewindow(strm, out)
+z_streamp strm;
+unsigned out;
+{
+ struct inflate_state FAR *state;
+ unsigned copy, dist;
+
+ state = (struct inflate_state FAR *)strm->state;
+
+ /* if it hasn't been done already, allocate space for the window */
+ if (state->window == Z_NULL) {
+ state->window = (unsigned char FAR *)
+ ZALLOC(strm, 1U << state->wbits,
+ sizeof(unsigned char));
+ if (state->window == Z_NULL) return 1;
+ }
+
+ /* if window not in use yet, initialize */
+ if (state->wsize == 0) {
+ state->wsize = 1U << state->wbits;
+ state->write = 0;
+ state->whave = 0;
+ }
+
+ /* copy state->wsize or less output bytes into the circular window */
+ copy = out - strm->avail_out;
+ if (copy >= state->wsize) {
+ zmemcpy(state->window, strm->next_out - state->wsize, state->wsize);
+ state->write = 0;
+ state->whave = state->wsize;
+ }
+ else {
+ dist = state->wsize - state->write;
+ if (dist > copy) dist = copy;
+ zmemcpy(state->window + state->write, strm->next_out - copy, dist);
+ copy -= dist;
+ if (copy) {
+ zmemcpy(state->window, strm->next_out - copy, copy);
+ state->write = copy;
+ state->whave = state->wsize;
+ }
+ else {
+ state->write += dist;
+ if (state->write == state->wsize) state->write = 0;
+ if (state->whave < state->wsize) state->whave += dist;
+ }
+ }
+ return 0;
+}
+
+/* Macros for inflate(): */
+
+/* check function to use adler32() for zlib or crc32() for gzip */
+#ifdef GUNZIP
+# define UPDATE(check, buf, len) \
+ (state->flags ? crc32(check, buf, len) : adler32(check, buf, len))
+#else
+# define UPDATE(check, buf, len) adler32(check, buf, len)
+#endif
+
+/* check macros for header crc */
+#ifdef GUNZIP
+# define CRC2(check, word) \
+ do { \
+ hbuf[0] = (unsigned char)(word); \
+ hbuf[1] = (unsigned char)((word) >> 8); \
+ check = crc32(check, hbuf, 2); \
+ } while (0)
+
+# define CRC4(check, word) \
+ do { \
+ hbuf[0] = (unsigned char)(word); \
+ hbuf[1] = (unsigned char)((word) >> 8); \
+ hbuf[2] = (unsigned char)((word) >> 16); \
+ hbuf[3] = (unsigned char)((word) >> 24); \
+ check = crc32(check, hbuf, 4); \
+ } while (0)
+#endif
+
+/* Load registers with state in inflate() for speed */
+#define LOAD() \
+ do { \
+ put = strm->next_out; \
+ left = strm->avail_out; \
+ next = strm->next_in; \
+ have = strm->avail_in; \
+ hold = state->hold; \
+ bits = state->bits; \
+ } while (0)
+
+/* Restore state from registers in inflate() */
+#define RESTORE() \
+ do { \
+ strm->next_out = put; \
+ strm->avail_out = left; \
+ strm->next_in = next; \
+ strm->avail_in = have; \
+ state->hold = hold; \
+ state->bits = bits; \
+ } while (0)
+
+/* Clear the input bit accumulator */
+#define INITBITS() \
+ do { \
+ hold = 0; \
+ bits = 0; \
+ } while (0)
+
+/* Get a byte of input into the bit accumulator, or return from inflate()
+ if there is no input available. */
+#define PULLBYTE() \
+ do { \
+ if (have == 0) goto inf_leave; \
+ have--; \
+ hold += (unsigned long)(*next++) << bits; \
+ bits += 8; \
+ } while (0)
+
+/* Assure that there are at least n bits in the bit accumulator. If there is
+ not enough available input to do that, then return from inflate(). */
+#define NEEDBITS(n) \
+ do { \
+ while (bits < (unsigned)(n)) \
+ PULLBYTE(); \
+ } while (0)
+
+/* Return the low n bits of the bit accumulator (n < 16) */
+#define BITS(n) \
+ ((unsigned)hold & ((1U << (n)) - 1))
+
+/* Remove n bits from the bit accumulator */
+#define DROPBITS(n) \
+ do { \
+ hold >>= (n); \
+ bits -= (unsigned)(n); \
+ } while (0)
+
+/* Remove zero to seven bits as needed to go to a byte boundary */
+#define BYTEBITS() \
+ do { \
+ hold >>= bits & 7; \
+ bits -= bits & 7; \
+ } while (0)
+
+/* Reverse the bytes in a 32-bit value */
+#define REVERSE(q) \
+ ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
+ (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
+
+/*
+ inflate() uses a state machine to process as much input data and generate as
+ much output data as possible before returning. The state machine is
+ structured roughly as follows:
+
+ for (;;) switch (state) {
+ ...
+ case STATEn:
+ if (not enough input data or output space to make progress)
+ return;
+ ... make progress ...
+ state = STATEm;
+ break;
+ ...
+ }
+
+ so when inflate() is called again, the same case is attempted again, and
+ if the appropriate resources are provided, the machine proceeds to the
+ next state. The NEEDBITS() macro is usually the way the state evaluates
+ whether it can proceed or should return. NEEDBITS() does the return if
+ the requested bits are not available. The typical use of the BITS macros
+ is:
+
+ NEEDBITS(n);
+ ... do something with BITS(n) ...
+ DROPBITS(n);
+
+ where NEEDBITS(n) either returns from inflate() if there isn't enough
+ input left to load n bits into the accumulator, or it continues. BITS(n)
+ gives the low n bits in the accumulator. When done, DROPBITS(n) drops
+ the low n bits off the accumulator. INITBITS() clears the accumulator
+ and sets the number of available bits to zero. BYTEBITS() discards just
+ enough bits to put the accumulator on a byte boundary. After BYTEBITS()
+ and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.
+
+ NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return
+ if there is no input available. The decoding of variable length codes uses
+ PULLBYTE() directly in order to pull just enough bytes to decode the next
+ code, and no more.
+
+ Some states loop until they get enough input, making sure that enough
+ state information is maintained to continue the loop where it left off
+ if NEEDBITS() returns in the loop. For example, want, need, and keep
+ would all have to actually be part of the saved state in case NEEDBITS()
+ returns:
+
+ case STATEw:
+ while (want < need) {
+ NEEDBITS(n);
+ keep[want++] = BITS(n);
+ DROPBITS(n);
+ }
+ state = STATEx;
+ case STATEx:
+
+ As shown above, if the next state is also the next case, then the break
+ is omitted.
+
+ A state may also return if there is not enough output space available to
+ complete that state. Those states are copying stored data, writing a
+ literal byte, and copying a matching string.
+
+ When returning, a "goto inf_leave" is used to update the total counters,
+ update the check value, and determine whether any progress has been made
+ during that inflate() call in order to return the proper return code.
+ Progress is defined as a change in either strm->avail_in or strm->avail_out.
+ When there is a window, goto inf_leave will update the window with the last
+ output written. If a goto inf_leave occurs in the middle of decompression
+ and there is no window currently, goto inf_leave will create one and copy
+ output to the window for the next call of inflate().
+
+ In this implementation, the flush parameter of inflate() only affects the
+ return code (per zlib.h). inflate() always writes as much as possible to
+ strm->next_out, given the space available and the provided input--the effect
+ documented in zlib.h of Z_SYNC_FLUSH. Furthermore, inflate() always defers
+ the allocation of and copying into a sliding window until necessary, which
+ provides the effect documented in zlib.h for Z_FINISH when the entire input
+ stream available. So the only thing the flush parameter actually does is:
+ when flush is set to Z_FINISH, inflate() cannot return Z_OK. Instead it
+ will return Z_BUF_ERROR if it has not reached the end of the stream.
+ */
+
+int ZEXPORT inflate(strm, flush)
+z_streamp strm;
+int flush;
+{
+ struct inflate_state FAR *state;
+ unsigned char FAR *next; /* next input */
+ unsigned char FAR *put; /* next output */
+ unsigned have, left; /* available input and output */
+ unsigned long hold; /* bit buffer */
+ unsigned bits; /* bits in bit buffer */
+ unsigned in, out; /* save starting available input and output */
+ unsigned copy; /* number of stored or match bytes to copy */
+ unsigned char FAR *from; /* where to copy match bytes from */
+ code this; /* current decoding table entry */
+ code last; /* parent table entry */
+ unsigned len; /* length to copy for repeats, bits to drop */
+ int ret; /* return code */
+#ifdef GUNZIP
+ unsigned char hbuf[4]; /* buffer for gzip header crc calculation */
+#endif
+ static const unsigned short order[19] = /* permutation of code lengths */
+ {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
+
+ if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL ||
+ (strm->next_in == Z_NULL && strm->avail_in != 0))
+ return Z_STREAM_ERROR;
+
+ state = (struct inflate_state FAR *)strm->state;
+ if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */
+ LOAD();
+ in = have;
+ out = left;
+ ret = Z_OK;
+ for (;;)
+ switch (state->mode) {
+ case HEAD:
+ if (state->wrap == 0) {
+ state->mode = TYPEDO;
+ break;
+ }
+ NEEDBITS(16);
+#ifdef GUNZIP
+ if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */
+ state->check = crc32(0L, Z_NULL, 0);
+ CRC2(state->check, hold);
+ INITBITS();
+ state->mode = FLAGS;
+ break;
+ }
+ state->flags = 0; /* expect zlib header */
+ if (state->head != Z_NULL)
+ state->head->done = -1;
+ if (!(state->wrap & 1) || /* check if zlib header allowed */
+#else
+ if (
+#endif
+ ((BITS(8) << 8) + (hold >> 8)) % 31) {
+ strm->msg = (char *)"incorrect header check";
+ state->mode = BAD;
+ break;
+ }
+ if (BITS(4) != Z_DEFLATED) {
+ strm->msg = (char *)"unknown compression method";
+ state->mode = BAD;
+ break;
+ }
+ DROPBITS(4);
+ len = BITS(4) + 8;
+ if (len > state->wbits) {
+ strm->msg = (char *)"invalid window size";
+ state->mode = BAD;
+ break;
+ }
+ state->dmax = 1U << len;
+ Tracev((stderr, "inflate: zlib header ok\n"));
+ strm->adler = state->check = adler32(0L, Z_NULL, 0);
+ state->mode = hold & 0x200 ? DICTID : TYPE;
+ INITBITS();
+ break;
+#ifdef GUNZIP
+ case FLAGS:
+ NEEDBITS(16);
+ state->flags = (int)(hold);
+ if ((state->flags & 0xff) != Z_DEFLATED) {
+ strm->msg = (char *)"unknown compression method";
+ state->mode = BAD;
+ break;
+ }
+ if (state->flags & 0xe000) {
+ strm->msg = (char *)"unknown header flags set";
+ state->mode = BAD;
+ break;
+ }
+ if (state->head != Z_NULL)
+ state->head->text = (int)((hold >> 8) & 1);
+ if (state->flags & 0x0200) CRC2(state->check, hold);
+ INITBITS();
+ state->mode = TIME;
+ case TIME:
+ NEEDBITS(32);
+ if (state->head != Z_NULL)
+ state->head->time = hold;
+ if (state->flags & 0x0200) CRC4(state->check, hold);
+ INITBITS();
+ state->mode = OS;
+ case OS:
+ NEEDBITS(16);
+ if (state->head != Z_NULL) {
+ state->head->xflags = (int)(hold & 0xff);
+ state->head->os = (int)(hold >> 8);
+ }
+ if (state->flags & 0x0200) CRC2(state->check, hold);
+ INITBITS();
+ state->mode = EXLEN;
+ case EXLEN:
+ if (state->flags & 0x0400) {
+ NEEDBITS(16);
+ state->length = (unsigned)(hold);
+ if (state->head != Z_NULL)
+ state->head->extra_len = (unsigned)hold;
+ if (state->flags & 0x0200) CRC2(state->check, hold);
+ INITBITS();
+ }
+ else if (state->head != Z_NULL)
+ state->head->extra = Z_NULL;
+ state->mode = EXTRA;
+ case EXTRA:
+ if (state->flags & 0x0400) {
+ copy = state->length;
+ if (copy > have) copy = have;
+ if (copy) {
+ if (state->head != Z_NULL &&
+ state->head->extra != Z_NULL) {
+ len = state->head->extra_len - state->length;
+ zmemcpy(state->head->extra + len, next,
+ len + copy > state->head->extra_max ?
+ state->head->extra_max - len : copy);
+ }
+ if (state->flags & 0x0200)
+ state->check = crc32(state->check, next, copy);
+ have -= copy;
+ next += copy;
+ state->length -= copy;
+ }
+ if (state->length) goto inf_leave;
+ }
+ state->length = 0;
+ state->mode = NAME;
+ case NAME:
+ if (state->flags & 0x0800) {
+ if (have == 0) goto inf_leave;
+ copy = 0;
+ do {
+ len = (unsigned)(next[copy++]);
+ if (state->head != Z_NULL &&
+ state->head->name != Z_NULL &&
+ state->length < state->head->name_max)
+ state->head->name[state->length++] = len;
+ } while (len && copy < have);
+ if (state->flags & 0x0200)
+ state->check = crc32(state->check, next, copy);
+ have -= copy;
+ next += copy;
+ if (len) goto inf_leave;
+ }
+ else if (state->head != Z_NULL)
+ state->head->name = Z_NULL;
+ state->length = 0;
+ state->mode = COMMENT;
+ case COMMENT:
+ if (state->flags & 0x1000) {
+ if (have == 0) goto inf_leave;
+ copy = 0;
+ do {
+ len = (unsigned)(next[copy++]);
+ if (state->head != Z_NULL &&
+ state->head->comment != Z_NULL &&
+ state->length < state->head->comm_max)
+ state->head->comment[state->length++] = len;
+ } while (len && copy < have);
+ if (state->flags & 0x0200)
+ state->check = crc32(state->check, next, copy);
+ have -= copy;
+ next += copy;
+ if (len) goto inf_leave;
+ }
+ else if (state->head != Z_NULL)
+ state->head->comment = Z_NULL;
+ state->mode = HCRC;
+ case HCRC:
+ if (state->flags & 0x0200) {
+ NEEDBITS(16);
+ if (hold != (state->check & 0xffff)) {
+ strm->msg = (char *)"header crc mismatch";
+ state->mode = BAD;
+ break;
+ }
+ INITBITS();
+ }
+ if (state->head != Z_NULL) {
+ state->head->hcrc = (int)((state->flags >> 9) & 1);
+ state->head->done = 1;
+ }
+ strm->adler = state->check = crc32(0L, Z_NULL, 0);
+ state->mode = TYPE;
+ break;
+#endif
+ case DICTID:
+ NEEDBITS(32);
+ strm->adler = state->check = REVERSE(hold);
+ INITBITS();
+ state->mode = DICT;
+ case DICT:
+ if (state->havedict == 0) {
+ RESTORE();
+ return Z_NEED_DICT;
+ }
+ strm->adler = state->check = adler32(0L, Z_NULL, 0);
+ state->mode = TYPE;
+ case TYPE:
+ if (flush == Z_BLOCK) goto inf_leave;
+ case TYPEDO:
+ if (state->last) {
+ BYTEBITS();
+ state->mode = CHECK;
+ break;
+ }
+ NEEDBITS(3);
+ state->last = BITS(1);
+ DROPBITS(1);
+ switch (BITS(2)) {
+ case 0: /* stored block */
+ Tracev((stderr, "inflate: stored block%s\n",
+ state->last ? " (last)" : ""));
+ state->mode = STORED;
+ break;
+ case 1: /* fixed block */
+ fixedtables(state);
+ Tracev((stderr, "inflate: fixed codes block%s\n",
+ state->last ? " (last)" : ""));
+ state->mode = LEN; /* decode codes */
+ break;
+ case 2: /* dynamic block */
+ Tracev((stderr, "inflate: dynamic codes block%s\n",
+ state->last ? " (last)" : ""));
+ state->mode = TABLE;
+ break;
+ case 3:
+ strm->msg = (char *)"invalid block type";
+ state->mode = BAD;
+ }
+ DROPBITS(2);
+ break;
+ case STORED:
+ BYTEBITS(); /* go to byte boundary */
+ NEEDBITS(32);
+ if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
+ strm->msg = (char *)"invalid stored block lengths";
+ state->mode = BAD;
+ break;
+ }
+ state->length = (unsigned)hold & 0xffff;
+ Tracev((stderr, "inflate: stored length %u\n",
+ state->length));
+ INITBITS();
+ state->mode = COPY;
+ case COPY:
+ copy = state->length;
+ if (copy) {
+ if (copy > have) copy = have;
+ if (copy > left) copy = left;
+ if (copy == 0) goto inf_leave;
+ zmemcpy(put, next, copy);
+ have -= copy;
+ next += copy;
+ left -= copy;
+ put += copy;
+ state->length -= copy;
+ break;
+ }
+ Tracev((stderr, "inflate: stored end\n"));
+ state->mode = TYPE;
+ break;
+ case TABLE:
+ NEEDBITS(14);
+ state->nlen = BITS(5) + 257;
+ DROPBITS(5);
+ state->ndist = BITS(5) + 1;
+ DROPBITS(5);
+ state->ncode = BITS(4) + 4;
+ DROPBITS(4);
+#ifndef PKZIP_BUG_WORKAROUND
+ if (state->nlen > 286 || state->ndist > 30) {
+ strm->msg = (char *)"too many length or distance symbols";
+ state->mode = BAD;
+ break;
+ }
+#endif
+ Tracev((stderr, "inflate: table sizes ok\n"));
+ state->have = 0;
+ state->mode = LENLENS;
+ case LENLENS:
+ while (state->have < state->ncode) {
+ NEEDBITS(3);
+ state->lens[order[state->have++]] = (unsigned short)BITS(3);
+ DROPBITS(3);
+ }
+ while (state->have < 19)
+ state->lens[order[state->have++]] = 0;
+ state->next = state->codes;
+ state->lencode = (code const FAR *)(state->next);
+ state->lenbits = 7;
+ ret = inflate_table(CODES, state->lens, 19, &(state->next),
+ &(state->lenbits), state->work);
+ if (ret) {
+ strm->msg = (char *)"invalid code lengths set";
+ state->mode = BAD;
+ break;
+ }
+ Tracev((stderr, "inflate: code lengths ok\n"));
+ state->have = 0;
+ state->mode = CODELENS;
+ case CODELENS:
+ while (state->have < state->nlen + state->ndist) {
+ for (;;) {
+ this = state->lencode[BITS(state->lenbits)];
+ if ((unsigned)(this.bits) <= bits) break;
+ PULLBYTE();
+ }
+ if (this.val < 16) {
+ NEEDBITS(this.bits);
+ DROPBITS(this.bits);
+ state->lens[state->have++] = this.val;
+ }
+ else {
+ if (this.val == 16) {
+ NEEDBITS(this.bits + 2);
+ DROPBITS(this.bits);
+ if (state->have == 0) {
+ strm->msg = (char *)"invalid bit length repeat";
+ state->mode = BAD;
+ break;
+ }
+ len = state->lens[state->have - 1];
+ copy = 3 + BITS(2);
+ DROPBITS(2);
+ }
+ else if (this.val == 17) {
+ NEEDBITS(this.bits + 3);
+ DROPBITS(this.bits);
+ len = 0;
+ copy = 3 + BITS(3);
+ DROPBITS(3);
+ }
+ else {
+ NEEDBITS(this.bits + 7);
+ DROPBITS(this.bits);
+ len = 0;
+ copy = 11 + BITS(7);
+ DROPBITS(7);
+ }
+ if (state->have + copy > state->nlen + state->ndist) {
+ strm->msg = (char *)"invalid bit length repeat";
+ state->mode = BAD;
+ break;
+ }
+ while (copy--)
+ state->lens[state->have++] = (unsigned short)len;
+ }
+ }
+
+ /* handle error breaks in while */
+ if (state->mode == BAD) break;
+
+ /* build code tables */
+ state->next = state->codes;
+ state->lencode = (code const FAR *)(state->next);
+ state->lenbits = 9;
+ ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
+ &(state->lenbits), state->work);
+ if (ret) {
+ strm->msg = (char *)"invalid literal/lengths set";
+ state->mode = BAD;
+ break;
+ }
+ state->distcode = (code const FAR *)(state->next);
+ state->distbits = 6;
+ ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
+ &(state->next), &(state->distbits), state->work);
+ if (ret) {
+ strm->msg = (char *)"invalid distances set";
+ state->mode = BAD;
+ break;
+ }
+ Tracev((stderr, "inflate: codes ok\n"));
+ state->mode = LEN;
+ case LEN:
+ if (have >= 6 && left >= 258) {
+ RESTORE();
+ inflate_fast(strm, out);
+ LOAD();
+ break;
+ }
+ for (;;) {
+ this = state->lencode[BITS(state->lenbits)];
+ if ((unsigned)(this.bits) <= bits) break;
+ PULLBYTE();
+ }
+ if (this.op && (this.op & 0xf0) == 0) {
+ last = this;
+ for (;;) {
+ this = state->lencode[last.val +
+ (BITS(last.bits + last.op) >> last.bits)];
+ if ((unsigned)(last.bits + this.bits) <= bits) break;
+ PULLBYTE();
+ }
+ DROPBITS(last.bits);
+ }
+ DROPBITS(this.bits);
+ state->length = (unsigned)this.val;
+ if ((int)(this.op) == 0) {
+ Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
+ "inflate: literal '%c'\n" :
+ "inflate: literal 0x%02x\n", this.val));
+ state->mode = LIT;
+ break;
+ }
+ if (this.op & 32) {
+ Tracevv((stderr, "inflate: end of block\n"));
+ state->mode = TYPE;
+ break;
+ }
+ if (this.op & 64) {
+ strm->msg = (char *)"invalid literal/length code";
+ state->mode = BAD;
+ break;
+ }
+ state->extra = (unsigned)(this.op) & 15;
+ state->mode = LENEXT;
+ case LENEXT:
+ if (state->extra) {
+ NEEDBITS(state->extra);
+ state->length += BITS(state->extra);
+ DROPBITS(state->extra);
+ }
+ Tracevv((stderr, "inflate: length %u\n", state->length));
+ state->mode = DIST;
+ case DIST:
+ for (;;) {
+ this = state->distcode[BITS(state->distbits)];
+ if ((unsigned)(this.bits) <= bits) break;
+ PULLBYTE();
+ }
+ if ((this.op & 0xf0) == 0) {
+ last = this;
+ for (;;) {
+ this = state->distcode[last.val +
+ (BITS(last.bits + last.op) >> last.bits)];
+ if ((unsigned)(last.bits + this.bits) <= bits) break;
+ PULLBYTE();
+ }
+ DROPBITS(last.bits);
+ }
+ DROPBITS(this.bits);
+ if (this.op & 64) {
+ strm->msg = (char *)"invalid distance code";
+ state->mode = BAD;
+ break;
+ }
+ state->offset = (unsigned)this.val;
+ state->extra = (unsigned)(this.op) & 15;
+ state->mode = DISTEXT;
+ case DISTEXT:
+ if (state->extra) {
+ NEEDBITS(state->extra);
+ state->offset += BITS(state->extra);
+ DROPBITS(state->extra);
+ }
+#ifdef INFLATE_STRICT
+ if (state->offset > state->dmax) {
+ strm->msg = (char *)"invalid distance too far back";
+ state->mode = BAD;
+ break;
+ }
+#endif
+ if (state->offset > state->whave + out - left) {
+ strm->msg = (char *)"invalid distance too far back";
+ state->mode = BAD;
+ break;
+ }
+ Tracevv((stderr, "inflate: distance %u\n", state->offset));
+ state->mode = MATCH;
+ case MATCH:
+ if (left == 0) goto inf_leave;
+ copy = out - left;
+ if (state->offset > copy) { /* copy from window */
+ copy = state->offset - copy;
+ if (copy > state->write) {
+ copy -= state->write;
+ from = state->window + (state->wsize - copy);
+ }
+ else
+ from = state->window + (state->write - copy);
+ if (copy > state->length) copy = state->length;
+ }
+ else { /* copy from output */
+ from = put - state->offset;
+ copy = state->length;
+ }
+ if (copy > left) copy = left;
+ left -= copy;
+ state->length -= copy;
+ do {
+ *put++ = *from++;
+ } while (--copy);
+ if (state->length == 0) state->mode = LEN;
+ break;
+ case LIT:
+ if (left == 0) goto inf_leave;
+ *put++ = (unsigned char)(state->length);
+ left--;
+ state->mode = LEN;
+ break;
+ case CHECK:
+ if (state->wrap) {
+ NEEDBITS(32);
+ out -= left;
+ strm->total_out += out;
+ state->total += out;
+ if (out)
+ strm->adler = state->check =
+ UPDATE(state->check, put - out, out);
+ out = left;
+ if ((
+#ifdef GUNZIP
+ state->flags ? hold :
+#endif
+ REVERSE(hold)) != state->check) {
+ strm->msg = (char *)"incorrect data check";
+ state->mode = BAD;
+ break;
+ }
+ INITBITS();
+ Tracev((stderr, "inflate: check matches trailer\n"));
+ }
+#ifdef GUNZIP
+ state->mode = LENGTH;
+ case LENGTH:
+ if (state->wrap && state->flags) {
+ NEEDBITS(32);
+ if (hold != (state->total & 0xffffffffUL)) {
+ strm->msg = (char *)"incorrect length check";
+ state->mode = BAD;
+ break;
+ }
+ INITBITS();
+ Tracev((stderr, "inflate: length matches trailer\n"));
+ }
+#endif
+ state->mode = DONE;
+ case DONE:
+ ret = Z_STREAM_END;
+ goto inf_leave;
+ case BAD:
+ ret = Z_DATA_ERROR;
+ goto inf_leave;
+ case MEM:
+ return Z_MEM_ERROR;
+ case SYNC:
+ default:
+ return Z_STREAM_ERROR;
+ }
+
+ /*
+ Return from inflate(), updating the total counts and the check value.
+ If there was no progress during the inflate() call, return a buffer
+ error. Call updatewindow() to create and/or update the window state.
+ Note: a memory error from inflate() is non-recoverable.
+ */
+ inf_leave:
+ RESTORE();
+ if (state->wsize || (state->mode < CHECK && out != strm->avail_out))
+ if (updatewindow(strm, out)) {
+ state->mode = MEM;
+ return Z_MEM_ERROR;
+ }
+ in -= strm->avail_in;
+ out -= strm->avail_out;
+ strm->total_in += in;
+ strm->total_out += out;
+ state->total += out;
+ if (state->wrap && out)
+ strm->adler = state->check =
+ UPDATE(state->check, strm->next_out - out, out);
+ strm->data_type = state->bits + (state->last ? 64 : 0) +
+ (state->mode == TYPE ? 128 : 0);
+ if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
+ ret = Z_BUF_ERROR;
+ return ret;
+}
+
+int ZEXPORT inflateEnd(strm)
+z_streamp strm;
+{
+ struct inflate_state FAR *state;
+ if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
+ return Z_STREAM_ERROR;
+ state = (struct inflate_state FAR *)strm->state;
+ if (state->window != Z_NULL) ZFREE(strm, state->window);
+ ZFREE(strm, strm->state);
+ strm->state = Z_NULL;
+ Tracev((stderr, "inflate: end\n"));
+ return Z_OK;
+}
+
+int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength)
+z_streamp strm;
+const Bytef *dictionary;
+uInt dictLength;
+{
+ struct inflate_state FAR *state;
+ unsigned long id;
+
+ /* check state */
+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ state = (struct inflate_state FAR *)strm->state;
+ if (state->wrap != 0 && state->mode != DICT)
+ return Z_STREAM_ERROR;
+
+ /* check for correct dictionary id */
+ if (state->mode == DICT) {
+ id = adler32(0L, Z_NULL, 0);
+ id = adler32(id, dictionary, dictLength);
+ if (id != state->check)
+ return Z_DATA_ERROR;
+ }
+
+ /* copy dictionary to window */
+ if (updatewindow(strm, strm->avail_out)) {
+ state->mode = MEM;
+ return Z_MEM_ERROR;
+ }
+ if (dictLength > state->wsize) {
+ zmemcpy(state->window, dictionary + dictLength - state->wsize,
+ state->wsize);
+ state->whave = state->wsize;
+ }
+ else {
+ zmemcpy(state->window + state->wsize - dictLength, dictionary,
+ dictLength);
+ state->whave = dictLength;
+ }
+ state->havedict = 1;
+ Tracev((stderr, "inflate: dictionary set\n"));
+ return Z_OK;
+}
+
+int ZEXPORT inflateGetHeader(strm, head)
+z_streamp strm;
+gz_headerp head;
+{
+ struct inflate_state FAR *state;
+
+ /* check state */
+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ state = (struct inflate_state FAR *)strm->state;
+ if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;
+
+ /* save header structure */
+ state->head = head;
+ head->done = 0;
+ return Z_OK;
+}
+
+/*
+ Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff. Return when found
+ or when out of input. When called, *have is the number of pattern bytes
+ found in order so far, in 0..3. On return *have is updated to the new
+ state. If on return *have equals four, then the pattern was found and the
+ return value is how many bytes were read including the last byte of the
+ pattern. If *have is less than four, then the pattern has not been found
+ yet and the return value is len. In the latter case, syncsearch() can be
+ called again with more data and the *have state. *have is initialized to
+ zero for the first call.
+ */
+local unsigned syncsearch(have, buf, len)
+unsigned FAR *have;
+unsigned char FAR *buf;
+unsigned len;
+{
+ unsigned got;
+ unsigned next;
+
+ got = *have;
+ next = 0;
+ while (next < len && got < 4) {
+ if ((int)(buf[next]) == (got < 2 ? 0 : 0xff))
+ got++;
+ else if (buf[next])
+ got = 0;
+ else
+ got = 4 - got;
+ next++;
+ }
+ *have = got;
+ return next;
+}
+
+int ZEXPORT inflateSync(strm)
+z_streamp strm;
+{
+ unsigned len; /* number of bytes to look at or looked at */
+ unsigned long in, out; /* temporary to save total_in and total_out */
+ unsigned char buf[4]; /* to restore bit buffer to byte string */
+ struct inflate_state FAR *state;
+
+ /* check parameters */
+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ state = (struct inflate_state FAR *)strm->state;
+ if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;
+
+ /* if first time, start search in bit buffer */
+ if (state->mode != SYNC) {
+ state->mode = SYNC;
+ state->hold <<= state->bits & 7;
+ state->bits -= state->bits & 7;
+ len = 0;
+ while (state->bits >= 8) {
+ buf[len++] = (unsigned char)(state->hold);
+ state->hold >>= 8;
+ state->bits -= 8;
+ }
+ state->have = 0;
+ syncsearch(&(state->have), buf, len);
+ }
+
+ /* search available input */
+ len = syncsearch(&(state->have), strm->next_in, strm->avail_in);
+ strm->avail_in -= len;
+ strm->next_in += len;
+ strm->total_in += len;
+
+ /* return no joy or set up to restart inflate() on a new block */
+ if (state->have != 4) return Z_DATA_ERROR;
+ in = strm->total_in; out = strm->total_out;
+ inflateReset(strm);
+ strm->total_in = in; strm->total_out = out;
+ state->mode = TYPE;
+ return Z_OK;
+}
+
+/*
+ Returns true if inflate is currently at the end of a block generated by
+ Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
+ implementation to provide an additional safety check. PPP uses
+ Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored
+ block. When decompressing, PPP checks that at the end of input packet,
+ inflate is waiting for these length bytes.
+ */
+int ZEXPORT inflateSyncPoint(strm)
+z_streamp strm;
+{
+ struct inflate_state FAR *state;
+
+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ state = (struct inflate_state FAR *)strm->state;
+ return state->mode == STORED && state->bits == 0;
+}
+
+int ZEXPORT inflateCopy(dest, source)
+z_streamp dest;
+z_streamp source;
+{
+ struct inflate_state FAR *state;
+ struct inflate_state FAR *copy;
+ unsigned char FAR *window;
+ unsigned wsize;
+
+ /* check input */
+ if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL ||
+ source->zalloc == (alloc_func)0 || source->zfree == (free_func)0)
+ return Z_STREAM_ERROR;
+ state = (struct inflate_state FAR *)source->state;
+
+ /* allocate space */
+ copy = (struct inflate_state FAR *)
+ ZALLOC(source, 1, sizeof(struct inflate_state));
+ if (copy == Z_NULL) return Z_MEM_ERROR;
+ window = Z_NULL;
+ if (state->window != Z_NULL) {
+ window = (unsigned char FAR *)
+ ZALLOC(source, 1U << state->wbits, sizeof(unsigned char));
+ if (window == Z_NULL) {
+ ZFREE(source, copy);
+ return Z_MEM_ERROR;
+ }
+ }
+
+ /* copy state */
+ zmemcpy(dest, source, sizeof(z_stream));
+ zmemcpy(copy, state, sizeof(struct inflate_state));
+ if (state->lencode >= state->codes &&
+ state->lencode <= state->codes + ENOUGH - 1) {
+ copy->lencode = copy->codes + (state->lencode - state->codes);
+ copy->distcode = copy->codes + (state->distcode - state->codes);
+ }
+ copy->next = copy->codes + (state->next - state->codes);
+ if (window != Z_NULL) {
+ wsize = 1U << state->wbits;
+ zmemcpy(window, state->window, wsize);
+ }
+ copy->window = window;
+ dest->state = (struct internal_state FAR *)copy;
+ return Z_OK;
+}
--- /dev/null
+/* inflate.h -- internal inflate state definition
+ * Copyright (C) 1995-2004 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+ part of the implementation of the compression library and is
+ subject to change. Applications should only use zlib.h.
+ */
+
+/* define NO_GZIP when compiling if you want to disable gzip header and
+ trailer decoding by inflate(). NO_GZIP would be used to avoid linking in
+ the crc code when it is not needed. For shared libraries, gzip decoding
+ should be left enabled. */
+#ifndef NO_GZIP
+# define GUNZIP
+#endif
+
+/* Possible inflate modes between inflate() calls */
+typedef enum {
+ HEAD, /* i: waiting for magic header */
+ FLAGS, /* i: waiting for method and flags (gzip) */
+ TIME, /* i: waiting for modification time (gzip) */
+ OS, /* i: waiting for extra flags and operating system (gzip) */
+ EXLEN, /* i: waiting for extra length (gzip) */
+ EXTRA, /* i: waiting for extra bytes (gzip) */
+ NAME, /* i: waiting for end of file name (gzip) */
+ COMMENT, /* i: waiting for end of comment (gzip) */
+ HCRC, /* i: waiting for header crc (gzip) */
+ DICTID, /* i: waiting for dictionary check value */
+ DICT, /* waiting for inflateSetDictionary() call */
+ TYPE, /* i: waiting for type bits, including last-flag bit */
+ TYPEDO, /* i: same, but skip check to exit inflate on new block */
+ STORED, /* i: waiting for stored size (length and complement) */
+ COPY, /* i/o: waiting for input or output to copy stored block */
+ TABLE, /* i: waiting for dynamic block table lengths */
+ LENLENS, /* i: waiting for code length code lengths */
+ CODELENS, /* i: waiting for length/lit and distance code lengths */
+ LEN, /* i: waiting for length/lit code */
+ LENEXT, /* i: waiting for length extra bits */
+ DIST, /* i: waiting for distance code */
+ DISTEXT, /* i: waiting for distance extra bits */
+ MATCH, /* o: waiting for output space to copy string */
+ LIT, /* o: waiting for output space to write literal */
+ CHECK, /* i: waiting for 32-bit check value */
+ LENGTH, /* i: waiting for 32-bit length (gzip) */
+ DONE, /* finished check, done -- remain here until reset */
+ BAD, /* got a data error -- remain here until reset */
+ MEM, /* got an inflate() memory error -- remain here until reset */
+ SYNC /* looking for synchronization bytes to restart inflate() */
+} inflate_mode;
+
+/*
+ State transitions between above modes -
+
+ (most modes can go to the BAD or MEM mode -- not shown for clarity)
+
+ Process header:
+ HEAD -> (gzip) or (zlib)
+ (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME
+ NAME -> COMMENT -> HCRC -> TYPE
+ (zlib) -> DICTID or TYPE
+ DICTID -> DICT -> TYPE
+ Read deflate blocks:
+ TYPE -> STORED or TABLE or LEN or CHECK
+ STORED -> COPY -> TYPE
+ TABLE -> LENLENS -> CODELENS -> LEN
+ Read deflate codes:
+ LEN -> LENEXT or LIT or TYPE
+ LENEXT -> DIST -> DISTEXT -> MATCH -> LEN
+ LIT -> LEN
+ Process trailer:
+ CHECK -> LENGTH -> DONE
+ */
+
+/* state maintained between inflate() calls. Approximately 7K bytes. */
+struct inflate_state {
+ inflate_mode mode; /* current inflate mode */
+ int last; /* true if processing last block */
+ int wrap; /* bit 0 true for zlib, bit 1 true for gzip */
+ int havedict; /* true if dictionary provided */
+ int flags; /* gzip header method and flags (0 if zlib) */
+ unsigned dmax; /* zlib header max distance (INFLATE_STRICT) */
+ unsigned long check; /* protected copy of check value */
+ unsigned long total; /* protected copy of output count */
+ gz_headerp head; /* where to save gzip header information */
+ /* sliding window */
+ unsigned wbits; /* log base 2 of requested window size */
+ unsigned wsize; /* window size or zero if not using window */
+ unsigned whave; /* valid bytes in the window */
+ unsigned write; /* window write index */
+ unsigned char FAR *window; /* allocated sliding window, if needed */
+ /* bit accumulator */
+ unsigned long hold; /* input bit accumulator */
+ unsigned bits; /* number of bits in "in" */
+ /* for string and stored block copying */
+ unsigned length; /* literal or length of data to copy */
+ unsigned offset; /* distance back to copy string from */
+ /* for table and code decoding */
+ unsigned extra; /* extra bits needed */
+ /* fixed and dynamic code tables */
+ code const FAR *lencode; /* starting table for length/literal codes */
+ code const FAR *distcode; /* starting table for distance codes */
+ unsigned lenbits; /* index bits for lencode */
+ unsigned distbits; /* index bits for distcode */
+ /* dynamic table building */
+ unsigned ncode; /* number of code length code lengths */
+ unsigned nlen; /* number of length code lengths */
+ unsigned ndist; /* number of distance code lengths */
+ unsigned have; /* number of code lengths in lens[] */
+ code FAR *next; /* next available space in codes[] */
+ unsigned short lens[320]; /* temporary storage for code lengths */
+ unsigned short work[288]; /* work area for code table building */
+ code codes[ENOUGH]; /* space for code tables */
+};
--- /dev/null
+/* inftrees.c -- generate Huffman trees for efficient decoding
+ * Copyright (C) 1995-2005 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+
+#define MAXBITS 15
+
+const char inflate_copyright[] =
+ " inflate 1.2.3 Copyright 1995-2005 Mark Adler ";
+/*
+ If you use the zlib library in a product, an acknowledgment is welcome
+ in the documentation of your product. If for some reason you cannot
+ include such an acknowledgment, I would appreciate that you keep this
+ copyright string in the executable of your product.
+ */
+
+/*
+ Build a set of tables to decode the provided canonical Huffman code.
+ The code lengths are lens[0..codes-1]. The result starts at *table,
+ whose indices are 0..2^bits-1. work is a writable array of at least
+ lens shorts, which is used as a work area. type is the type of code
+ to be generated, CODES, LENS, or DISTS. On return, zero is success,
+ -1 is an invalid code, and +1 means that ENOUGH isn't enough. table
+ on return points to the next available entry's address. bits is the
+ requested root table index bits, and on return it is the actual root
+ table index bits. It will differ if the request is greater than the
+ longest code or if it is less than the shortest code.
+ */
+int inflate_table(type, lens, codes, table, bits, work)
+codetype type;
+unsigned short FAR *lens;
+unsigned codes;
+code FAR * FAR *table;
+unsigned FAR *bits;
+unsigned short FAR *work;
+{
+ unsigned len; /* a code's length in bits */
+ unsigned sym; /* index of code symbols */
+ unsigned min, max; /* minimum and maximum code lengths */
+ unsigned root; /* number of index bits for root table */
+ unsigned curr; /* number of index bits for current table */
+ unsigned drop; /* code bits to drop for sub-table */
+ int left; /* number of prefix codes available */
+ unsigned used; /* code entries in table used */
+ unsigned huff; /* Huffman code */
+ unsigned incr; /* for incrementing code, index */
+ unsigned fill; /* index for replicating entries */
+ unsigned low; /* low bits for current root entry */
+ unsigned mask; /* mask for low root bits */
+ code this; /* table entry for duplication */
+ code FAR *next; /* next available space in table */
+ const unsigned short FAR *base; /* base value table to use */
+ const unsigned short FAR *extra; /* extra bits table to use */
+ int end; /* use base and extra for symbol > end */
+ unsigned short count[MAXBITS+1]; /* number of codes of each length */
+ unsigned short offs[MAXBITS+1]; /* offsets in table for each length */
+ static const unsigned short lbase[31] = { /* Length codes 257..285 base */
+ 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
+ 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
+ static const unsigned short lext[31] = { /* Length codes 257..285 extra */
+ 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
+ 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 201, 196};
+ static const unsigned short dbase[32] = { /* Distance codes 0..29 base */
+ 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
+ 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
+ 8193, 12289, 16385, 24577, 0, 0};
+ static const unsigned short dext[32] = { /* Distance codes 0..29 extra */
+ 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
+ 23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
+ 28, 28, 29, 29, 64, 64};
+
+ /*
+ Process a set of code lengths to create a canonical Huffman code. The
+ code lengths are lens[0..codes-1]. Each length corresponds to the
+ symbols 0..codes-1. The Huffman code is generated by first sorting the
+ symbols by length from short to long, and retaining the symbol order
+ for codes with equal lengths. Then the code starts with all zero bits
+ for the first code of the shortest length, and the codes are integer
+ increments for the same length, and zeros are appended as the length
+ increases. For the deflate format, these bits are stored backwards
+ from their more natural integer increment ordering, and so when the
+ decoding tables are built in the large loop below, the integer codes
+ are incremented backwards.
+
+ This routine assumes, but does not check, that all of the entries in
+ lens[] are in the range 0..MAXBITS. The caller must assure this.
+ 1..MAXBITS is interpreted as that code length. zero means that that
+ symbol does not occur in this code.
+
+ The codes are sorted by computing a count of codes for each length,
+ creating from that a table of starting indices for each length in the
+ sorted table, and then entering the symbols in order in the sorted
+ table. The sorted table is work[], with that space being provided by
+ the caller.
+
+ The length counts are used for other purposes as well, i.e. finding
+ the minimum and maximum length codes, determining if there are any
+ codes at all, checking for a valid set of lengths, and looking ahead
+ at length counts to determine sub-table sizes when building the
+ decoding tables.
+ */
+
+ /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
+ for (len = 0; len <= MAXBITS; len++)
+ count[len] = 0;
+ for (sym = 0; sym < codes; sym++)
+ count[lens[sym]]++;
+
+ /* bound code lengths, force root to be within code lengths */
+ root = *bits;
+ for (max = MAXBITS; max >= 1; max--)
+ if (count[max] != 0) break;
+ if (root > max) root = max;
+ if (max == 0) { /* no symbols to code at all */
+ this.op = (unsigned char)64; /* invalid code marker */
+ this.bits = (unsigned char)1;
+ this.val = (unsigned short)0;
+ *(*table)++ = this; /* make a table to force an error */
+ *(*table)++ = this;
+ *bits = 1;
+ return 0; /* no symbols, but wait for decoding to report error */
+ }
+ for (min = 1; min <= MAXBITS; min++)
+ if (count[min] != 0) break;
+ if (root < min) root = min;
+
+ /* check for an over-subscribed or incomplete set of lengths */
+ left = 1;
+ for (len = 1; len <= MAXBITS; len++) {
+ left <<= 1;
+ left -= count[len];
+ if (left < 0) return -1; /* over-subscribed */
+ }
+ if (left > 0 && (type == CODES || max != 1))
+ return -1; /* incomplete set */
+
+ /* generate offsets into symbol table for each length for sorting */
+ offs[1] = 0;
+ for (len = 1; len < MAXBITS; len++)
+ offs[len + 1] = offs[len] + count[len];
+
+ /* sort symbols by length, by symbol order within each length */
+ for (sym = 0; sym < codes; sym++)
+ if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym;
+
+ /*
+ Create and fill in decoding tables. In this loop, the table being
+ filled is at next and has curr index bits. The code being used is huff
+ with length len. That code is converted to an index by dropping drop
+ bits off of the bottom. For codes where len is less than drop + curr,
+ those top drop + curr - len bits are incremented through all values to
+ fill the table with replicated entries.
+
+ root is the number of index bits for the root table. When len exceeds
+ root, sub-tables are created pointed to by the root entry with an index
+ of the low root bits of huff. This is saved in low to check for when a
+ new sub-table should be started. drop is zero when the root table is
+ being filled, and drop is root when sub-tables are being filled.
+
+ When a new sub-table is needed, it is necessary to look ahead in the
+ code lengths to determine what size sub-table is needed. The length
+ counts are used for this, and so count[] is decremented as codes are
+ entered in the tables.
+
+ used keeps track of how many table entries have been allocated from the
+ provided *table space. It is checked when a LENS table is being made
+ against the space in *table, ENOUGH, minus the maximum space needed by
+ the worst case distance code, MAXD. This should never happen, but the
+ sufficiency of ENOUGH has not been proven exhaustively, hence the check.
+ This assumes that when type == LENS, bits == 9.
+
+ sym increments through all symbols, and the loop terminates when
+ all codes of length max, i.e. all codes, have been processed. This
+ routine permits incomplete codes, so another loop after this one fills
+ in the rest of the decoding tables with invalid code markers.
+ */
+
+ /* set up for code type */
+ switch (type) {
+ case CODES:
+ base = extra = work; /* dummy value--not used */
+ end = 19;
+ break;
+ case LENS:
+ base = lbase;
+ base -= 257;
+ extra = lext;
+ extra -= 257;
+ end = 256;
+ break;
+ default: /* DISTS */
+ base = dbase;
+ extra = dext;
+ end = -1;
+ }
+
+ /* initialize state for loop */
+ huff = 0; /* starting code */
+ sym = 0; /* starting code symbol */
+ len = min; /* starting code length */
+ next = *table; /* current table to fill in */
+ curr = root; /* current table index bits */
+ drop = 0; /* current bits to drop from code for index */
+ low = (unsigned)(-1); /* trigger new sub-table when len > root */
+ used = 1U << root; /* use root table entries */
+ mask = used - 1; /* mask for comparing low */
+
+ /* check available table space */
+ if (type == LENS && used >= ENOUGH - MAXD)
+ return 1;
+
+ /* process all codes and make table entries */
+ for (;;) {
+ /* create table entry */
+ this.bits = (unsigned char)(len - drop);
+ if ((int)(work[sym]) < end) {
+ this.op = (unsigned char)0;
+ this.val = work[sym];
+ }
+ else if ((int)(work[sym]) > end) {
+ this.op = (unsigned char)(extra[work[sym]]);
+ this.val = base[work[sym]];
+ }
+ else {
+ this.op = (unsigned char)(32 + 64); /* end of block */
+ this.val = 0;
+ }
+
+ /* replicate for those indices with low len bits equal to huff */
+ incr = 1U << (len - drop);
+ fill = 1U << curr;
+ min = fill; /* save offset to next table */
+ do {
+ fill -= incr;
+ next[(huff >> drop) + fill] = this;
+ } while (fill != 0);
+
+ /* backwards increment the len-bit code huff */
+ incr = 1U << (len - 1);
+ while (huff & incr)
+ incr >>= 1;
+ if (incr != 0) {
+ huff &= incr - 1;
+ huff += incr;
+ }
+ else
+ huff = 0;
+
+ /* go to next symbol, update count, len */
+ sym++;
+ if (--(count[len]) == 0) {
+ if (len == max) break;
+ len = lens[work[sym]];
+ }
+
+ /* create new sub-table if needed */
+ if (len > root && (huff & mask) != low) {
+ /* if first time, transition to sub-tables */
+ if (drop == 0)
+ drop = root;
+
+ /* increment past last table */
+ next += min; /* here min is 1 << curr */
+
+ /* determine length of next table */
+ curr = len - drop;
+ left = (int)(1 << curr);
+ while (curr + drop < max) {
+ left -= count[curr + drop];
+ if (left <= 0) break;
+ curr++;
+ left <<= 1;
+ }
+
+ /* check for enough space */
+ used += 1U << curr;
+ if (type == LENS && used >= ENOUGH - MAXD)
+ return 1;
+
+ /* point entry in root table to sub-table */
+ low = huff & mask;
+ (*table)[low].op = (unsigned char)curr;
+ (*table)[low].bits = (unsigned char)root;
+ (*table)[low].val = (unsigned short)(next - *table);
+ }
+ }
+
+ /*
+ Fill in rest of table for incomplete codes. This loop is similar to the
+ loop above in incrementing huff for table indices. It is assumed that
+ len is equal to curr + drop, so there is no loop needed to increment
+ through high index bits. When the current sub-table is filled, the loop
+ drops back to the root table to fill in any remaining entries there.
+ */
+ this.op = (unsigned char)64; /* invalid code marker */
+ this.bits = (unsigned char)(len - drop);
+ this.val = (unsigned short)0;
+ while (huff != 0) {
+ /* when done with sub-table, drop back to root table */
+ if (drop != 0 && (huff & mask) != low) {
+ drop = 0;
+ len = root;
+ next = *table;
+ this.bits = (unsigned char)len;
+ }
+
+ /* put invalid code marker in table */
+ next[huff >> drop] = this;
+
+ /* backwards increment the len-bit code huff */
+ incr = 1U << (len - 1);
+ while (huff & incr)
+ incr >>= 1;
+ if (incr != 0) {
+ huff &= incr - 1;
+ huff += incr;
+ }
+ else
+ huff = 0;
+ }
+
+ /* set return parameters */
+ *table += used;
+ *bits = root;
+ return 0;
+}
--- /dev/null
+/* inftrees.h -- header to use inftrees.c
+ * Copyright (C) 1995-2005 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+ part of the implementation of the compression library and is
+ subject to change. Applications should only use zlib.h.
+ */
+
+/* Structure for decoding tables. Each entry provides either the
+ information needed to do the operation requested by the code that
+ indexed that table entry, or it provides a pointer to another
+ table that indexes more bits of the code. op indicates whether
+ the entry is a pointer to another table, a literal, a length or
+ distance, an end-of-block, or an invalid code. For a table
+ pointer, the low four bits of op is the number of index bits of
+ that table. For a length or distance, the low four bits of op
+ is the number of extra bits to get after the code. bits is
+ the number of bits in this code or part of the code to drop off
+ of the bit buffer. val is the actual byte to output in the case
+ of a literal, the base length or distance, or the offset from
+ the current table to the next table. Each entry is four bytes. */
+typedef struct {
+ unsigned char op; /* operation, extra bits, table bits */
+ unsigned char bits; /* bits in this part of the code */
+ unsigned short val; /* offset in table or code value */
+} code;
+
+/* op values as set by inflate_table():
+ 00000000 - literal
+ 0000tttt - table link, tttt != 0 is the number of table index bits
+ 0001eeee - length or distance, eeee is the number of extra bits
+ 01100000 - end of block
+ 01000000 - invalid code
+ */
+
+/* Maximum size of dynamic tree. The maximum found in a long but non-
+ exhaustive search was 1444 code structures (852 for length/literals
+ and 592 for distances, the latter actually the result of an
+ exhaustive search). The true maximum is not known, but the value
+ below is more than safe. */
+#define ENOUGH 2048
+#define MAXD 592
+
+/* Type of code to build for inftable() */
+typedef enum {
+ CODES,
+ LENS,
+ DISTS
+} codetype;
+
+extern int inflate_table OF((codetype type, unsigned short FAR *lens,
+ unsigned codes, code FAR * FAR *table,
+ unsigned FAR *bits, unsigned short FAR *work));
--- /dev/null
+/* trees.c -- output deflated data using Huffman coding
+ * Copyright (C) 1995-2005 Jean-loup Gailly
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/*
+ * ALGORITHM
+ *
+ * The "deflation" process uses several Huffman trees. The more
+ * common source values are represented by shorter bit sequences.
+ *
+ * Each code tree is stored in a compressed form which is itself
+ * a Huffman encoding of the lengths of all the code strings (in
+ * ascending order by source values). The actual code strings are
+ * reconstructed from the lengths in the inflate process, as described
+ * in the deflate specification.
+ *
+ * REFERENCES
+ *
+ * Deutsch, L.P.,"'Deflate' Compressed Data Format Specification".
+ * Available in ftp.uu.net:/pub/archiving/zip/doc/deflate-1.1.doc
+ *
+ * Storer, James A.
+ * Data Compression: Methods and Theory, pp. 49-50.
+ * Computer Science Press, 1988. ISBN 0-7167-8156-5.
+ *
+ * Sedgewick, R.
+ * Algorithms, p290.
+ * Addison-Wesley, 1983. ISBN 0-201-06672-6.
+ */
+
+/* @(#) $Id$ */
+
+/* #define GEN_TREES_H */
+
+#include "deflate.h"
+
+#ifdef DEBUG
+# include <ctype.h>
+#endif
+
+/* ===========================================================================
+ * Constants
+ */
+
+#define MAX_BL_BITS 7
+/* Bit length codes must not exceed MAX_BL_BITS bits */
+
+#define END_BLOCK 256
+/* end of block literal code */
+
+#define REP_3_6 16
+/* repeat previous bit length 3-6 times (2 bits of repeat count) */
+
+#define REPZ_3_10 17
+/* repeat a zero length 3-10 times (3 bits of repeat count) */
+
+#define REPZ_11_138 18
+/* repeat a zero length 11-138 times (7 bits of repeat count) */
+
+local const int extra_lbits[LENGTH_CODES] /* extra bits for each length code */
+ = {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0};
+
+local const int extra_dbits[D_CODES] /* extra bits for each distance code */
+ = {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
+
+local const int extra_blbits[BL_CODES]/* extra bits for each bit length code */
+ = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7};
+
+local const uch bl_order[BL_CODES]
+ = {16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15};
+/* The lengths of the bit length codes are sent in order of decreasing
+ * probability, to avoid transmitting the lengths for unused bit length codes.
+ */
+
+#define Buf_size (8 * 2*sizeof(char))
+/* Number of bits used within bi_buf. (bi_buf might be implemented on
+ * more than 16 bits on some systems.)
+ */
+
+/* ===========================================================================
+ * Local data. These are initialized only once.
+ */
+
+#define DIST_CODE_LEN 512 /* see definition of array dist_code below */
+
+#if defined(GEN_TREES_H) || !defined(STDC)
+/* non ANSI compilers may not accept trees.h */
+
+local ct_data static_ltree[L_CODES+2];
+/* The static literal tree. Since the bit lengths are imposed, there is no
+ * need for the L_CODES extra codes used during heap construction. However
+ * The codes 286 and 287 are needed to build a canonical tree (see _tr_init
+ * below).
+ */
+
+local ct_data static_dtree[D_CODES];
+/* The static distance tree. (Actually a trivial tree since all codes use
+ * 5 bits.)
+ */
+
+uch _dist_code[DIST_CODE_LEN];
+/* Distance codes. The first 256 values correspond to the distances
+ * 3 .. 258, the last 256 values correspond to the top 8 bits of
+ * the 15 bit distances.
+ */
+
+uch _length_code[MAX_MATCH-MIN_MATCH+1];
+/* length code for each normalized match length (0 == MIN_MATCH) */
+
+local int base_length[LENGTH_CODES];
+/* First normalized length for each code (0 = MIN_MATCH) */
+
+local int base_dist[D_CODES];
+/* First normalized distance for each code (0 = distance of 1) */
+
+#else
+# include "trees.h"
+#endif /* GEN_TREES_H */
+
+struct static_tree_desc_s {
+ const ct_data *static_tree; /* static tree or NULL */
+ const intf *extra_bits; /* extra bits for each code or NULL */
+ int extra_base; /* base index for extra_bits */
+ int elems; /* max number of elements in the tree */
+ int max_length; /* max bit length for the codes */
+};
+
+local static_tree_desc static_l_desc =
+{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS};
+
+local static_tree_desc static_d_desc =
+{static_dtree, extra_dbits, 0, D_CODES, MAX_BITS};
+
+local static_tree_desc static_bl_desc =
+{(const ct_data *)0, extra_blbits, 0, BL_CODES, MAX_BL_BITS};
+
+/* ===========================================================================
+ * Local (static) routines in this file.
+ */
+
+local void tr_static_init OF((void));
+local void init_block OF((deflate_state *s));
+local void pqdownheap OF((deflate_state *s, ct_data *tree, int k));
+local void gen_bitlen OF((deflate_state *s, tree_desc *desc));
+local void gen_codes OF((ct_data *tree, int max_code, ushf *bl_count));
+local void build_tree OF((deflate_state *s, tree_desc *desc));
+local void scan_tree OF((deflate_state *s, ct_data *tree, int max_code));
+local void send_tree OF((deflate_state *s, ct_data *tree, int max_code));
+local int build_bl_tree OF((deflate_state *s));
+local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes,
+ int blcodes));
+local void compress_block OF((deflate_state *s, ct_data *ltree,
+ ct_data *dtree));
+local void set_data_type OF((deflate_state *s));
+local unsigned bi_reverse OF((unsigned value, int length));
+local void bi_windup OF((deflate_state *s));
+local void bi_flush OF((deflate_state *s));
+local void copy_block OF((deflate_state *s, charf *buf, unsigned len,
+ int header));
+
+#ifdef GEN_TREES_H
+local void gen_trees_header OF((void));
+#endif
+
+#ifndef DEBUG
+# define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len)
+ /* Send a code of the given tree. c and tree must not have side effects */
+
+#else /* DEBUG */
+# define send_code(s, c, tree) \
+ { if (z_verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \
+ send_bits(s, tree[c].Code, tree[c].Len); }
+#endif
+
+/* ===========================================================================
+ * Output a short LSB first on the stream.
+ * IN assertion: there is enough room in pendingBuf.
+ */
+#define put_short(s, w) { \
+ put_byte(s, (uch)((w) & 0xff)); \
+ put_byte(s, (uch)((ush)(w) >> 8)); \
+}
+
+/* ===========================================================================
+ * Send a value on a given number of bits.
+ * IN assertion: length <= 16 and value fits in length bits.
+ */
+#ifdef DEBUG
+local void send_bits OF((deflate_state *s, int value, int length));
+
+local void send_bits(s, value, length)
+ deflate_state *s;
+ int value; /* value to send */
+ int length; /* number of bits */
+{
+ Tracevv((stderr," l %2d v %4x ", length, value));
+ Assert(length > 0 && length <= 15, "invalid length");
+ s->bits_sent += (ulg)length;
+
+ /* If not enough room in bi_buf, use (valid) bits from bi_buf and
+ * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid))
+ * unused bits in value.
+ */
+ if (s->bi_valid > (int)Buf_size - length) {
+ s->bi_buf |= (value << s->bi_valid);
+ put_short(s, s->bi_buf);
+ s->bi_buf = (ush)value >> (Buf_size - s->bi_valid);
+ s->bi_valid += length - Buf_size;
+ } else {
+ s->bi_buf |= value << s->bi_valid;
+ s->bi_valid += length;
+ }
+}
+#else /* !DEBUG */
+
+#define send_bits(s, value, length) \
+{ int len = length;\
+ if (s->bi_valid > (int)Buf_size - len) {\
+ int val = value;\
+ s->bi_buf |= (val << s->bi_valid);\
+ put_short(s, s->bi_buf);\
+ s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\
+ s->bi_valid += len - Buf_size;\
+ } else {\
+ s->bi_buf |= (value) << s->bi_valid;\
+ s->bi_valid += len;\
+ }\
+}
+#endif /* DEBUG */
+
+
+/* the arguments must not have side effects */
+
+/* ===========================================================================
+ * Initialize the various 'constant' tables.
+ */
+local void tr_static_init()
+{
+#if defined(GEN_TREES_H) || !defined(STDC)
+ static int static_init_done = 0;
+ int n; /* iterates over tree elements */
+ int bits; /* bit counter */
+ int length; /* length value */
+ int code; /* code value */
+ int dist; /* distance index */
+ ush bl_count[MAX_BITS+1];
+ /* number of codes at each bit length for an optimal tree */
+
+ if (static_init_done) return;
+
+ /* For some embedded targets, global variables are not initialized: */
+ static_l_desc.static_tree = static_ltree;
+ static_l_desc.extra_bits = extra_lbits;
+ static_d_desc.static_tree = static_dtree;
+ static_d_desc.extra_bits = extra_dbits;
+ static_bl_desc.extra_bits = extra_blbits;
+
+ /* Initialize the mapping length (0..255) -> length code (0..28) */
+ length = 0;
+ for (code = 0; code < LENGTH_CODES-1; code++) {
+ base_length[code] = length;
+ for (n = 0; n < (1<<extra_lbits[code]); n++) {
+ _length_code[length++] = (uch)code;
+ }
+ }
+ Assert (length == 256, "tr_static_init: length != 256");
+ /* Note that the length 255 (match length 258) can be represented
+ * in two different ways: code 284 + 5 bits or code 285, so we
+ * overwrite length_code[255] to use the best encoding:
+ */
+ _length_code[length-1] = (uch)code;
+
+ /* Initialize the mapping dist (0..32K) -> dist code (0..29) */
+ dist = 0;
+ for (code = 0 ; code < 16; code++) {
+ base_dist[code] = dist;
+ for (n = 0; n < (1<<extra_dbits[code]); n++) {
+ _dist_code[dist++] = (uch)code;
+ }
+ }
+ Assert (dist == 256, "tr_static_init: dist != 256");
+ dist >>= 7; /* from now on, all distances are divided by 128 */
+ for ( ; code < D_CODES; code++) {
+ base_dist[code] = dist << 7;
+ for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) {
+ _dist_code[256 + dist++] = (uch)code;
+ }
+ }
+ Assert (dist == 256, "tr_static_init: 256+dist != 512");
+
+ /* Construct the codes of the static literal tree */
+ for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0;
+ n = 0;
+ while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++;
+ while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++;
+ while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++;
+ while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++;
+ /* Codes 286 and 287 do not exist, but we must include them in the
+ * tree construction to get a canonical Huffman tree (longest code
+ * all ones)
+ */
+ gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count);
+
+ /* The static distance tree is trivial: */
+ for (n = 0; n < D_CODES; n++) {
+ static_dtree[n].Len = 5;
+ static_dtree[n].Code = bi_reverse((unsigned)n, 5);
+ }
+ static_init_done = 1;
+
+# ifdef GEN_TREES_H
+ gen_trees_header();
+# endif
+#endif /* defined(GEN_TREES_H) || !defined(STDC) */
+}
+
+/* ===========================================================================
+ * Genererate the file trees.h describing the static trees.
+ */
+#ifdef GEN_TREES_H
+# ifndef DEBUG
+# include <stdio.h>
+# endif
+
+# define SEPARATOR(i, last, width) \
+ ((i) == (last)? "\n};\n\n" : \
+ ((i) % (width) == (width)-1 ? ",\n" : ", "))
+
+void gen_trees_header()
+{
+ FILE *header = fopen("trees.h", "w");
+ int i;
+
+ Assert (header != NULL, "Can't open trees.h");
+ fprintf(header,
+ "/* header created automatically with -DGEN_TREES_H */\n\n");
+
+ fprintf(header, "local const ct_data static_ltree[L_CODES+2] = {\n");
+ for (i = 0; i < L_CODES+2; i++) {
+ fprintf(header, "{{%3u},{%3u}}%s", static_ltree[i].Code,
+ static_ltree[i].Len, SEPARATOR(i, L_CODES+1, 5));
+ }
+
+ fprintf(header, "local const ct_data static_dtree[D_CODES] = {\n");
+ for (i = 0; i < D_CODES; i++) {
+ fprintf(header, "{{%2u},{%2u}}%s", static_dtree[i].Code,
+ static_dtree[i].Len, SEPARATOR(i, D_CODES-1, 5));
+ }
+
+ fprintf(header, "const uch _dist_code[DIST_CODE_LEN] = {\n");
+ for (i = 0; i < DIST_CODE_LEN; i++) {
+ fprintf(header, "%2u%s", _dist_code[i],
+ SEPARATOR(i, DIST_CODE_LEN-1, 20));
+ }
+
+ fprintf(header, "const uch _length_code[MAX_MATCH-MIN_MATCH+1]= {\n");
+ for (i = 0; i < MAX_MATCH-MIN_MATCH+1; i++) {
+ fprintf(header, "%2u%s", _length_code[i],
+ SEPARATOR(i, MAX_MATCH-MIN_MATCH, 20));
+ }
+
+ fprintf(header, "local const int base_length[LENGTH_CODES] = {\n");
+ for (i = 0; i < LENGTH_CODES; i++) {
+ fprintf(header, "%1u%s", base_length[i],
+ SEPARATOR(i, LENGTH_CODES-1, 20));
+ }
+
+ fprintf(header, "local const int base_dist[D_CODES] = {\n");
+ for (i = 0; i < D_CODES; i++) {
+ fprintf(header, "%5u%s", base_dist[i],
+ SEPARATOR(i, D_CODES-1, 10));
+ }
+
+ fclose(header);
+}
+#endif /* GEN_TREES_H */
+
+/* ===========================================================================
+ * Initialize the tree data structures for a new zlib stream.
+ */
+void _tr_init(s)
+ deflate_state *s;
+{
+ tr_static_init();
+
+ s->l_desc.dyn_tree = s->dyn_ltree;
+ s->l_desc.stat_desc = &static_l_desc;
+
+ s->d_desc.dyn_tree = s->dyn_dtree;
+ s->d_desc.stat_desc = &static_d_desc;
+
+ s->bl_desc.dyn_tree = s->bl_tree;
+ s->bl_desc.stat_desc = &static_bl_desc;
+
+ s->bi_buf = 0;
+ s->bi_valid = 0;
+ s->last_eob_len = 8; /* enough lookahead for inflate */
+#ifdef DEBUG
+ s->compressed_len = 0L;
+ s->bits_sent = 0L;
+#endif
+
+ /* Initialize the first block of the first file: */
+ init_block(s);
+}
+
+/* ===========================================================================
+ * Initialize a new block.
+ */
+local void init_block(s)
+ deflate_state *s;
+{
+ int n; /* iterates over tree elements */
+
+ /* Initialize the trees. */
+ for (n = 0; n < L_CODES; n++) s->dyn_ltree[n].Freq = 0;
+ for (n = 0; n < D_CODES; n++) s->dyn_dtree[n].Freq = 0;
+ for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0;
+
+ s->dyn_ltree[END_BLOCK].Freq = 1;
+ s->opt_len = s->static_len = 0L;
+ s->last_lit = s->matches = 0;
+}
+
+#define SMALLEST 1
+/* Index within the heap array of least frequent node in the Huffman tree */
+
+
+/* ===========================================================================
+ * Remove the smallest element from the heap and recreate the heap with
+ * one less element. Updates heap and heap_len.
+ */
+#define pqremove(s, tree, top) \
+{\
+ top = s->heap[SMALLEST]; \
+ s->heap[SMALLEST] = s->heap[s->heap_len--]; \
+ pqdownheap(s, tree, SMALLEST); \
+}
+
+/* ===========================================================================
+ * Compares to subtrees, using the tree depth as tie breaker when
+ * the subtrees have equal frequency. This minimizes the worst case length.
+ */
+#define smaller(tree, n, m, depth) \
+ (tree[n].Freq < tree[m].Freq || \
+ (tree[n].Freq == tree[m].Freq && depth[n] <= depth[m]))
+
+/* ===========================================================================
+ * Restore the heap property by moving down the tree starting at node k,
+ * exchanging a node with the smallest of its two sons if necessary, stopping
+ * when the heap property is re-established (each father smaller than its
+ * two sons).
+ */
+local void pqdownheap(s, tree, k)
+ deflate_state *s;
+ ct_data *tree; /* the tree to restore */
+ int k; /* node to move down */
+{
+ int v = s->heap[k];
+ int j = k << 1; /* left son of k */
+ while (j <= s->heap_len) {
+ /* Set j to the smallest of the two sons: */
+ if (j < s->heap_len &&
+ smaller(tree, s->heap[j+1], s->heap[j], s->depth)) {
+ j++;
+ }
+ /* Exit if v is smaller than both sons */
+ if (smaller(tree, v, s->heap[j], s->depth)) break;
+
+ /* Exchange v with the smallest son */
+ s->heap[k] = s->heap[j]; k = j;
+
+ /* And continue down the tree, setting j to the left son of k */
+ j <<= 1;
+ }
+ s->heap[k] = v;
+}
+
+/* ===========================================================================
+ * Compute the optimal bit lengths for a tree and update the total bit length
+ * for the current block.
+ * IN assertion: the fields freq and dad are set, heap[heap_max] and
+ * above are the tree nodes sorted by increasing frequency.
+ * OUT assertions: the field len is set to the optimal bit length, the
+ * array bl_count contains the frequencies for each bit length.
+ * The length opt_len is updated; static_len is also updated if stree is
+ * not null.
+ */
+local void gen_bitlen(s, desc)
+ deflate_state *s;
+ tree_desc *desc; /* the tree descriptor */
+{
+ ct_data *tree = desc->dyn_tree;
+ int max_code = desc->max_code;
+ const ct_data *stree = desc->stat_desc->static_tree;
+ const intf *extra = desc->stat_desc->extra_bits;
+ int base = desc->stat_desc->extra_base;
+ int max_length = desc->stat_desc->max_length;
+ int h; /* heap index */
+ int n, m; /* iterate over the tree elements */
+ int bits; /* bit length */
+ int xbits; /* extra bits */
+ ush f; /* frequency */
+ int overflow = 0; /* number of elements with bit length too large */
+
+ for (bits = 0; bits <= MAX_BITS; bits++) s->bl_count[bits] = 0;
+
+ /* In a first pass, compute the optimal bit lengths (which may
+ * overflow in the case of the bit length tree).
+ */
+ tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */
+
+ for (h = s->heap_max+1; h < HEAP_SIZE; h++) {
+ n = s->heap[h];
+ bits = tree[tree[n].Dad].Len + 1;
+ if (bits > max_length) bits = max_length, overflow++;
+ tree[n].Len = (ush)bits;
+ /* We overwrite tree[n].Dad which is no longer needed */
+
+ if (n > max_code) continue; /* not a leaf node */
+
+ s->bl_count[bits]++;
+ xbits = 0;
+ if (n >= base) xbits = extra[n-base];
+ f = tree[n].Freq;
+ s->opt_len += (ulg)f * (bits + xbits);
+ if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits);
+ }
+ if (overflow == 0) return;
+
+ Trace((stderr,"\nbit length overflow\n"));
+ /* This happens for example on obj2 and pic of the Calgary corpus */
+
+ /* Find the first bit length which could increase: */
+ do {
+ bits = max_length-1;
+ while (s->bl_count[bits] == 0) bits--;
+ s->bl_count[bits]--; /* move one leaf down the tree */
+ s->bl_count[bits+1] += 2; /* move one overflow item as its brother */
+ s->bl_count[max_length]--;
+ /* The brother of the overflow item also moves one step up,
+ * but this does not affect bl_count[max_length]
+ */
+ overflow -= 2;
+ } while (overflow > 0);
+
+ /* Now recompute all bit lengths, scanning in increasing frequency.
+ * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
+ * lengths instead of fixing only the wrong ones. This idea is taken
+ * from 'ar' written by Haruhiko Okumura.)
+ */
+ for (bits = max_length; bits != 0; bits--) {
+ n = s->bl_count[bits];
+ while (n != 0) {
+ m = s->heap[--h];
+ if (m > max_code) continue;
+ if ((unsigned) tree[m].Len != (unsigned) bits) {
+ Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
+ s->opt_len += ((long)bits - (long)tree[m].Len)
+ *(long)tree[m].Freq;
+ tree[m].Len = (ush)bits;
+ }
+ n--;
+ }
+ }
+}
+
+/* ===========================================================================
+ * Generate the codes for a given tree and bit counts (which need not be
+ * optimal).
+ * IN assertion: the array bl_count contains the bit length statistics for
+ * the given tree and the field len is set for all tree elements.
+ * OUT assertion: the field code is set for all tree elements of non
+ * zero code length.
+ */
+local void gen_codes (tree, max_code, bl_count)
+ ct_data *tree; /* the tree to decorate */
+ int max_code; /* largest code with non zero frequency */
+ ushf *bl_count; /* number of codes at each bit length */
+{
+ ush next_code[MAX_BITS+1]; /* next code value for each bit length */
+ ush code = 0; /* running code value */
+ int bits; /* bit index */
+ int n; /* code index */
+
+ /* The distribution counts are first used to generate the code values
+ * without bit reversal.
+ */
+ for (bits = 1; bits <= MAX_BITS; bits++) {
+ next_code[bits] = code = (code + bl_count[bits-1]) << 1;
+ }
+ /* Check that the bit counts in bl_count are consistent. The last code
+ * must be all ones.
+ */
+ Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
+ "inconsistent bit counts");
+ Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
+
+ for (n = 0; n <= max_code; n++) {
+ int len = tree[n].Len;
+ if (len == 0) continue;
+ /* Now reverse the bits */
+ tree[n].Code = bi_reverse(next_code[len]++, len);
+
+ Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",
+ n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));
+ }
+}
+
+/* ===========================================================================
+ * Construct one Huffman tree and assigns the code bit strings and lengths.
+ * Update the total bit length for the current block.
+ * IN assertion: the field freq is set for all tree elements.
+ * OUT assertions: the fields len and code are set to the optimal bit length
+ * and corresponding code. The length opt_len is updated; static_len is
+ * also updated if stree is not null. The field max_code is set.
+ */
+local void build_tree(s, desc)
+ deflate_state *s;
+ tree_desc *desc; /* the tree descriptor */
+{
+ ct_data *tree = desc->dyn_tree;
+ const ct_data *stree = desc->stat_desc->static_tree;
+ int elems = desc->stat_desc->elems;
+ int n, m; /* iterate over heap elements */
+ int max_code = -1; /* largest code with non zero frequency */
+ int node; /* new node being created */
+
+ /* Construct the initial heap, with least frequent element in
+ * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
+ * heap[0] is not used.
+ */
+ s->heap_len = 0, s->heap_max = HEAP_SIZE;
+
+ for (n = 0; n < elems; n++) {
+ if (tree[n].Freq != 0) {
+ s->heap[++(s->heap_len)] = max_code = n;
+ s->depth[n] = 0;
+ } else {
+ tree[n].Len = 0;
+ }
+ }
+
+ /* The pkzip format requires that at least one distance code exists,
+ * and that at least one bit should be sent even if there is only one
+ * possible code. So to avoid special checks later on we force at least
+ * two codes of non zero frequency.
+ */
+ while (s->heap_len < 2) {
+ node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0);
+ tree[node].Freq = 1;
+ s->depth[node] = 0;
+ s->opt_len--; if (stree) s->static_len -= stree[node].Len;
+ /* node is 0 or 1 so it does not have extra bits */
+ }
+ desc->max_code = max_code;
+
+ /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
+ * establish sub-heaps of increasing lengths:
+ */
+ for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n);
+
+ /* Construct the Huffman tree by repeatedly combining the least two
+ * frequent nodes.
+ */
+ node = elems; /* next internal node of the tree */
+ do {
+ pqremove(s, tree, n); /* n = node of least frequency */
+ m = s->heap[SMALLEST]; /* m = node of next least frequency */
+
+ s->heap[--(s->heap_max)] = n; /* keep the nodes sorted by frequency */
+ s->heap[--(s->heap_max)] = m;
+
+ /* Create a new node father of n and m */
+ tree[node].Freq = tree[n].Freq + tree[m].Freq;
+ s->depth[node] = (uch)((s->depth[n] >= s->depth[m] ?
+ s->depth[n] : s->depth[m]) + 1);
+ tree[n].Dad = tree[m].Dad = (ush)node;
+#ifdef DUMP_BL_TREE
+ if (tree == s->bl_tree) {
+ fprintf(stderr,"\nnode %d(%d), sons %d(%d) %d(%d)",
+ node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq);
+ }
+#endif
+ /* and insert the new node in the heap */
+ s->heap[SMALLEST] = node++;
+ pqdownheap(s, tree, SMALLEST);
+
+ } while (s->heap_len >= 2);
+
+ s->heap[--(s->heap_max)] = s->heap[SMALLEST];
+
+ /* At this point, the fields freq and dad are set. We can now
+ * generate the bit lengths.
+ */
+ gen_bitlen(s, (tree_desc *)desc);
+
+ /* The field len is now set, we can generate the bit codes */
+ gen_codes ((ct_data *)tree, max_code, s->bl_count);
+}
+
+/* ===========================================================================
+ * Scan a literal or distance tree to determine the frequencies of the codes
+ * in the bit length tree.
+ */
+local void scan_tree (s, tree, max_code)
+ deflate_state *s;
+ ct_data *tree; /* the tree to be scanned */
+ int max_code; /* and its largest code of non zero frequency */
+{
+ int n; /* iterates over all tree elements */
+ int prevlen = -1; /* last emitted length */
+ int curlen; /* length of current code */
+ int nextlen = tree[0].Len; /* length of next code */
+ int count = 0; /* repeat count of the current code */
+ int max_count = 7; /* max repeat count */
+ int min_count = 4; /* min repeat count */
+
+ if (nextlen == 0) max_count = 138, min_count = 3;
+ tree[max_code+1].Len = (ush)0xffff; /* guard */
+
+ for (n = 0; n <= max_code; n++) {
+ curlen = nextlen; nextlen = tree[n+1].Len;
+ if (++count < max_count && curlen == nextlen) {
+ continue;
+ } else if (count < min_count) {
+ s->bl_tree[curlen].Freq += count;
+ } else if (curlen != 0) {
+ if (curlen != prevlen) s->bl_tree[curlen].Freq++;
+ s->bl_tree[REP_3_6].Freq++;
+ } else if (count <= 10) {
+ s->bl_tree[REPZ_3_10].Freq++;
+ } else {
+ s->bl_tree[REPZ_11_138].Freq++;
+ }
+ count = 0; prevlen = curlen;
+ if (nextlen == 0) {
+ max_count = 138, min_count = 3;
+ } else if (curlen == nextlen) {
+ max_count = 6, min_count = 3;
+ } else {
+ max_count = 7, min_count = 4;
+ }
+ }
+}
+
+/* ===========================================================================
+ * Send a literal or distance tree in compressed form, using the codes in
+ * bl_tree.
+ */
+local void send_tree (s, tree, max_code)
+ deflate_state *s;
+ ct_data *tree; /* the tree to be scanned */
+ int max_code; /* and its largest code of non zero frequency */
+{
+ int n; /* iterates over all tree elements */
+ int prevlen = -1; /* last emitted length */
+ int curlen; /* length of current code */
+ int nextlen = tree[0].Len; /* length of next code */
+ int count = 0; /* repeat count of the current code */
+ int max_count = 7; /* max repeat count */
+ int min_count = 4; /* min repeat count */
+
+ /* tree[max_code+1].Len = -1; */ /* guard already set */
+ if (nextlen == 0) max_count = 138, min_count = 3;
+
+ for (n = 0; n <= max_code; n++) {
+ curlen = nextlen; nextlen = tree[n+1].Len;
+ if (++count < max_count && curlen == nextlen) {
+ continue;
+ } else if (count < min_count) {
+ do { send_code(s, curlen, s->bl_tree); } while (--count != 0);
+
+ } else if (curlen != 0) {
+ if (curlen != prevlen) {
+ send_code(s, curlen, s->bl_tree); count--;
+ }
+ Assert(count >= 3 && count <= 6, " 3_6?");
+ send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2);
+
+ } else if (count <= 10) {
+ send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3);
+
+ } else {
+ send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count-11, 7);
+ }
+ count = 0; prevlen = curlen;
+ if (nextlen == 0) {
+ max_count = 138, min_count = 3;
+ } else if (curlen == nextlen) {
+ max_count = 6, min_count = 3;
+ } else {
+ max_count = 7, min_count = 4;
+ }
+ }
+}
+
+/* ===========================================================================
+ * Construct the Huffman tree for the bit lengths and return the index in
+ * bl_order of the last bit length code to send.
+ */
+local int build_bl_tree(s)
+ deflate_state *s;
+{
+ int max_blindex; /* index of last bit length code of non zero freq */
+
+ /* Determine the bit length frequencies for literal and distance trees */
+ scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code);
+ scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code);
+
+ /* Build the bit length tree: */
+ build_tree(s, (tree_desc *)(&(s->bl_desc)));
+ /* opt_len now includes the length of the tree representations, except
+ * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
+ */
+
+ /* Determine the number of bit length codes to send. The pkzip format
+ * requires that at least 4 bit length codes be sent. (appnote.txt says
+ * 3 but the actual value used is 4.)
+ */
+ for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) {
+ if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;
+ }
+ /* Update opt_len to include the bit length tree and counts */
+ s->opt_len += 3*(max_blindex+1) + 5+5+4;
+ Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
+ s->opt_len, s->static_len));
+
+ return max_blindex;
+}
+
+/* ===========================================================================
+ * Send the header for a block using dynamic Huffman trees: the counts, the
+ * lengths of the bit length codes, the literal tree and the distance tree.
+ * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
+ */
+local void send_all_trees(s, lcodes, dcodes, blcodes)
+ deflate_state *s;
+ int lcodes, dcodes, blcodes; /* number of codes for each tree */
+{
+ int rank; /* index in bl_order */
+
+ Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
+ Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,
+ "too many codes");
+ Tracev((stderr, "\nbl counts: "));
+ send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */
+ send_bits(s, dcodes-1, 5);
+ send_bits(s, blcodes-4, 4); /* not -3 as stated in appnote.txt */
+ for (rank = 0; rank < blcodes; rank++) {
+ Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
+ send_bits(s, s->bl_tree[bl_order[rank]].Len, 3);
+ }
+ Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent));
+
+ send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */
+ Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent));
+
+ send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */
+ Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent));
+}
+
+/* ===========================================================================
+ * Send a stored block
+ */
+void _tr_stored_block(s, buf, stored_len, eof)
+ deflate_state *s;
+ charf *buf; /* input block */
+ ulg stored_len; /* length of input block */
+ int eof; /* true if this is the last block for a file */
+{
+ send_bits(s, (STORED_BLOCK<<1)+eof, 3); /* send block type */
+#ifdef DEBUG
+ s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;
+ s->compressed_len += (stored_len + 4) << 3;
+#endif
+ copy_block(s, buf, (unsigned)stored_len, 1); /* with header */
+}
+
+/* ===========================================================================
+ * Send one empty static block to give enough lookahead for inflate.
+ * This takes 10 bits, of which 7 may remain in the bit buffer.
+ * The current inflate code requires 9 bits of lookahead. If the
+ * last two codes for the previous block (real code plus EOB) were coded
+ * on 5 bits or less, inflate may have only 5+3 bits of lookahead to decode
+ * the last real code. In this case we send two empty static blocks instead
+ * of one. (There are no problems if the previous block is stored or fixed.)
+ * To simplify the code, we assume the worst case of last real code encoded
+ * on one bit only.
+ */
+void _tr_align(s)
+ deflate_state *s;
+{
+ send_bits(s, STATIC_TREES<<1, 3);
+ send_code(s, END_BLOCK, static_ltree);
+#ifdef DEBUG
+ s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
+#endif
+ bi_flush(s);
+ /* Of the 10 bits for the empty block, we have already sent
+ * (10 - bi_valid) bits. The lookahead for the last real code (before
+ * the EOB of the previous block) was thus at least one plus the length
+ * of the EOB plus what we have just sent of the empty static block.
+ */
+ if (1 + s->last_eob_len + 10 - s->bi_valid < 9) {
+ send_bits(s, STATIC_TREES<<1, 3);
+ send_code(s, END_BLOCK, static_ltree);
+#ifdef DEBUG
+ s->compressed_len += 10L;
+#endif
+ bi_flush(s);
+ }
+ s->last_eob_len = 7;
+}
+
+/* ===========================================================================
+ * Determine the best encoding for the current block: dynamic trees, static
+ * trees or store, and output the encoded block to the zip file.
+ */
+void _tr_flush_block(s, buf, stored_len, eof)
+ deflate_state *s;
+ charf *buf; /* input block, or NULL if too old */
+ ulg stored_len; /* length of input block */
+ int eof; /* true if this is the last block for a file */
+{
+ ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */
+ int max_blindex = 0; /* index of last bit length code of non zero freq */
+
+ /* Build the Huffman trees unless a stored block is forced */
+ if (s->level > 0) {
+
+ /* Check if the file is binary or text */
+ if (stored_len > 0 && s->strm->data_type == Z_UNKNOWN)
+ set_data_type(s);
+
+ /* Construct the literal and distance trees */
+ build_tree(s, (tree_desc *)(&(s->l_desc)));
+ Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,
+ s->static_len));
+
+ build_tree(s, (tree_desc *)(&(s->d_desc)));
+ Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,
+ s->static_len));
+ /* At this point, opt_len and static_len are the total bit lengths of
+ * the compressed block data, excluding the tree representations.
+ */
+
+ /* Build the bit length tree for the above two trees, and get the index
+ * in bl_order of the last bit length code to send.
+ */
+ max_blindex = build_bl_tree(s);
+
+ /* Determine the best encoding. Compute the block lengths in bytes. */
+ opt_lenb = (s->opt_len+3+7)>>3;
+ static_lenb = (s->static_len+3+7)>>3;
+
+ Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",
+ opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,
+ s->last_lit));
+
+ if (static_lenb <= opt_lenb) opt_lenb = static_lenb;
+
+ } else {
+ Assert(buf != (char*)0, "lost buf");
+ opt_lenb = static_lenb = stored_len + 5; /* force a stored block */
+ }
+
+#ifdef FORCE_STORED
+ if (buf != (char*)0) { /* force stored block */
+#else
+ if (stored_len+4 <= opt_lenb && buf != (char*)0) {
+ /* 4: two words for the lengths */
+#endif
+ /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
+ * Otherwise we can't have processed more than WSIZE input bytes since
+ * the last block flush, because compression would have been
+ * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
+ * transform a block into a stored block.
+ */
+ _tr_stored_block(s, buf, stored_len, eof);
+
+#ifdef FORCE_STATIC
+ } else if (static_lenb >= 0) { /* force static trees */
+#else
+ } else if (s->strategy == Z_FIXED || static_lenb == opt_lenb) {
+#endif
+ send_bits(s, (STATIC_TREES<<1)+eof, 3);
+ compress_block(s, (ct_data *)static_ltree, (ct_data *)static_dtree);
+#ifdef DEBUG
+ s->compressed_len += 3 + s->static_len;
+#endif
+ } else {
+ send_bits(s, (DYN_TREES<<1)+eof, 3);
+ send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1,
+ max_blindex+1);
+ compress_block(s, (ct_data *)s->dyn_ltree, (ct_data *)s->dyn_dtree);
+#ifdef DEBUG
+ s->compressed_len += 3 + s->opt_len;
+#endif
+ }
+ Assert (s->compressed_len == s->bits_sent, "bad compressed size");
+ /* The above check is made mod 2^32, for files larger than 512 MB
+ * and uLong implemented on 32 bits.
+ */
+ init_block(s);
+
+ if (eof) {
+ bi_windup(s);
+#ifdef DEBUG
+ s->compressed_len += 7; /* align on byte boundary */
+#endif
+ }
+ Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3,
+ s->compressed_len-7*eof));
+}
+
+/* ===========================================================================
+ * Save the match info and tally the frequency counts. Return true if
+ * the current block must be flushed.
+ */
+int _tr_tally (s, dist, lc)
+ deflate_state *s;
+ unsigned dist; /* distance of matched string */
+ unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */
+{
+ s->d_buf[s->last_lit] = (ush)dist;
+ s->l_buf[s->last_lit++] = (uch)lc;
+ if (dist == 0) {
+ /* lc is the unmatched char */
+ s->dyn_ltree[lc].Freq++;
+ } else {
+ s->matches++;
+ /* Here, lc is the match length - MIN_MATCH */
+ dist--; /* dist = match distance - 1 */
+ Assert((ush)dist < (ush)MAX_DIST(s) &&
+ (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
+ (ush)d_code(dist) < (ush)D_CODES, "_tr_tally: bad match");
+
+ s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++;
+ s->dyn_dtree[d_code(dist)].Freq++;
+ }
+
+#ifdef TRUNCATE_BLOCK
+ /* Try to guess if it is profitable to stop the current block here */
+ if ((s->last_lit & 0x1fff) == 0 && s->level > 2) {
+ /* Compute an upper bound for the compressed length */
+ ulg out_length = (ulg)s->last_lit*8L;
+ ulg in_length = (ulg)((long)s->strstart - s->block_start);
+ int dcode;
+ for (dcode = 0; dcode < D_CODES; dcode++) {
+ out_length += (ulg)s->dyn_dtree[dcode].Freq *
+ (5L+extra_dbits[dcode]);
+ }
+ out_length >>= 3;
+ Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ",
+ s->last_lit, in_length, out_length,
+ 100L - out_length*100L/in_length));
+ if (s->matches < s->last_lit/2 && out_length < in_length/2) return 1;
+ }
+#endif
+ return (s->last_lit == s->lit_bufsize-1);
+ /* We avoid equality with lit_bufsize because of wraparound at 64K
+ * on 16 bit machines and because stored blocks are restricted to
+ * 64K-1 bytes.
+ */
+}
+
+/* ===========================================================================
+ * Send the block data compressed using the given Huffman trees
+ */
+local void compress_block(s, ltree, dtree)
+ deflate_state *s;
+ ct_data *ltree; /* literal tree */
+ ct_data *dtree; /* distance tree */
+{
+ unsigned dist; /* distance of matched string */
+ int lc; /* match length or unmatched char (if dist == 0) */
+ unsigned lx = 0; /* running index in l_buf */
+ unsigned code; /* the code to send */
+ int extra; /* number of extra bits to send */
+
+ if (s->last_lit != 0) do {
+ dist = s->d_buf[lx];
+ lc = s->l_buf[lx++];
+ if (dist == 0) {
+ send_code(s, lc, ltree); /* send a literal byte */
+ Tracecv(isgraph(lc), (stderr," '%c' ", lc));
+ } else {
+ /* Here, lc is the match length - MIN_MATCH */
+ code = _length_code[lc];
+ send_code(s, code+LITERALS+1, ltree); /* send the length code */
+ extra = extra_lbits[code];
+ if (extra != 0) {
+ lc -= base_length[code];
+ send_bits(s, lc, extra); /* send the extra length bits */
+ }
+ dist--; /* dist is now the match distance - 1 */
+ code = d_code(dist);
+ Assert (code < D_CODES, "bad d_code");
+
+ send_code(s, code, dtree); /* send the distance code */
+ extra = extra_dbits[code];
+ if (extra != 0) {
+ dist -= base_dist[code];
+ send_bits(s, dist, extra); /* send the extra distance bits */
+ }
+ } /* literal or match pair ? */
+
+ /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */
+ Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,
+ "pendingBuf overflow");
+
+ } while (lx < s->last_lit);
+
+ send_code(s, END_BLOCK, ltree);
+ s->last_eob_len = ltree[END_BLOCK].Len;
+}
+
+/* ===========================================================================
+ * Set the data type to BINARY or TEXT, using a crude approximation:
+ * set it to Z_TEXT if all symbols are either printable characters (33 to 255)
+ * or white spaces (9 to 13, or 32); or set it to Z_BINARY otherwise.
+ * IN assertion: the fields Freq of dyn_ltree are set.
+ */
+local void set_data_type(s)
+ deflate_state *s;
+{
+ int n;
+
+ for (n = 0; n < 9; n++)
+ if (s->dyn_ltree[n].Freq != 0)
+ break;
+ if (n == 9)
+ for (n = 14; n < 32; n++)
+ if (s->dyn_ltree[n].Freq != 0)
+ break;
+ s->strm->data_type = (n == 32) ? Z_TEXT : Z_BINARY;
+}
+
+/* ===========================================================================
+ * Reverse the first len bits of a code, using straightforward code (a faster
+ * method would use a table)
+ * IN assertion: 1 <= len <= 15
+ */
+local unsigned bi_reverse(code, len)
+ unsigned code; /* the value to invert */
+ int len; /* its bit length */
+{
+ register unsigned res = 0;
+ do {
+ res |= code & 1;
+ code >>= 1, res <<= 1;
+ } while (--len > 0);
+ return res >> 1;
+}
+
+/* ===========================================================================
+ * Flush the bit buffer, keeping at most 7 bits in it.
+ */
+local void bi_flush(s)
+ deflate_state *s;
+{
+ if (s->bi_valid == 16) {
+ put_short(s, s->bi_buf);
+ s->bi_buf = 0;
+ s->bi_valid = 0;
+ } else if (s->bi_valid >= 8) {
+ put_byte(s, (Byte)s->bi_buf);
+ s->bi_buf >>= 8;
+ s->bi_valid -= 8;
+ }
+}
+
+/* ===========================================================================
+ * Flush the bit buffer and align the output on a byte boundary
+ */
+local void bi_windup(s)
+ deflate_state *s;
+{
+ if (s->bi_valid > 8) {
+ put_short(s, s->bi_buf);
+ } else if (s->bi_valid > 0) {
+ put_byte(s, (Byte)s->bi_buf);
+ }
+ s->bi_buf = 0;
+ s->bi_valid = 0;
+#ifdef DEBUG
+ s->bits_sent = (s->bits_sent+7) & ~7;
+#endif
+}
+
+/* ===========================================================================
+ * Copy a stored block, storing first the length and its
+ * one's complement if requested.
+ */
+local void copy_block(s, buf, len, header)
+ deflate_state *s;
+ charf *buf; /* the input data */
+ unsigned len; /* its length */
+ int header; /* true if block header must be written */
+{
+ bi_windup(s); /* align on byte boundary */
+ s->last_eob_len = 8; /* enough lookahead for inflate */
+
+ if (header) {
+ put_short(s, (ush)len);
+ put_short(s, (ush)~len);
+#ifdef DEBUG
+ s->bits_sent += 2*16;
+#endif
+ }
+#ifdef DEBUG
+ s->bits_sent += (ulg)len<<3;
+#endif
+ while (len--) {
+ put_byte(s, *buf++);
+ }
+}
--- /dev/null
+/* header created automatically with -DGEN_TREES_H */
+
+local const ct_data static_ltree[L_CODES+2] = {
+{{ 12},{ 8}}, {{140},{ 8}}, {{ 76},{ 8}}, {{204},{ 8}}, {{ 44},{ 8}},
+{{172},{ 8}}, {{108},{ 8}}, {{236},{ 8}}, {{ 28},{ 8}}, {{156},{ 8}},
+{{ 92},{ 8}}, {{220},{ 8}}, {{ 60},{ 8}}, {{188},{ 8}}, {{124},{ 8}},
+{{252},{ 8}}, {{ 2},{ 8}}, {{130},{ 8}}, {{ 66},{ 8}}, {{194},{ 8}},
+{{ 34},{ 8}}, {{162},{ 8}}, {{ 98},{ 8}}, {{226},{ 8}}, {{ 18},{ 8}},
+{{146},{ 8}}, {{ 82},{ 8}}, {{210},{ 8}}, {{ 50},{ 8}}, {{178},{ 8}},
+{{114},{ 8}}, {{242},{ 8}}, {{ 10},{ 8}}, {{138},{ 8}}, {{ 74},{ 8}},
+{{202},{ 8}}, {{ 42},{ 8}}, {{170},{ 8}}, {{106},{ 8}}, {{234},{ 8}},
+{{ 26},{ 8}}, {{154},{ 8}}, {{ 90},{ 8}}, {{218},{ 8}}, {{ 58},{ 8}},
+{{186},{ 8}}, {{122},{ 8}}, {{250},{ 8}}, {{ 6},{ 8}}, {{134},{ 8}},
+{{ 70},{ 8}}, {{198},{ 8}}, {{ 38},{ 8}}, {{166},{ 8}}, {{102},{ 8}},
+{{230},{ 8}}, {{ 22},{ 8}}, {{150},{ 8}}, {{ 86},{ 8}}, {{214},{ 8}},
+{{ 54},{ 8}}, {{182},{ 8}}, {{118},{ 8}}, {{246},{ 8}}, {{ 14},{ 8}},
+{{142},{ 8}}, {{ 78},{ 8}}, {{206},{ 8}}, {{ 46},{ 8}}, {{174},{ 8}},
+{{110},{ 8}}, {{238},{ 8}}, {{ 30},{ 8}}, {{158},{ 8}}, {{ 94},{ 8}},
+{{222},{ 8}}, {{ 62},{ 8}}, {{190},{ 8}}, {{126},{ 8}}, {{254},{ 8}},
+{{ 1},{ 8}}, {{129},{ 8}}, {{ 65},{ 8}}, {{193},{ 8}}, {{ 33},{ 8}},
+{{161},{ 8}}, {{ 97},{ 8}}, {{225},{ 8}}, {{ 17},{ 8}}, {{145},{ 8}},
+{{ 81},{ 8}}, {{209},{ 8}}, {{ 49},{ 8}}, {{177},{ 8}}, {{113},{ 8}},
+{{241},{ 8}}, {{ 9},{ 8}}, {{137},{ 8}}, {{ 73},{ 8}}, {{201},{ 8}},
+{{ 41},{ 8}}, {{169},{ 8}}, {{105},{ 8}}, {{233},{ 8}}, {{ 25},{ 8}},
+{{153},{ 8}}, {{ 89},{ 8}}, {{217},{ 8}}, {{ 57},{ 8}}, {{185},{ 8}},
+{{121},{ 8}}, {{249},{ 8}}, {{ 5},{ 8}}, {{133},{ 8}}, {{ 69},{ 8}},
+{{197},{ 8}}, {{ 37},{ 8}}, {{165},{ 8}}, {{101},{ 8}}, {{229},{ 8}},
+{{ 21},{ 8}}, {{149},{ 8}}, {{ 85},{ 8}}, {{213},{ 8}}, {{ 53},{ 8}},
+{{181},{ 8}}, {{117},{ 8}}, {{245},{ 8}}, {{ 13},{ 8}}, {{141},{ 8}},
+{{ 77},{ 8}}, {{205},{ 8}}, {{ 45},{ 8}}, {{173},{ 8}}, {{109},{ 8}},
+{{237},{ 8}}, {{ 29},{ 8}}, {{157},{ 8}}, {{ 93},{ 8}}, {{221},{ 8}},
+{{ 61},{ 8}}, {{189},{ 8}}, {{125},{ 8}}, {{253},{ 8}}, {{ 19},{ 9}},
+{{275},{ 9}}, {{147},{ 9}}, {{403},{ 9}}, {{ 83},{ 9}}, {{339},{ 9}},
+{{211},{ 9}}, {{467},{ 9}}, {{ 51},{ 9}}, {{307},{ 9}}, {{179},{ 9}},
+{{435},{ 9}}, {{115},{ 9}}, {{371},{ 9}}, {{243},{ 9}}, {{499},{ 9}},
+{{ 11},{ 9}}, {{267},{ 9}}, {{139},{ 9}}, {{395},{ 9}}, {{ 75},{ 9}},
+{{331},{ 9}}, {{203},{ 9}}, {{459},{ 9}}, {{ 43},{ 9}}, {{299},{ 9}},
+{{171},{ 9}}, {{427},{ 9}}, {{107},{ 9}}, {{363},{ 9}}, {{235},{ 9}},
+{{491},{ 9}}, {{ 27},{ 9}}, {{283},{ 9}}, {{155},{ 9}}, {{411},{ 9}},
+{{ 91},{ 9}}, {{347},{ 9}}, {{219},{ 9}}, {{475},{ 9}}, {{ 59},{ 9}},
+{{315},{ 9}}, {{187},{ 9}}, {{443},{ 9}}, {{123},{ 9}}, {{379},{ 9}},
+{{251},{ 9}}, {{507},{ 9}}, {{ 7},{ 9}}, {{263},{ 9}}, {{135},{ 9}},
+{{391},{ 9}}, {{ 71},{ 9}}, {{327},{ 9}}, {{199},{ 9}}, {{455},{ 9}},
+{{ 39},{ 9}}, {{295},{ 9}}, {{167},{ 9}}, {{423},{ 9}}, {{103},{ 9}},
+{{359},{ 9}}, {{231},{ 9}}, {{487},{ 9}}, {{ 23},{ 9}}, {{279},{ 9}},
+{{151},{ 9}}, {{407},{ 9}}, {{ 87},{ 9}}, {{343},{ 9}}, {{215},{ 9}},
+{{471},{ 9}}, {{ 55},{ 9}}, {{311},{ 9}}, {{183},{ 9}}, {{439},{ 9}},
+{{119},{ 9}}, {{375},{ 9}}, {{247},{ 9}}, {{503},{ 9}}, {{ 15},{ 9}},
+{{271},{ 9}}, {{143},{ 9}}, {{399},{ 9}}, {{ 79},{ 9}}, {{335},{ 9}},
+{{207},{ 9}}, {{463},{ 9}}, {{ 47},{ 9}}, {{303},{ 9}}, {{175},{ 9}},
+{{431},{ 9}}, {{111},{ 9}}, {{367},{ 9}}, {{239},{ 9}}, {{495},{ 9}},
+{{ 31},{ 9}}, {{287},{ 9}}, {{159},{ 9}}, {{415},{ 9}}, {{ 95},{ 9}},
+{{351},{ 9}}, {{223},{ 9}}, {{479},{ 9}}, {{ 63},{ 9}}, {{319},{ 9}},
+{{191},{ 9}}, {{447},{ 9}}, {{127},{ 9}}, {{383},{ 9}}, {{255},{ 9}},
+{{511},{ 9}}, {{ 0},{ 7}}, {{ 64},{ 7}}, {{ 32},{ 7}}, {{ 96},{ 7}},
+{{ 16},{ 7}}, {{ 80},{ 7}}, {{ 48},{ 7}}, {{112},{ 7}}, {{ 8},{ 7}},
+{{ 72},{ 7}}, {{ 40},{ 7}}, {{104},{ 7}}, {{ 24},{ 7}}, {{ 88},{ 7}},
+{{ 56},{ 7}}, {{120},{ 7}}, {{ 4},{ 7}}, {{ 68},{ 7}}, {{ 36},{ 7}},
+{{100},{ 7}}, {{ 20},{ 7}}, {{ 84},{ 7}}, {{ 52},{ 7}}, {{116},{ 7}},
+{{ 3},{ 8}}, {{131},{ 8}}, {{ 67},{ 8}}, {{195},{ 8}}, {{ 35},{ 8}},
+{{163},{ 8}}, {{ 99},{ 8}}, {{227},{ 8}}
+};
+
+local const ct_data static_dtree[D_CODES] = {
+{{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}},
+{{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}},
+{{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}},
+{{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}},
+{{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}},
+{{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}}
+};
+
+const uch _dist_code[DIST_CODE_LEN] = {
+ 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8,
+ 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10,
+10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13,
+13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15,
+15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 16, 17,
+18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22,
+23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27,
+27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29
+};
+
+const uch _length_code[MAX_MATCH-MIN_MATCH+1]= {
+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12,
+13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16,
+17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19,
+19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22,
+22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23,
+23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26,
+26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28
+};
+
+local const int base_length[LENGTH_CODES] = {
+0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56,
+64, 80, 96, 112, 128, 160, 192, 224, 0
+};
+
+local const int base_dist[D_CODES] = {
+ 0, 1, 2, 3, 4, 6, 8, 12, 16, 24,
+ 32, 48, 64, 96, 128, 192, 256, 384, 512, 768,
+ 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576
+};
+
--- /dev/null
+/* uncompr.c -- decompress a memory buffer
+ * Copyright (C) 1995-2003 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#define ZLIB_INTERNAL
+#include "zlib.h"
+
+/* ===========================================================================
+ Decompresses the source buffer into the destination buffer. sourceLen is
+ the byte length of the source buffer. Upon entry, destLen is the total
+ size of the destination buffer, which must be large enough to hold the
+ entire uncompressed data. (The size of the uncompressed data must have
+ been saved previously by the compressor and transmitted to the decompressor
+ by some mechanism outside the scope of this compression library.)
+ Upon exit, destLen is the actual size of the compressed buffer.
+ This function can be used to decompress a whole file at once if the
+ input file is mmap'ed.
+
+ uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
+ enough memory, Z_BUF_ERROR if there was not enough room in the output
+ buffer, or Z_DATA_ERROR if the input data was corrupted.
+*/
+int ZEXPORT uncompress (dest, destLen, source, sourceLen)
+ Bytef *dest;
+ uLongf *destLen;
+ const Bytef *source;
+ uLong sourceLen;
+{
+ z_stream stream;
+ int err;
+
+ stream.next_in = (Bytef*)source;
+ stream.avail_in = (uInt)sourceLen;
+ /* Check for source > 64K on 16-bit machine: */
+ if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;
+
+ stream.next_out = dest;
+ stream.avail_out = (uInt)*destLen;
+ if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;
+
+ stream.zalloc = (alloc_func)0;
+ stream.zfree = (free_func)0;
+
+ err = inflateInit(&stream);
+ if (err != Z_OK) return err;
+
+ err = inflate(&stream, Z_FINISH);
+ if (err != Z_STREAM_END) {
+ inflateEnd(&stream);
+ if (err == Z_NEED_DICT || (err == Z_BUF_ERROR && stream.avail_in == 0))
+ return Z_DATA_ERROR;
+ return err;
+ }
+ *destLen = stream.total_out;
+
+ err = inflateEnd(&stream);
+ return err;
+}
--- /dev/null
+/* zconf.h -- configuration of the zlib compression library
+ * Copyright (C) 1995-2005 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#ifndef ZCONF_H
+#define ZCONF_H
+
+/*
+ * If you *really* need a unique prefix for all types and library functions,
+ * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
+ */
+#ifdef Z_PREFIX
+# define deflateInit_ z_deflateInit_
+# define deflate z_deflate
+# define deflateEnd z_deflateEnd
+# define inflateInit_ z_inflateInit_
+# define inflate z_inflate
+# define inflateEnd z_inflateEnd
+# define deflateInit2_ z_deflateInit2_
+# define deflateSetDictionary z_deflateSetDictionary
+# define deflateCopy z_deflateCopy
+# define deflateReset z_deflateReset
+# define deflateParams z_deflateParams
+# define deflateBound z_deflateBound
+# define deflatePrime z_deflatePrime
+# define inflateInit2_ z_inflateInit2_
+# define inflateSetDictionary z_inflateSetDictionary
+# define inflateSync z_inflateSync
+# define inflateSyncPoint z_inflateSyncPoint
+# define inflateCopy z_inflateCopy
+# define inflateReset z_inflateReset
+# define inflateBack z_inflateBack
+# define inflateBackEnd z_inflateBackEnd
+# define compress z_compress
+# define compress2 z_compress2
+# define compressBound z_compressBound
+# define uncompress z_uncompress
+# define adler32 z_adler32
+# define crc32 z_crc32
+# define get_crc_table z_get_crc_table
+# define zError z_zError
+
+# define alloc_func z_alloc_func
+# define free_func z_free_func
+# define in_func z_in_func
+# define out_func z_out_func
+# define Byte z_Byte
+# define uInt z_uInt
+# define uLong z_uLong
+# define Bytef z_Bytef
+# define charf z_charf
+# define intf z_intf
+# define uIntf z_uIntf
+# define uLongf z_uLongf
+# define voidpf z_voidpf
+# define voidp z_voidp
+#endif
+
+#if defined(__MSDOS__) && !defined(MSDOS)
+# define MSDOS
+#endif
+#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
+# define OS2
+#endif
+#if defined(_WINDOWS) && !defined(WINDOWS)
+# define WINDOWS
+#endif
+#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
+# ifndef WIN32
+# define WIN32
+# endif
+#endif
+#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
+# if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
+# ifndef SYS16BIT
+# define SYS16BIT
+# endif
+# endif
+#endif
+
+/*
+ * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
+ * than 64k bytes at a time (needed on systems with 16-bit int).
+ */
+#ifdef SYS16BIT
+# define MAXSEG_64K
+#endif
+#ifdef MSDOS
+# define UNALIGNED_OK
+#endif
+
+#ifdef __STDC_VERSION__
+# ifndef STDC
+# define STDC
+# endif
+# if __STDC_VERSION__ >= 199901L
+# ifndef STDC99
+# define STDC99
+# endif
+# endif
+#endif
+#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
+# define STDC
+#endif
+#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
+# define STDC
+#endif
+#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
+# define STDC
+#endif
+#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
+# define STDC
+#endif
+
+#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */
+# define STDC
+#endif
+
+#ifndef STDC
+# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
+# define const /* note: need a more gentle solution here */
+# endif
+#endif
+
+/* Some Mac compilers merge all .h files incorrectly: */
+#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__)
+# define NO_DUMMY_DECL
+#endif
+
+/* Maximum value for memLevel in deflateInit2 */
+#ifndef MAX_MEM_LEVEL
+# ifdef MAXSEG_64K
+# define MAX_MEM_LEVEL 8
+# else
+# define MAX_MEM_LEVEL 9
+# endif
+#endif
+
+/* Maximum value for windowBits in deflateInit2 and inflateInit2.
+ * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
+ * created by gzip. (Files created by minigzip can still be extracted by
+ * gzip.)
+ */
+#ifndef MAX_WBITS
+# define MAX_WBITS 15 /* 32K LZ77 window */
+#endif
+
+/* The memory requirements for deflate are (in bytes):
+ (1 << (windowBits+2)) + (1 << (memLevel+9))
+ that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values)
+ plus a few kilobytes for small objects. For example, if you want to reduce
+ the default memory requirements from 256K to 128K, compile with
+ make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
+ Of course this will generally degrade compression (there's no free lunch).
+
+ The memory requirements for inflate are (in bytes) 1 << windowBits
+ that is, 32K for windowBits=15 (default value) plus a few kilobytes
+ for small objects.
+*/
+
+ /* Type declarations */
+
+#ifndef OF /* function prototypes */
+# ifdef STDC
+# define OF(args) args
+# else
+# define OF(args) ()
+# endif
+#endif
+
+/* The following definitions for FAR are needed only for MSDOS mixed
+ * model programming (small or medium model with some far allocations).
+ * This was tested only with MSC; for other MSDOS compilers you may have
+ * to define NO_MEMCPY in zutil.h. If you don't need the mixed model,
+ * just define FAR to be empty.
+ */
+#ifdef SYS16BIT
+# if defined(M_I86SM) || defined(M_I86MM)
+ /* MSC small or medium model */
+# define SMALL_MEDIUM
+# ifdef _MSC_VER
+# define FAR _far
+# else
+# define FAR far
+# endif
+# endif
+# if (defined(__SMALL__) || defined(__MEDIUM__))
+ /* Turbo C small or medium model */
+# define SMALL_MEDIUM
+# ifdef __BORLANDC__
+# define FAR _far
+# else
+# define FAR far
+# endif
+# endif
+#endif
+
+#if defined(WINDOWS) || defined(WIN32)
+ /* If building or using zlib as a DLL, define ZLIB_DLL.
+ * This is not mandatory, but it offers a little performance increase.
+ */
+# ifdef ZLIB_DLL
+# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
+# ifdef ZLIB_INTERNAL
+# define ZEXTERN extern __declspec(dllexport)
+# else
+# define ZEXTERN extern __declspec(dllimport)
+# endif
+# endif
+# endif /* ZLIB_DLL */
+ /* If building or using zlib with the WINAPI/WINAPIV calling convention,
+ * define ZLIB_WINAPI.
+ * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
+ */
+# ifdef ZLIB_WINAPI
+# ifdef FAR
+# undef FAR
+# endif
+# include <windows.h>
+ /* No need for _export, use ZLIB.DEF instead. */
+ /* For complete Windows compatibility, use WINAPI, not __stdcall. */
+# define ZEXPORT WINAPI
+# ifdef WIN32
+# define ZEXPORTVA WINAPIV
+# else
+# define ZEXPORTVA FAR CDECL
+# endif
+# endif
+#endif
+
+#if defined (__BEOS__)
+# ifdef ZLIB_DLL
+# ifdef ZLIB_INTERNAL
+# define ZEXPORT __declspec(dllexport)
+# define ZEXPORTVA __declspec(dllexport)
+# else
+# define ZEXPORT __declspec(dllimport)
+# define ZEXPORTVA __declspec(dllimport)
+# endif
+# endif
+#endif
+
+#ifndef ZEXTERN
+# define ZEXTERN extern
+#endif
+#ifndef ZEXPORT
+# define ZEXPORT
+#endif
+#ifndef ZEXPORTVA
+# define ZEXPORTVA
+#endif
+
+#ifndef FAR
+# define FAR
+#endif
+
+#if !defined(__MACTYPES__)
+typedef unsigned char Byte; /* 8 bits */
+#endif
+typedef unsigned int uInt; /* 16 bits or more */
+typedef unsigned long uLong; /* 32 bits or more */
+
+#ifdef SMALL_MEDIUM
+ /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
+# define Bytef Byte FAR
+#else
+ typedef Byte FAR Bytef;
+#endif
+typedef char FAR charf;
+typedef int FAR intf;
+typedef uInt FAR uIntf;
+typedef uLong FAR uLongf;
+
+#ifdef STDC
+ typedef void const *voidpc;
+ typedef void FAR *voidpf;
+ typedef void *voidp;
+#else
+ typedef Byte const *voidpc;
+ typedef Byte FAR *voidpf;
+ typedef Byte *voidp;
+#endif
+
+#if 0 /* HAVE_UNISTD_H -- this line is updated by ./configure */
+# include <sys/types.h> /* for off_t */
+# include <unistd.h> /* for SEEK_* and off_t */
+# ifdef VMS
+# include <unixio.h> /* for off_t */
+# endif
+# define z_off_t off_t
+#endif
+#ifndef SEEK_SET
+# define SEEK_SET 0 /* Seek from beginning of file. */
+# define SEEK_CUR 1 /* Seek from current position. */
+# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */
+#endif
+#ifndef z_off_t
+# define z_off_t long
+#endif
+
+#if defined(__OS400__)
+# define NO_vsnprintf
+#endif
+
+#if defined(__MVS__)
+# define NO_vsnprintf
+# ifdef FAR
+# undef FAR
+# endif
+#endif
+
+/* MVS linker does not support external names larger than 8 bytes */
+#if defined(__MVS__)
+# pragma map(deflateInit_,"DEIN")
+# pragma map(deflateInit2_,"DEIN2")
+# pragma map(deflateEnd,"DEEND")
+# pragma map(deflateBound,"DEBND")
+# pragma map(inflateInit_,"ININ")
+# pragma map(inflateInit2_,"ININ2")
+# pragma map(inflateEnd,"INEND")
+# pragma map(inflateSync,"INSY")
+# pragma map(inflateSetDictionary,"INSEDI")
+# pragma map(compressBound,"CMBND")
+# pragma map(inflate_table,"INTABL")
+# pragma map(inflate_fast,"INFA")
+# pragma map(inflate_copyright,"INCOPY")
+#endif
+
+#endif /* ZCONF_H */
--- /dev/null
+/* zlib.h -- interface of the 'zlib' general purpose compression library
+ version 1.2.3, July 18th, 2005
+
+ Copyright (C) 1995-2005 Jean-loup Gailly and Mark Adler
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any damages
+ arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+
+ Jean-loup Gailly Mark Adler
+ jloup@gzip.org madler@alumni.caltech.edu
+
+
+ The data format used by the zlib library is described by RFCs (Request for
+ Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt
+ (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
+*/
+
+#ifndef ZLIB_H
+#define ZLIB_H
+
+#include "zconf.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ZLIB_VERSION "1.2.3"
+#define ZLIB_VERNUM 0x1230
+
+/*
+ The 'zlib' compression library provides in-memory compression and
+ decompression functions, including integrity checks of the uncompressed
+ data. This version of the library supports only one compression method
+ (deflation) but other algorithms will be added later and will have the same
+ stream interface.
+
+ Compression can be done in a single step if the buffers are large
+ enough (for example if an input file is mmap'ed), or can be done by
+ repeated calls of the compression function. In the latter case, the
+ application must provide more input and/or consume the output
+ (providing more output space) before each call.
+
+ The compressed data format used by default by the in-memory functions is
+ the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped
+ around a deflate stream, which is itself documented in RFC 1951.
+
+ The library also supports reading and writing files in gzip (.gz) format
+ with an interface similar to that of stdio using the functions that start
+ with "gz". The gzip format is different from the zlib format. gzip is a
+ gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.
+
+ This library can optionally read and write gzip streams in memory as well.
+
+ The zlib format was designed to be compact and fast for use in memory
+ and on communications channels. The gzip format was designed for single-
+ file compression on file systems, has a larger header than zlib to maintain
+ directory information, and uses a different, slower check method than zlib.
+
+ The library does not install any signal handler. The decoder checks
+ the consistency of the compressed data, so the library should never
+ crash even in case of corrupted input.
+*/
+
+typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
+typedef void (*free_func) OF((voidpf opaque, voidpf address));
+
+struct internal_state;
+
+typedef struct z_stream_s {
+ Bytef *next_in; /* next input byte */
+ uInt avail_in; /* number of bytes available at next_in */
+ uLong total_in; /* total nb of input bytes read so far */
+
+ Bytef *next_out; /* next output byte should be put there */
+ uInt avail_out; /* remaining free space at next_out */
+ uLong total_out; /* total nb of bytes output so far */
+
+ char *msg; /* last error message, NULL if no error */
+ struct internal_state FAR *state; /* not visible by applications */
+
+ alloc_func zalloc; /* used to allocate the internal state */
+ free_func zfree; /* used to free the internal state */
+ voidpf opaque; /* private data object passed to zalloc and zfree */
+
+ int data_type; /* best guess about the data type: binary or text */
+ uLong adler; /* adler32 value of the uncompressed data */
+ uLong reserved; /* reserved for future use */
+} z_stream;
+
+typedef z_stream FAR *z_streamp;
+
+/*
+ gzip header information passed to and from zlib routines. See RFC 1952
+ for more details on the meanings of these fields.
+*/
+typedef struct gz_header_s {
+ int text; /* true if compressed data believed to be text */
+ uLong time; /* modification time */
+ int xflags; /* extra flags (not used when writing a gzip file) */
+ int os; /* operating system */
+ Bytef *extra; /* pointer to extra field or Z_NULL if none */
+ uInt extra_len; /* extra field length (valid if extra != Z_NULL) */
+ uInt extra_max; /* space at extra (only when reading header) */
+ Bytef *name; /* pointer to zero-terminated file name or Z_NULL */
+ uInt name_max; /* space at name (only when reading header) */
+ Bytef *comment; /* pointer to zero-terminated comment or Z_NULL */
+ uInt comm_max; /* space at comment (only when reading header) */
+ int hcrc; /* true if there was or will be a header crc */
+ int done; /* true when done reading gzip header (not used
+ when writing a gzip file) */
+} gz_header;
+
+typedef gz_header FAR *gz_headerp;
+
+/*
+ The application must update next_in and avail_in when avail_in has
+ dropped to zero. It must update next_out and avail_out when avail_out
+ has dropped to zero. The application must initialize zalloc, zfree and
+ opaque before calling the init function. All other fields are set by the
+ compression library and must not be updated by the application.
+
+ The opaque value provided by the application will be passed as the first
+ parameter for calls of zalloc and zfree. This can be useful for custom
+ memory management. The compression library attaches no meaning to the
+ opaque value.
+
+ zalloc must return Z_NULL if there is not enough memory for the object.
+ If zlib is used in a multi-threaded application, zalloc and zfree must be
+ thread safe.
+
+ On 16-bit systems, the functions zalloc and zfree must be able to allocate
+ exactly 65536 bytes, but will not be required to allocate more than this
+ if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS,
+ pointers returned by zalloc for objects of exactly 65536 bytes *must*
+ have their offset normalized to zero. The default allocation function
+ provided by this library ensures this (see zutil.c). To reduce memory
+ requirements and avoid any allocation of 64K objects, at the expense of
+ compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h).
+
+ The fields total_in and total_out can be used for statistics or
+ progress reports. After compression, total_in holds the total size of
+ the uncompressed data and may be saved for use in the decompressor
+ (particularly if the decompressor wants to decompress everything in
+ a single step).
+*/
+
+ /* constants */
+
+#define Z_NO_FLUSH 0
+#define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */
+#define Z_SYNC_FLUSH 2
+#define Z_FULL_FLUSH 3
+#define Z_FINISH 4
+#define Z_BLOCK 5
+/* Allowed flush values; see deflate() and inflate() below for details */
+
+#define Z_OK 0
+#define Z_STREAM_END 1
+#define Z_NEED_DICT 2
+#define Z_ERRNO (-1)
+#define Z_STREAM_ERROR (-2)
+#define Z_DATA_ERROR (-3)
+#define Z_MEM_ERROR (-4)
+#define Z_BUF_ERROR (-5)
+#define Z_VERSION_ERROR (-6)
+/* Return codes for the compression/decompression functions. Negative
+ * values are errors, positive values are used for special but normal events.
+ */
+
+#define Z_NO_COMPRESSION 0
+#define Z_BEST_SPEED 1
+#define Z_BEST_COMPRESSION 9
+#define Z_DEFAULT_COMPRESSION (-1)
+/* compression levels */
+
+#define Z_FILTERED 1
+#define Z_HUFFMAN_ONLY 2
+#define Z_RLE 3
+#define Z_FIXED 4
+#define Z_DEFAULT_STRATEGY 0
+/* compression strategy; see deflateInit2() below for details */
+
+#define Z_BINARY 0
+#define Z_TEXT 1
+#define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */
+#define Z_UNKNOWN 2
+/* Possible values of the data_type field (though see inflate()) */
+
+#define Z_DEFLATED 8
+/* The deflate compression method (the only one supported in this version) */
+
+#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */
+
+#define zlib_version zlibVersion()
+/* for compatibility with versions < 1.0.2 */
+
+ /* basic functions */
+
+ZEXTERN const char * ZEXPORT zlibVersion OF((void));
+/* The application can compare zlibVersion and ZLIB_VERSION for consistency.
+ If the first character differs, the library code actually used is
+ not compatible with the zlib.h header file used by the application.
+ This check is automatically made by deflateInit and inflateInit.
+ */
+
+/*
+ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level));
+
+ Initializes the internal stream state for compression. The fields
+ zalloc, zfree and opaque must be initialized before by the caller.
+ If zalloc and zfree are set to Z_NULL, deflateInit updates them to
+ use default allocation functions.
+
+ The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
+ 1 gives best speed, 9 gives best compression, 0 gives no compression at
+ all (the input data is simply copied a block at a time).
+ Z_DEFAULT_COMPRESSION requests a default compromise between speed and
+ compression (currently equivalent to level 6).
+
+ deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
+ enough memory, Z_STREAM_ERROR if level is not a valid compression level,
+ Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
+ with the version assumed by the caller (ZLIB_VERSION).
+ msg is set to null if there is no error message. deflateInit does not
+ perform any compression: this will be done by deflate().
+*/
+
+
+ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
+/*
+ deflate compresses as much data as possible, and stops when the input
+ buffer becomes empty or the output buffer becomes full. It may introduce some
+ output latency (reading input without producing any output) except when
+ forced to flush.
+
+ The detailed semantics are as follows. deflate performs one or both of the
+ following actions:
+
+ - Compress more input starting at next_in and update next_in and avail_in
+ accordingly. If not all input can be processed (because there is not
+ enough room in the output buffer), next_in and avail_in are updated and
+ processing will resume at this point for the next call of deflate().
+
+ - Provide more output starting at next_out and update next_out and avail_out
+ accordingly. This action is forced if the parameter flush is non zero.
+ Forcing flush frequently degrades the compression ratio, so this parameter
+ should be set only when necessary (in interactive applications).
+ Some output may be provided even if flush is not set.
+
+ Before the call of deflate(), the application should ensure that at least
+ one of the actions is possible, by providing more input and/or consuming
+ more output, and updating avail_in or avail_out accordingly; avail_out
+ should never be zero before the call. The application can consume the
+ compressed output when it wants, for example when the output buffer is full
+ (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK
+ and with zero avail_out, it must be called again after making room in the
+ output buffer because there might be more output pending.
+
+ Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to
+ decide how much data to accumualte before producing output, in order to
+ maximize compression.
+
+ If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
+ flushed to the output buffer and the output is aligned on a byte boundary, so
+ that the decompressor can get all input data available so far. (In particular
+ avail_in is zero after the call if enough output space has been provided
+ before the call.) Flushing may degrade compression for some compression
+ algorithms and so it should be used only when necessary.
+
+ If flush is set to Z_FULL_FLUSH, all output is flushed as with
+ Z_SYNC_FLUSH, and the compression state is reset so that decompression can
+ restart from this point if previous compressed data has been damaged or if
+ random access is desired. Using Z_FULL_FLUSH too often can seriously degrade
+ compression.
+
+ If deflate returns with avail_out == 0, this function must be called again
+ with the same value of the flush parameter and more output space (updated
+ avail_out), until the flush is complete (deflate returns with non-zero
+ avail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that
+ avail_out is greater than six to avoid repeated flush markers due to
+ avail_out == 0 on return.
+
+ If the parameter flush is set to Z_FINISH, pending input is processed,
+ pending output is flushed and deflate returns with Z_STREAM_END if there
+ was enough output space; if deflate returns with Z_OK, this function must be
+ called again with Z_FINISH and more output space (updated avail_out) but no
+ more input data, until it returns with Z_STREAM_END or an error. After
+ deflate has returned Z_STREAM_END, the only possible operations on the
+ stream are deflateReset or deflateEnd.
+
+ Z_FINISH can be used immediately after deflateInit if all the compression
+ is to be done in a single step. In this case, avail_out must be at least
+ the value returned by deflateBound (see below). If deflate does not return
+ Z_STREAM_END, then it must be called again as described above.
+
+ deflate() sets strm->adler to the adler32 checksum of all input read
+ so far (that is, total_in bytes).
+
+ deflate() may update strm->data_type if it can make a good guess about
+ the input data type (Z_BINARY or Z_TEXT). In doubt, the data is considered
+ binary. This field is only for information purposes and does not affect
+ the compression algorithm in any manner.
+
+ deflate() returns Z_OK if some progress has been made (more input
+ processed or more output produced), Z_STREAM_END if all input has been
+ consumed and all output has been produced (only when flush is set to
+ Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
+ if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible
+ (for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not
+ fatal, and deflate() can be called again with more input and more output
+ space to continue compressing.
+*/
+
+
+ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm));
+/*
+ All dynamically allocated data structures for this stream are freed.
+ This function discards any unprocessed input and does not flush any
+ pending output.
+
+ deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
+ stream state was inconsistent, Z_DATA_ERROR if the stream was freed
+ prematurely (some input or output was discarded). In the error case,
+ msg may be set but then points to a static string (which must not be
+ deallocated).
+*/
+
+
+/*
+ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
+
+ Initializes the internal stream state for decompression. The fields
+ next_in, avail_in, zalloc, zfree and opaque must be initialized before by
+ the caller. If next_in is not Z_NULL and avail_in is large enough (the exact
+ value depends on the compression method), inflateInit determines the
+ compression method from the zlib header and allocates all data structures
+ accordingly; otherwise the allocation will be deferred to the first call of
+ inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to
+ use default allocation functions.
+
+ inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
+ memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
+ version assumed by the caller. msg is set to null if there is no error
+ message. inflateInit does not perform any decompression apart from reading
+ the zlib header if present: this will be done by inflate(). (So next_in and
+ avail_in may be modified, but next_out and avail_out are unchanged.)
+*/
+
+
+ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
+/*
+ inflate decompresses as much data as possible, and stops when the input
+ buffer becomes empty or the output buffer becomes full. It may introduce
+ some output latency (reading input without producing any output) except when
+ forced to flush.
+
+ The detailed semantics are as follows. inflate performs one or both of the
+ following actions:
+
+ - Decompress more input starting at next_in and update next_in and avail_in
+ accordingly. If not all input can be processed (because there is not
+ enough room in the output buffer), next_in is updated and processing
+ will resume at this point for the next call of inflate().
+
+ - Provide more output starting at next_out and update next_out and avail_out
+ accordingly. inflate() provides as much output as possible, until there
+ is no more input data or no more space in the output buffer (see below
+ about the flush parameter).
+
+ Before the call of inflate(), the application should ensure that at least
+ one of the actions is possible, by providing more input and/or consuming
+ more output, and updating the next_* and avail_* values accordingly.
+ The application can consume the uncompressed output when it wants, for
+ example when the output buffer is full (avail_out == 0), or after each
+ call of inflate(). If inflate returns Z_OK and with zero avail_out, it
+ must be called again after making room in the output buffer because there
+ might be more output pending.
+
+ The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH,
+ Z_FINISH, or Z_BLOCK. Z_SYNC_FLUSH requests that inflate() flush as much
+ output as possible to the output buffer. Z_BLOCK requests that inflate() stop
+ if and when it gets to the next deflate block boundary. When decoding the
+ zlib or gzip format, this will cause inflate() to return immediately after
+ the header and before the first block. When doing a raw inflate, inflate()
+ will go ahead and process the first block, and will return when it gets to
+ the end of that block, or when it runs out of data.
+
+ The Z_BLOCK option assists in appending to or combining deflate streams.
+ Also to assist in this, on return inflate() will set strm->data_type to the
+ number of unused bits in the last byte taken from strm->next_in, plus 64
+ if inflate() is currently decoding the last block in the deflate stream,
+ plus 128 if inflate() returned immediately after decoding an end-of-block
+ code or decoding the complete header up to just before the first byte of the
+ deflate stream. The end-of-block will not be indicated until all of the
+ uncompressed data from that block has been written to strm->next_out. The
+ number of unused bits may in general be greater than seven, except when
+ bit 7 of data_type is set, in which case the number of unused bits will be
+ less than eight.
+
+ inflate() should normally be called until it returns Z_STREAM_END or an
+ error. However if all decompression is to be performed in a single step
+ (a single call of inflate), the parameter flush should be set to
+ Z_FINISH. In this case all pending input is processed and all pending
+ output is flushed; avail_out must be large enough to hold all the
+ uncompressed data. (The size of the uncompressed data may have been saved
+ by the compressor for this purpose.) The next operation on this stream must
+ be inflateEnd to deallocate the decompression state. The use of Z_FINISH
+ is never required, but can be used to inform inflate that a faster approach
+ may be used for the single inflate() call.
+
+ In this implementation, inflate() always flushes as much output as
+ possible to the output buffer, and always uses the faster approach on the
+ first call. So the only effect of the flush parameter in this implementation
+ is on the return value of inflate(), as noted below, or when it returns early
+ because Z_BLOCK is used.
+
+ If a preset dictionary is needed after this call (see inflateSetDictionary
+ below), inflate sets strm->adler to the adler32 checksum of the dictionary
+ chosen by the compressor and returns Z_NEED_DICT; otherwise it sets
+ strm->adler to the adler32 checksum of all output produced so far (that is,
+ total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described
+ below. At the end of the stream, inflate() checks that its computed adler32
+ checksum is equal to that saved by the compressor and returns Z_STREAM_END
+ only if the checksum is correct.
+
+ inflate() will decompress and check either zlib-wrapped or gzip-wrapped
+ deflate data. The header type is detected automatically. Any information
+ contained in the gzip header is not retained, so applications that need that
+ information should instead use raw inflate, see inflateInit2() below, or
+ inflateBack() and perform their own processing of the gzip header and
+ trailer.
+
+ inflate() returns Z_OK if some progress has been made (more input processed
+ or more output produced), Z_STREAM_END if the end of the compressed data has
+ been reached and all uncompressed output has been produced, Z_NEED_DICT if a
+ preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
+ corrupted (input stream not conforming to the zlib format or incorrect check
+ value), Z_STREAM_ERROR if the stream structure was inconsistent (for example
+ if next_in or next_out was NULL), Z_MEM_ERROR if there was not enough memory,
+ Z_BUF_ERROR if no progress is possible or if there was not enough room in the
+ output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and
+ inflate() can be called again with more input and more output space to
+ continue decompressing. If Z_DATA_ERROR is returned, the application may then
+ call inflateSync() to look for a good compression block if a partial recovery
+ of the data is desired.
+*/
+
+
+ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
+/*
+ All dynamically allocated data structures for this stream are freed.
+ This function discards any unprocessed input and does not flush any
+ pending output.
+
+ inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
+ was inconsistent. In the error case, msg may be set but then points to a
+ static string (which must not be deallocated).
+*/
+
+ /* Advanced functions */
+
+/*
+ The following functions are needed only in some special applications.
+*/
+
+/*
+ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
+ int level,
+ int method,
+ int windowBits,
+ int memLevel,
+ int strategy));
+
+ This is another version of deflateInit with more compression options. The
+ fields next_in, zalloc, zfree and opaque must be initialized before by
+ the caller.
+
+ The method parameter is the compression method. It must be Z_DEFLATED in
+ this version of the library.
+
+ The windowBits parameter is the base two logarithm of the window size
+ (the size of the history buffer). It should be in the range 8..15 for this
+ version of the library. Larger values of this parameter result in better
+ compression at the expense of memory usage. The default value is 15 if
+ deflateInit is used instead.
+
+ windowBits can also be -8..-15 for raw deflate. In this case, -windowBits
+ determines the window size. deflate() will then generate raw deflate data
+ with no zlib header or trailer, and will not compute an adler32 check value.
+
+ windowBits can also be greater than 15 for optional gzip encoding. Add
+ 16 to windowBits to write a simple gzip header and trailer around the
+ compressed data instead of a zlib wrapper. The gzip header will have no
+ file name, no extra data, no comment, no modification time (set to zero),
+ no header crc, and the operating system will be set to 255 (unknown). If a
+ gzip stream is being written, strm->adler is a crc32 instead of an adler32.
+
+ The memLevel parameter specifies how much memory should be allocated
+ for the internal compression state. memLevel=1 uses minimum memory but
+ is slow and reduces compression ratio; memLevel=9 uses maximum memory
+ for optimal speed. The default value is 8. See zconf.h for total memory
+ usage as a function of windowBits and memLevel.
+
+ The strategy parameter is used to tune the compression algorithm. Use the
+ value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
+ filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no
+ string match), or Z_RLE to limit match distances to one (run-length
+ encoding). Filtered data consists mostly of small values with a somewhat
+ random distribution. In this case, the compression algorithm is tuned to
+ compress them better. The effect of Z_FILTERED is to force more Huffman
+ coding and less string matching; it is somewhat intermediate between
+ Z_DEFAULT and Z_HUFFMAN_ONLY. Z_RLE is designed to be almost as fast as
+ Z_HUFFMAN_ONLY, but give better compression for PNG image data. The strategy
+ parameter only affects the compression ratio but not the correctness of the
+ compressed output even if it is not set appropriately. Z_FIXED prevents the
+ use of dynamic Huffman codes, allowing for a simpler decoder for special
+ applications.
+
+ deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+ memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid
+ method). msg is set to null if there is no error message. deflateInit2 does
+ not perform any compression: this will be done by deflate().
+*/
+
+ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
+ const Bytef *dictionary,
+ uInt dictLength));
+/*
+ Initializes the compression dictionary from the given byte sequence
+ without producing any compressed output. This function must be called
+ immediately after deflateInit, deflateInit2 or deflateReset, before any
+ call of deflate. The compressor and decompressor must use exactly the same
+ dictionary (see inflateSetDictionary).
+
+ The dictionary should consist of strings (byte sequences) that are likely
+ to be encountered later in the data to be compressed, with the most commonly
+ used strings preferably put towards the end of the dictionary. Using a
+ dictionary is most useful when the data to be compressed is short and can be
+ predicted with good accuracy; the data can then be compressed better than
+ with the default empty dictionary.
+
+ Depending on the size of the compression data structures selected by
+ deflateInit or deflateInit2, a part of the dictionary may in effect be
+ discarded, for example if the dictionary is larger than the window size in
+ deflate or deflate2. Thus the strings most likely to be useful should be
+ put at the end of the dictionary, not at the front. In addition, the
+ current implementation of deflate will use at most the window size minus
+ 262 bytes of the provided dictionary.
+
+ Upon return of this function, strm->adler is set to the adler32 value
+ of the dictionary; the decompressor may later use this value to determine
+ which dictionary has been used by the compressor. (The adler32 value
+ applies to the whole dictionary even if only a subset of the dictionary is
+ actually used by the compressor.) If a raw deflate was requested, then the
+ adler32 value is not computed and strm->adler is not set.
+
+ deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
+ parameter is invalid (such as NULL dictionary) or the stream state is
+ inconsistent (for example if deflate has already been called for this stream
+ or if the compression method is bsort). deflateSetDictionary does not
+ perform any compression: this will be done by deflate().
+*/
+
+ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
+ z_streamp source));
+/*
+ Sets the destination stream as a complete copy of the source stream.
+
+ This function can be useful when several compression strategies will be
+ tried, for example when there are several ways of pre-processing the input
+ data with a filter. The streams that will be discarded should then be freed
+ by calling deflateEnd. Note that deflateCopy duplicates the internal
+ compression state which can be quite large, so this strategy is slow and
+ can consume lots of memory.
+
+ deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+ enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+ (such as zalloc being NULL). msg is left unchanged in both source and
+ destination.
+*/
+
+ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
+/*
+ This function is equivalent to deflateEnd followed by deflateInit,
+ but does not free and reallocate all the internal compression state.
+ The stream will keep the same compression level and any other attributes
+ that may have been set by deflateInit2.
+
+ deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+ stream state was inconsistent (such as zalloc or state being NULL).
+*/
+
+ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
+ int level,
+ int strategy));
+/*
+ Dynamically update the compression level and compression strategy. The
+ interpretation of level and strategy is as in deflateInit2. This can be
+ used to switch between compression and straight copy of the input data, or
+ to switch to a different kind of input data requiring a different
+ strategy. If the compression level is changed, the input available so far
+ is compressed with the old level (and may be flushed); the new level will
+ take effect only at the next call of deflate().
+
+ Before the call of deflateParams, the stream state must be set as for
+ a call of deflate(), since the currently available input may have to
+ be compressed and flushed. In particular, strm->avail_out must be non-zero.
+
+ deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
+ stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR
+ if strm->avail_out was zero.
+*/
+
+ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm,
+ int good_length,
+ int max_lazy,
+ int nice_length,
+ int max_chain));
+/*
+ Fine tune deflate's internal compression parameters. This should only be
+ used by someone who understands the algorithm used by zlib's deflate for
+ searching for the best matching string, and even then only by the most
+ fanatic optimizer trying to squeeze out the last compressed bit for their
+ specific input data. Read the deflate.c source code for the meaning of the
+ max_lazy, good_length, nice_length, and max_chain parameters.
+
+ deflateTune() can be called after deflateInit() or deflateInit2(), and
+ returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream.
+ */
+
+ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm,
+ uLong sourceLen));
+/*
+ deflateBound() returns an upper bound on the compressed size after
+ deflation of sourceLen bytes. It must be called after deflateInit()
+ or deflateInit2(). This would be used to allocate an output buffer
+ for deflation in a single pass, and so would be called before deflate().
+*/
+
+ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm,
+ int bits,
+ int value));
+/*
+ deflatePrime() inserts bits in the deflate output stream. The intent
+ is that this function is used to start off the deflate output with the
+ bits leftover from a previous deflate stream when appending to it. As such,
+ this function can only be used for raw deflate, and must be used before the
+ first deflate() call after a deflateInit2() or deflateReset(). bits must be
+ less than or equal to 16, and that many of the least significant bits of
+ value will be inserted in the output.
+
+ deflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
+ stream state was inconsistent.
+*/
+
+ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm,
+ gz_headerp head));
+/*
+ deflateSetHeader() provides gzip header information for when a gzip
+ stream is requested by deflateInit2(). deflateSetHeader() may be called
+ after deflateInit2() or deflateReset() and before the first call of
+ deflate(). The text, time, os, extra field, name, and comment information
+ in the provided gz_header structure are written to the gzip header (xflag is
+ ignored -- the extra flags are set according to the compression level). The
+ caller must assure that, if not Z_NULL, name and comment are terminated with
+ a zero byte, and that if extra is not Z_NULL, that extra_len bytes are
+ available there. If hcrc is true, a gzip header crc is included. Note that
+ the current versions of the command-line version of gzip (up through version
+ 1.3.x) do not support header crc's, and will report that it is a "multi-part
+ gzip file" and give up.
+
+ If deflateSetHeader is not used, the default gzip header has text false,
+ the time set to zero, and os set to 255, with no extra, name, or comment
+ fields. The gzip header is returned to the default state by deflateReset().
+
+ deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
+ stream state was inconsistent.
+*/
+
+/*
+ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
+ int windowBits));
+
+ This is another version of inflateInit with an extra parameter. The
+ fields next_in, avail_in, zalloc, zfree and opaque must be initialized
+ before by the caller.
+
+ The windowBits parameter is the base two logarithm of the maximum window
+ size (the size of the history buffer). It should be in the range 8..15 for
+ this version of the library. The default value is 15 if inflateInit is used
+ instead. windowBits must be greater than or equal to the windowBits value
+ provided to deflateInit2() while compressing, or it must be equal to 15 if
+ deflateInit2() was not used. If a compressed stream with a larger window
+ size is given as input, inflate() will return with the error code
+ Z_DATA_ERROR instead of trying to allocate a larger window.
+
+ windowBits can also be -8..-15 for raw inflate. In this case, -windowBits
+ determines the window size. inflate() will then process raw deflate data,
+ not looking for a zlib or gzip header, not generating a check value, and not
+ looking for any check values for comparison at the end of the stream. This
+ is for use with other formats that use the deflate compressed data format
+ such as zip. Those formats provide their own check values. If a custom
+ format is developed using the raw deflate format for compressed data, it is
+ recommended that a check value such as an adler32 or a crc32 be applied to
+ the uncompressed data as is done in the zlib, gzip, and zip formats. For
+ most applications, the zlib format should be used as is. Note that comments
+ above on the use in deflateInit2() applies to the magnitude of windowBits.
+
+ windowBits can also be greater than 15 for optional gzip decoding. Add
+ 32 to windowBits to enable zlib and gzip decoding with automatic header
+ detection, or add 16 to decode only the gzip format (the zlib format will
+ return a Z_DATA_ERROR). If a gzip stream is being decoded, strm->adler is
+ a crc32 instead of an adler32.
+
+ inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+ memory, Z_STREAM_ERROR if a parameter is invalid (such as a null strm). msg
+ is set to null if there is no error message. inflateInit2 does not perform
+ any decompression apart from reading the zlib header if present: this will
+ be done by inflate(). (So next_in and avail_in may be modified, but next_out
+ and avail_out are unchanged.)
+*/
+
+ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
+ const Bytef *dictionary,
+ uInt dictLength));
+/*
+ Initializes the decompression dictionary from the given uncompressed byte
+ sequence. This function must be called immediately after a call of inflate,
+ if that call returned Z_NEED_DICT. The dictionary chosen by the compressor
+ can be determined from the adler32 value returned by that call of inflate.
+ The compressor and decompressor must use exactly the same dictionary (see
+ deflateSetDictionary). For raw inflate, this function can be called
+ immediately after inflateInit2() or inflateReset() and before any call of
+ inflate() to set the dictionary. The application must insure that the
+ dictionary that was used for compression is provided.
+
+ inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
+ parameter is invalid (such as NULL dictionary) or the stream state is
+ inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
+ expected one (incorrect adler32 value). inflateSetDictionary does not
+ perform any decompression: this will be done by subsequent calls of
+ inflate().
+*/
+
+ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
+/*
+ Skips invalid compressed data until a full flush point (see above the
+ description of deflate with Z_FULL_FLUSH) can be found, or until all
+ available input is skipped. No output is provided.
+
+ inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR
+ if no more input was provided, Z_DATA_ERROR if no flush point has been found,
+ or Z_STREAM_ERROR if the stream structure was inconsistent. In the success
+ case, the application may save the current current value of total_in which
+ indicates where valid compressed data was found. In the error case, the
+ application may repeatedly call inflateSync, providing more input each time,
+ until success or end of the input data.
+*/
+
+ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest,
+ z_streamp source));
+/*
+ Sets the destination stream as a complete copy of the source stream.
+
+ This function can be useful when randomly accessing a large stream. The
+ first pass through the stream can periodically record the inflate state,
+ allowing restarting inflate at those points when randomly accessing the
+ stream.
+
+ inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+ enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+ (such as zalloc being NULL). msg is left unchanged in both source and
+ destination.
+*/
+
+ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
+/*
+ This function is equivalent to inflateEnd followed by inflateInit,
+ but does not free and reallocate all the internal decompression state.
+ The stream will keep attributes that may have been set by inflateInit2.
+
+ inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+ stream state was inconsistent (such as zalloc or state being NULL).
+*/
+
+ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm,
+ int bits,
+ int value));
+/*
+ This function inserts bits in the inflate input stream. The intent is
+ that this function is used to start inflating at a bit position in the
+ middle of a byte. The provided bits will be used before any bytes are used
+ from next_in. This function should only be used with raw inflate, and
+ should be used before the first inflate() call after inflateInit2() or
+ inflateReset(). bits must be less than or equal to 16, and that many of the
+ least significant bits of value will be inserted in the input.
+
+ inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
+ stream state was inconsistent.
+*/
+
+ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm,
+ gz_headerp head));
+/*
+ inflateGetHeader() requests that gzip header information be stored in the
+ provided gz_header structure. inflateGetHeader() may be called after
+ inflateInit2() or inflateReset(), and before the first call of inflate().
+ As inflate() processes the gzip stream, head->done is zero until the header
+ is completed, at which time head->done is set to one. If a zlib stream is
+ being decoded, then head->done is set to -1 to indicate that there will be
+ no gzip header information forthcoming. Note that Z_BLOCK can be used to
+ force inflate() to return immediately after header processing is complete
+ and before any actual data is decompressed.
+
+ The text, time, xflags, and os fields are filled in with the gzip header
+ contents. hcrc is set to true if there is a header CRC. (The header CRC
+ was valid if done is set to one.) If extra is not Z_NULL, then extra_max
+ contains the maximum number of bytes to write to extra. Once done is true,
+ extra_len contains the actual extra field length, and extra contains the
+ extra field, or that field truncated if extra_max is less than extra_len.
+ If name is not Z_NULL, then up to name_max characters are written there,
+ terminated with a zero unless the length is greater than name_max. If
+ comment is not Z_NULL, then up to comm_max characters are written there,
+ terminated with a zero unless the length is greater than comm_max. When
+ any of extra, name, or comment are not Z_NULL and the respective field is
+ not present in the header, then that field is set to Z_NULL to signal its
+ absence. This allows the use of deflateSetHeader() with the returned
+ structure to duplicate the header. However if those fields are set to
+ allocated memory, then the application will need to save those pointers
+ elsewhere so that they can be eventually freed.
+
+ If inflateGetHeader is not used, then the header information is simply
+ discarded. The header is always checked for validity, including the header
+ CRC if present. inflateReset() will reset the process to discard the header
+ information. The application would need to call inflateGetHeader() again to
+ retrieve the header from the next gzip stream.
+
+ inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
+ stream state was inconsistent.
+*/
+
+/*
+ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits,
+ unsigned char FAR *window));
+
+ Initialize the internal stream state for decompression using inflateBack()
+ calls. The fields zalloc, zfree and opaque in strm must be initialized
+ before the call. If zalloc and zfree are Z_NULL, then the default library-
+ derived memory allocation routines are used. windowBits is the base two
+ logarithm of the window size, in the range 8..15. window is a caller
+ supplied buffer of that size. Except for special applications where it is
+ assured that deflate was used with small window sizes, windowBits must be 15
+ and a 32K byte window must be supplied to be able to decompress general
+ deflate streams.
+
+ See inflateBack() for the usage of these routines.
+
+ inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of
+ the paramaters are invalid, Z_MEM_ERROR if the internal state could not
+ be allocated, or Z_VERSION_ERROR if the version of the library does not
+ match the version of the header file.
+*/
+
+typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *));
+typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned));
+
+ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm,
+ in_func in, void FAR *in_desc,
+ out_func out, void FAR *out_desc));
+/*
+ inflateBack() does a raw inflate with a single call using a call-back
+ interface for input and output. This is more efficient than inflate() for
+ file i/o applications in that it avoids copying between the output and the
+ sliding window by simply making the window itself the output buffer. This
+ function trusts the application to not change the output buffer passed by
+ the output function, at least until inflateBack() returns.
+
+ inflateBackInit() must be called first to allocate the internal state
+ and to initialize the state with the user-provided window buffer.
+ inflateBack() may then be used multiple times to inflate a complete, raw
+ deflate stream with each call. inflateBackEnd() is then called to free
+ the allocated state.
+
+ A raw deflate stream is one with no zlib or gzip header or trailer.
+ This routine would normally be used in a utility that reads zip or gzip
+ files and writes out uncompressed files. The utility would decode the
+ header and process the trailer on its own, hence this routine expects
+ only the raw deflate stream to decompress. This is different from the
+ normal behavior of inflate(), which expects either a zlib or gzip header and
+ trailer around the deflate stream.
+
+ inflateBack() uses two subroutines supplied by the caller that are then
+ called by inflateBack() for input and output. inflateBack() calls those
+ routines until it reads a complete deflate stream and writes out all of the
+ uncompressed data, or until it encounters an error. The function's
+ parameters and return types are defined above in the in_func and out_func
+ typedefs. inflateBack() will call in(in_desc, &buf) which should return the
+ number of bytes of provided input, and a pointer to that input in buf. If
+ there is no input available, in() must return zero--buf is ignored in that
+ case--and inflateBack() will return a buffer error. inflateBack() will call
+ out(out_desc, buf, len) to write the uncompressed data buf[0..len-1]. out()
+ should return zero on success, or non-zero on failure. If out() returns
+ non-zero, inflateBack() will return with an error. Neither in() nor out()
+ are permitted to change the contents of the window provided to
+ inflateBackInit(), which is also the buffer that out() uses to write from.
+ The length written by out() will be at most the window size. Any non-zero
+ amount of input may be provided by in().
+
+ For convenience, inflateBack() can be provided input on the first call by
+ setting strm->next_in and strm->avail_in. If that input is exhausted, then
+ in() will be called. Therefore strm->next_in must be initialized before
+ calling inflateBack(). If strm->next_in is Z_NULL, then in() will be called
+ immediately for input. If strm->next_in is not Z_NULL, then strm->avail_in
+ must also be initialized, and then if strm->avail_in is not zero, input will
+ initially be taken from strm->next_in[0 .. strm->avail_in - 1].
+
+ The in_desc and out_desc parameters of inflateBack() is passed as the
+ first parameter of in() and out() respectively when they are called. These
+ descriptors can be optionally used to pass any information that the caller-
+ supplied in() and out() functions need to do their job.
+
+ On return, inflateBack() will set strm->next_in and strm->avail_in to
+ pass back any unused input that was provided by the last in() call. The
+ return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR
+ if in() or out() returned an error, Z_DATA_ERROR if there was a format
+ error in the deflate stream (in which case strm->msg is set to indicate the
+ nature of the error), or Z_STREAM_ERROR if the stream was not properly
+ initialized. In the case of Z_BUF_ERROR, an input or output error can be
+ distinguished using strm->next_in which will be Z_NULL only if in() returned
+ an error. If strm->next is not Z_NULL, then the Z_BUF_ERROR was due to
+ out() returning non-zero. (in() will always be called before out(), so
+ strm->next_in is assured to be defined if out() returns non-zero.) Note
+ that inflateBack() cannot return Z_OK.
+*/
+
+ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm));
+/*
+ All memory allocated by inflateBackInit() is freed.
+
+ inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream
+ state was inconsistent.
+*/
+
+ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void));
+/* Return flags indicating compile-time options.
+
+ Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other:
+ 1.0: size of uInt
+ 3.2: size of uLong
+ 5.4: size of voidpf (pointer)
+ 7.6: size of z_off_t
+
+ Compiler, assembler, and debug options:
+ 8: DEBUG
+ 9: ASMV or ASMINF -- use ASM code
+ 10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention
+ 11: 0 (reserved)
+
+ One-time table building (smaller code, but not thread-safe if true):
+ 12: BUILDFIXED -- build static block decoding tables when needed
+ 13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed
+ 14,15: 0 (reserved)
+
+ Library content (indicates missing functionality):
+ 16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking
+ deflate code when not needed)
+ 17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect
+ and decode gzip streams (to avoid linking crc code)
+ 18-19: 0 (reserved)
+
+ Operation variations (changes in library functionality):
+ 20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate
+ 21: FASTEST -- deflate algorithm with only one, lowest compression level
+ 22,23: 0 (reserved)
+
+ The sprintf variant used by gzprintf (zero is best):
+ 24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format
+ 25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure!
+ 26: 0 = returns value, 1 = void -- 1 means inferred string length returned
+
+ Remainder:
+ 27-31: 0 (reserved)
+ */
+
+
+ /* utility functions */
+
+/*
+ The following utility functions are implemented on top of the
+ basic stream-oriented functions. To simplify the interface, some
+ default options are assumed (compression level and memory usage,
+ standard memory allocation functions). The source code of these
+ utility functions can easily be modified if you need special options.
+*/
+
+ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen,
+ const Bytef *source, uLong sourceLen));
+/*
+ Compresses the source buffer into the destination buffer. sourceLen is
+ the byte length of the source buffer. Upon entry, destLen is the total
+ size of the destination buffer, which must be at least the value returned
+ by compressBound(sourceLen). Upon exit, destLen is the actual size of the
+ compressed buffer.
+ This function can be used to compress a whole file at once if the
+ input file is mmap'ed.
+ compress returns Z_OK if success, Z_MEM_ERROR if there was not
+ enough memory, Z_BUF_ERROR if there was not enough room in the output
+ buffer.
+*/
+
+ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen,
+ const Bytef *source, uLong sourceLen,
+ int level));
+/*
+ Compresses the source buffer into the destination buffer. The level
+ parameter has the same meaning as in deflateInit. sourceLen is the byte
+ length of the source buffer. Upon entry, destLen is the total size of the
+ destination buffer, which must be at least the value returned by
+ compressBound(sourceLen). Upon exit, destLen is the actual size of the
+ compressed buffer.
+
+ compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+ memory, Z_BUF_ERROR if there was not enough room in the output buffer,
+ Z_STREAM_ERROR if the level parameter is invalid.
+*/
+
+ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen));
+/*
+ compressBound() returns an upper bound on the compressed size after
+ compress() or compress2() on sourceLen bytes. It would be used before
+ a compress() or compress2() call to allocate the destination buffer.
+*/
+
+ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen,
+ const Bytef *source, uLong sourceLen));
+/*
+ Decompresses the source buffer into the destination buffer. sourceLen is
+ the byte length of the source buffer. Upon entry, destLen is the total
+ size of the destination buffer, which must be large enough to hold the
+ entire uncompressed data. (The size of the uncompressed data must have
+ been saved previously by the compressor and transmitted to the decompressor
+ by some mechanism outside the scope of this compression library.)
+ Upon exit, destLen is the actual size of the compressed buffer.
+ This function can be used to decompress a whole file at once if the
+ input file is mmap'ed.
+
+ uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
+ enough memory, Z_BUF_ERROR if there was not enough room in the output
+ buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete.
+*/
+
+
+typedef voidp gzFile;
+
+ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode));
+/*
+ Opens a gzip (.gz) file for reading or writing. The mode parameter
+ is as in fopen ("rb" or "wb") but can also include a compression level
+ ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for
+ Huffman only compression as in "wb1h", or 'R' for run-length encoding
+ as in "wb1R". (See the description of deflateInit2 for more information
+ about the strategy parameter.)
+
+ gzopen can be used to read a file which is not in gzip format; in this
+ case gzread will directly read from the file without decompression.
+
+ gzopen returns NULL if the file could not be opened or if there was
+ insufficient memory to allocate the (de)compression state; errno
+ can be checked to distinguish the two cases (if errno is zero, the
+ zlib error is Z_MEM_ERROR). */
+
+ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode));
+/*
+ gzdopen() associates a gzFile with the file descriptor fd. File
+ descriptors are obtained from calls like open, dup, creat, pipe or
+ fileno (in the file has been previously opened with fopen).
+ The mode parameter is as in gzopen.
+ The next call of gzclose on the returned gzFile will also close the
+ file descriptor fd, just like fclose(fdopen(fd), mode) closes the file
+ descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode).
+ gzdopen returns NULL if there was insufficient memory to allocate
+ the (de)compression state.
+*/
+
+ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
+/*
+ Dynamically update the compression level or strategy. See the description
+ of deflateInit2 for the meaning of these parameters.
+ gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
+ opened for writing.
+*/
+
+ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len));
+/*
+ Reads the given number of uncompressed bytes from the compressed file.
+ If the input file was not in gzip format, gzread copies the given number
+ of bytes into the buffer.
+ gzread returns the number of uncompressed bytes actually read (0 for
+ end of file, -1 for error). */
+
+ZEXTERN int ZEXPORT gzwrite OF((gzFile file,
+ voidpc buf, unsigned len));
+/*
+ Writes the given number of uncompressed bytes into the compressed file.
+ gzwrite returns the number of uncompressed bytes actually written
+ (0 in case of error).
+*/
+
+ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...));
+/*
+ Converts, formats, and writes the args to the compressed file under
+ control of the format string, as in fprintf. gzprintf returns the number of
+ uncompressed bytes actually written (0 in case of error). The number of
+ uncompressed bytes written is limited to 4095. The caller should assure that
+ this limit is not exceeded. If it is exceeded, then gzprintf() will return
+ return an error (0) with nothing written. In this case, there may also be a
+ buffer overflow with unpredictable consequences, which is possible only if
+ zlib was compiled with the insecure functions sprintf() or vsprintf()
+ because the secure snprintf() or vsnprintf() functions were not available.
+*/
+
+ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
+/*
+ Writes the given null-terminated string to the compressed file, excluding
+ the terminating null character.
+ gzputs returns the number of characters written, or -1 in case of error.
+*/
+
+ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len));
+/*
+ Reads bytes from the compressed file until len-1 characters are read, or
+ a newline character is read and transferred to buf, or an end-of-file
+ condition is encountered. The string is then terminated with a null
+ character.
+ gzgets returns buf, or Z_NULL in case of error.
+*/
+
+ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c));
+/*
+ Writes c, converted to an unsigned char, into the compressed file.
+ gzputc returns the value that was written, or -1 in case of error.
+*/
+
+ZEXTERN int ZEXPORT gzgetc OF((gzFile file));
+/*
+ Reads one byte from the compressed file. gzgetc returns this byte
+ or -1 in case of end of file or error.
+*/
+
+ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file));
+/*
+ Push one character back onto the stream to be read again later.
+ Only one character of push-back is allowed. gzungetc() returns the
+ character pushed, or -1 on failure. gzungetc() will fail if a
+ character has been pushed but not read yet, or if c is -1. The pushed
+ character will be discarded if the stream is repositioned with gzseek()
+ or gzrewind().
+*/
+
+ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush));
+/*
+ Flushes all pending output into the compressed file. The parameter
+ flush is as in the deflate() function. The return value is the zlib
+ error number (see function gzerror below). gzflush returns Z_OK if
+ the flush parameter is Z_FINISH and all output could be flushed.
+ gzflush should be called only when strictly necessary because it can
+ degrade compression.
+*/
+
+ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file,
+ z_off_t offset, int whence));
+/*
+ Sets the starting position for the next gzread or gzwrite on the
+ given compressed file. The offset represents a number of bytes in the
+ uncompressed data stream. The whence parameter is defined as in lseek(2);
+ the value SEEK_END is not supported.
+ If the file is opened for reading, this function is emulated but can be
+ extremely slow. If the file is opened for writing, only forward seeks are
+ supported; gzseek then compresses a sequence of zeroes up to the new
+ starting position.
+
+ gzseek returns the resulting offset location as measured in bytes from
+ the beginning of the uncompressed stream, or -1 in case of error, in
+ particular if the file is opened for writing and the new starting position
+ would be before the current position.
+*/
+
+ZEXTERN int ZEXPORT gzrewind OF((gzFile file));
+/*
+ Rewinds the given file. This function is supported only for reading.
+
+ gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
+*/
+
+ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file));
+/*
+ Returns the starting position for the next gzread or gzwrite on the
+ given compressed file. This position represents a number of bytes in the
+ uncompressed data stream.
+
+ gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
+*/
+
+ZEXTERN int ZEXPORT gzeof OF((gzFile file));
+/*
+ Returns 1 when EOF has previously been detected reading the given
+ input stream, otherwise zero.
+*/
+
+ZEXTERN int ZEXPORT gzdirect OF((gzFile file));
+/*
+ Returns 1 if file is being read directly without decompression, otherwise
+ zero.
+*/
+
+ZEXTERN int ZEXPORT gzclose OF((gzFile file));
+/*
+ Flushes all pending output if necessary, closes the compressed file
+ and deallocates all the (de)compression state. The return value is the zlib
+ error number (see function gzerror below).
+*/
+
+ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum));
+/*
+ Returns the error message for the last error which occurred on the
+ given compressed file. errnum is set to zlib error number. If an
+ error occurred in the file system and not in the compression library,
+ errnum is set to Z_ERRNO and the application may consult errno
+ to get the exact error code.
+*/
+
+ZEXTERN void ZEXPORT gzclearerr OF((gzFile file));
+/*
+ Clears the error and end-of-file flags for file. This is analogous to the
+ clearerr() function in stdio. This is useful for continuing to read a gzip
+ file that is being written concurrently.
+*/
+
+ /* checksum functions */
+
+/*
+ These functions are not related to compression but are exported
+ anyway because they might be useful in applications using the
+ compression library.
+*/
+
+ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
+/*
+ Update a running Adler-32 checksum with the bytes buf[0..len-1] and
+ return the updated checksum. If buf is NULL, this function returns
+ the required initial value for the checksum.
+ An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
+ much faster. Usage example:
+
+ uLong adler = adler32(0L, Z_NULL, 0);
+
+ while (read_buffer(buffer, length) != EOF) {
+ adler = adler32(adler, buffer, length);
+ }
+ if (adler != original_adler) error();
+*/
+
+ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2,
+ z_off_t len2));
+/*
+ Combine two Adler-32 checksums into one. For two sequences of bytes, seq1
+ and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for
+ each, adler1 and adler2. adler32_combine() returns the Adler-32 checksum of
+ seq1 and seq2 concatenated, requiring only adler1, adler2, and len2.
+*/
+
+ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len));
+/*
+ Update a running CRC-32 with the bytes buf[0..len-1] and return the
+ updated CRC-32. If buf is NULL, this function returns the required initial
+ value for the for the crc. Pre- and post-conditioning (one's complement) is
+ performed within this function so it shouldn't be done by the application.
+ Usage example:
+
+ uLong crc = crc32(0L, Z_NULL, 0);
+
+ while (read_buffer(buffer, length) != EOF) {
+ crc = crc32(crc, buffer, length);
+ }
+ if (crc != original_crc) error();
+*/
+
+ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2));
+
+/*
+ Combine two CRC-32 check values into one. For two sequences of bytes,
+ seq1 and seq2 with lengths len1 and len2, CRC-32 check values were
+ calculated for each, crc1 and crc2. crc32_combine() returns the CRC-32
+ check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and
+ len2.
+*/
+
+
+ /* various hacks, don't look :) */
+
+/* deflateInit and inflateInit are macros to allow checking the zlib version
+ * and the compiler's view of z_stream:
+ */
+ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
+ const char *version, int stream_size));
+ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm,
+ const char *version, int stream_size));
+ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method,
+ int windowBits, int memLevel,
+ int strategy, const char *version,
+ int stream_size));
+ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits,
+ const char *version, int stream_size));
+ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits,
+ unsigned char FAR *window,
+ const char *version,
+ int stream_size));
+#define deflateInit(strm, level) \
+ deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream))
+#define inflateInit(strm) \
+ inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream))
+#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+ deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
+ (strategy), ZLIB_VERSION, sizeof(z_stream))
+#define inflateInit2(strm, windowBits) \
+ inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
+#define inflateBackInit(strm, windowBits, window) \
+ inflateBackInit_((strm), (windowBits), (window), \
+ ZLIB_VERSION, sizeof(z_stream))
+
+
+#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL)
+ struct internal_state {int dummy;}; /* hack for buggy compilers */
+#endif
+
+ZEXTERN const char * ZEXPORT zError OF((int));
+ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp z));
+ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZLIB_H */
--- /dev/null
+/* zutil.c -- target dependent utility functions for the compression library
+ * Copyright (C) 1995-2005 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#include "zutil.h"
+
+#ifndef NO_DUMMY_DECL
+struct internal_state {int dummy;}; /* for buggy compilers */
+#endif
+
+const char * const z_errmsg[10] = {
+"need dictionary", /* Z_NEED_DICT 2 */
+"stream end", /* Z_STREAM_END 1 */
+"", /* Z_OK 0 */
+"file error", /* Z_ERRNO (-1) */
+"stream error", /* Z_STREAM_ERROR (-2) */
+"data error", /* Z_DATA_ERROR (-3) */
+"insufficient memory", /* Z_MEM_ERROR (-4) */
+"buffer error", /* Z_BUF_ERROR (-5) */
+"incompatible version",/* Z_VERSION_ERROR (-6) */
+""};
+
+
+const char * ZEXPORT zlibVersion()
+{
+ return ZLIB_VERSION;
+}
+
+uLong ZEXPORT zlibCompileFlags()
+{
+ uLong flags;
+
+ flags = 0;
+ switch (sizeof(uInt)) {
+ case 2: break;
+ case 4: flags += 1; break;
+ case 8: flags += 2; break;
+ default: flags += 3;
+ }
+ switch (sizeof(uLong)) {
+ case 2: break;
+ case 4: flags += 1 << 2; break;
+ case 8: flags += 2 << 2; break;
+ default: flags += 3 << 2;
+ }
+ switch (sizeof(voidpf)) {
+ case 2: break;
+ case 4: flags += 1 << 4; break;
+ case 8: flags += 2 << 4; break;
+ default: flags += 3 << 4;
+ }
+ switch (sizeof(z_off_t)) {
+ case 2: break;
+ case 4: flags += 1 << 6; break;
+ case 8: flags += 2 << 6; break;
+ default: flags += 3 << 6;
+ }
+#ifdef DEBUG
+ flags += 1 << 8;
+#endif
+#if defined(ASMV) || defined(ASMINF)
+ flags += 1 << 9;
+#endif
+#ifdef ZLIB_WINAPI
+ flags += 1 << 10;
+#endif
+#ifdef BUILDFIXED
+ flags += 1 << 12;
+#endif
+#ifdef DYNAMIC_CRC_TABLE
+ flags += 1 << 13;
+#endif
+#ifdef NO_GZCOMPRESS
+ flags += 1L << 16;
+#endif
+#ifdef NO_GZIP
+ flags += 1L << 17;
+#endif
+#ifdef PKZIP_BUG_WORKAROUND
+ flags += 1L << 20;
+#endif
+#ifdef FASTEST
+ flags += 1L << 21;
+#endif
+#ifdef STDC
+# ifdef NO_vsnprintf
+ flags += 1L << 25;
+# ifdef HAS_vsprintf_void
+ flags += 1L << 26;
+# endif
+# else
+# ifdef HAS_vsnprintf_void
+ flags += 1L << 26;
+# endif
+# endif
+#else
+ flags += 1L << 24;
+# ifdef NO_snprintf
+ flags += 1L << 25;
+# ifdef HAS_sprintf_void
+ flags += 1L << 26;
+# endif
+# else
+# ifdef HAS_snprintf_void
+ flags += 1L << 26;
+# endif
+# endif
+#endif
+ return flags;
+}
+
+#ifdef DEBUG
+
+# ifndef verbose
+# define verbose 0
+# endif
+int z_verbose = verbose;
+
+void z_error (m)
+ char *m;
+{
+ fprintf(stderr, "%s\n", m);
+ exit(1);
+}
+#endif
+
+/* exported to allow conversion of error code to string for compress() and
+ * uncompress()
+ */
+const char * ZEXPORT zError(err)
+ int err;
+{
+ return ERR_MSG(err);
+}
+
+#if defined(_WIN32_WCE)
+ /* The Microsoft C Run-Time Library for Windows CE doesn't have
+ * errno. We define it as a global variable to simplify porting.
+ * Its value is always 0 and should not be used.
+ */
+ int errno = 0;
+#endif
+
+#ifndef HAVE_MEMCPY
+
+void zmemcpy(dest, source, len)
+ Bytef* dest;
+ const Bytef* source;
+ uInt len;
+{
+ if (len == 0) return;
+ do {
+ *dest++ = *source++; /* ??? to be unrolled */
+ } while (--len != 0);
+}
+
+int zmemcmp(s1, s2, len)
+ const Bytef* s1;
+ const Bytef* s2;
+ uInt len;
+{
+ uInt j;
+
+ for (j = 0; j < len; j++) {
+ if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;
+ }
+ return 0;
+}
+
+void zmemzero(dest, len)
+ Bytef* dest;
+ uInt len;
+{
+ if (len == 0) return;
+ do {
+ *dest++ = 0; /* ??? to be unrolled */
+ } while (--len != 0);
+}
+#endif
+
+
+#ifdef SYS16BIT
+
+#ifdef __TURBOC__
+/* Turbo C in 16-bit mode */
+
+# define MY_ZCALLOC
+
+/* Turbo C malloc() does not allow dynamic allocation of 64K bytes
+ * and farmalloc(64K) returns a pointer with an offset of 8, so we
+ * must fix the pointer. Warning: the pointer must be put back to its
+ * original form in order to free it, use zcfree().
+ */
+
+#define MAX_PTR 10
+/* 10*64K = 640K */
+
+local int next_ptr = 0;
+
+typedef struct ptr_table_s {
+ voidpf org_ptr;
+ voidpf new_ptr;
+} ptr_table;
+
+local ptr_table table[MAX_PTR];
+/* This table is used to remember the original form of pointers
+ * to large buffers (64K). Such pointers are normalized with a zero offset.
+ * Since MSDOS is not a preemptive multitasking OS, this table is not
+ * protected from concurrent access. This hack doesn't work anyway on
+ * a protected system like OS/2. Use Microsoft C instead.
+ */
+
+voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)
+{
+ voidpf buf = opaque; /* just to make some compilers happy */
+ ulg bsize = (ulg)items*size;
+
+ /* If we allocate less than 65520 bytes, we assume that farmalloc
+ * will return a usable pointer which doesn't have to be normalized.
+ */
+ if (bsize < 65520L) {
+ buf = farmalloc(bsize);
+ if (*(ush*)&buf != 0) return buf;
+ } else {
+ buf = farmalloc(bsize + 16L);
+ }
+ if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
+ table[next_ptr].org_ptr = buf;
+
+ /* Normalize the pointer to seg:0 */
+ *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
+ *(ush*)&buf = 0;
+ table[next_ptr++].new_ptr = buf;
+ return buf;
+}
+
+void zcfree (voidpf opaque, voidpf ptr)
+{
+ int n;
+ if (*(ush*)&ptr != 0) { /* object < 64K */
+ farfree(ptr);
+ return;
+ }
+ /* Find the original pointer */
+ for (n = 0; n < next_ptr; n++) {
+ if (ptr != table[n].new_ptr) continue;
+
+ farfree(table[n].org_ptr);
+ while (++n < next_ptr) {
+ table[n-1] = table[n];
+ }
+ next_ptr--;
+ return;
+ }
+ ptr = opaque; /* just to make some compilers happy */
+ Assert(0, "zcfree: ptr not found");
+}
+
+#endif /* __TURBOC__ */
+
+
+#ifdef M_I86
+/* Microsoft C in 16-bit mode */
+
+# define MY_ZCALLOC
+
+#if (!defined(_MSC_VER) || (_MSC_VER <= 600))
+# define _halloc halloc
+# define _hfree hfree
+#endif
+
+voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)
+{
+ if (opaque) opaque = 0; /* to make compiler happy */
+ return _halloc((long)items, size);
+}
+
+void zcfree (voidpf opaque, voidpf ptr)
+{
+ if (opaque) opaque = 0; /* to make compiler happy */
+ _hfree(ptr);
+}
+
+#endif /* M_I86 */
+
+#endif /* SYS16BIT */
+
+
+#ifndef MY_ZCALLOC /* Any system without a special alloc function */
+
+#ifndef STDC
+extern voidp malloc OF((uInt size));
+extern voidp calloc OF((uInt items, uInt size));
+extern void free OF((voidpf ptr));
+#endif
+
+voidpf zcalloc (opaque, items, size)
+ voidpf opaque;
+ unsigned items;
+ unsigned size;
+{
+ if (opaque) items += size - size; /* make compiler happy */
+ return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
+ (voidpf)calloc(items, size);
+}
+
+void zcfree (opaque, ptr)
+ voidpf opaque;
+ voidpf ptr;
+{
+ free(ptr);
+ if (opaque) return; /* make compiler happy */
+}
+
+#endif /* MY_ZCALLOC */
--- /dev/null
+/* zutil.h -- internal interface and configuration of the compression library
+ * Copyright (C) 1995-2005 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+ part of the implementation of the compression library and is
+ subject to change. Applications should only use zlib.h.
+ */
+
+/* @(#) $Id$ */
+
+#ifndef ZUTIL_H
+#define ZUTIL_H
+
+#define ZLIB_INTERNAL
+#include "zlib.h"
+
+#ifdef STDC
+# ifndef _WIN32_WCE
+# include <stddef.h>
+# endif
+# include <string.h>
+# include <stdlib.h>
+#endif
+#ifdef NO_ERRNO_H
+# ifdef _WIN32_WCE
+ /* The Microsoft C Run-Time Library for Windows CE doesn't have
+ * errno. We define it as a global variable to simplify porting.
+ * Its value is always 0 and should not be used. We rename it to
+ * avoid conflict with other libraries that use the same workaround.
+ */
+# define errno z_errno
+# endif
+ extern int errno;
+#else
+# ifndef _WIN32_WCE
+# include <errno.h>
+# endif
+#endif
+
+#ifndef local
+# define local static
+#endif
+/* compile with -Dlocal if your debugger can't find static symbols */
+
+typedef unsigned char uch;
+typedef uch FAR uchf;
+typedef unsigned short ush;
+typedef ush FAR ushf;
+typedef unsigned long ulg;
+
+extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
+/* (size given to avoid silly warnings with Visual C++) */
+
+#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)]
+
+#define ERR_RETURN(strm,err) \
+ return (strm->msg = (char*)ERR_MSG(err), (err))
+/* To be used only when the state is known to be valid */
+
+ /* common constants */
+
+#ifndef DEF_WBITS
+# define DEF_WBITS MAX_WBITS
+#endif
+/* default windowBits for decompression. MAX_WBITS is for compression only */
+
+#if MAX_MEM_LEVEL >= 8
+# define DEF_MEM_LEVEL 8
+#else
+# define DEF_MEM_LEVEL MAX_MEM_LEVEL
+#endif
+/* default memLevel */
+
+#define STORED_BLOCK 0
+#define STATIC_TREES 1
+#define DYN_TREES 2
+/* The three kinds of block type */
+
+#define MIN_MATCH 3
+#define MAX_MATCH 258
+/* The minimum and maximum match lengths */
+
+#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */
+
+ /* target dependencies */
+
+#if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32))
+# define OS_CODE 0x00
+# if defined(__TURBOC__) || defined(__BORLANDC__)
+# if(__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__))
+ /* Allow compilation with ANSI keywords only enabled */
+ void _Cdecl farfree( void *block );
+ void *_Cdecl farmalloc( unsigned long nbytes );
+# else
+# include <alloc.h>
+# endif
+# else /* MSC or DJGPP */
+# include <malloc.h>
+# endif
+#endif
+
+#ifdef AMIGA
+# define OS_CODE 0x01
+#endif
+
+#if defined(VAXC) || defined(VMS)
+# define OS_CODE 0x02
+# define F_OPEN(name, mode) \
+ fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
+#endif
+
+#if defined(ATARI) || defined(atarist)
+# define OS_CODE 0x05
+#endif
+
+#ifdef OS2
+# define OS_CODE 0x06
+# ifdef M_I86
+ #include <malloc.h>
+# endif
+#endif
+
+#if defined(MACOS) || defined(TARGET_OS_MAC)
+# define OS_CODE 0x07
+# if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
+# include <unix.h> /* for fdopen */
+# else
+# ifndef fdopen
+# define fdopen(fd,mode) NULL /* No fdopen() */
+# endif
+# endif
+#endif
+
+#ifdef TOPS20
+# define OS_CODE 0x0a
+#endif
+
+#ifdef WIN32
+# ifndef __CYGWIN__ /* Cygwin is Unix, not Win32 */
+# define OS_CODE 0x0b
+# endif
+#endif
+
+#ifdef __50SERIES /* Prime/PRIMOS */
+# define OS_CODE 0x0f
+#endif
+
+#if defined(_BEOS_) || defined(RISCOS)
+# define fdopen(fd,mode) NULL /* No fdopen() */
+#endif
+
+#if (defined(_MSC_VER) && (_MSC_VER > 600))
+# if defined(_WIN32_WCE)
+# define fdopen(fd,mode) NULL /* No fdopen() */
+# ifndef _PTRDIFF_T_DEFINED
+ typedef int ptrdiff_t;
+# define _PTRDIFF_T_DEFINED
+# endif
+# else
+# define fdopen(fd,type) _fdopen(fd,type)
+# endif
+#endif
+
+ /* common defaults */
+
+#ifndef OS_CODE
+# define OS_CODE 0x03 /* assume Unix */
+#endif
+
+#ifndef F_OPEN
+# define F_OPEN(name, mode) fopen((name), (mode))
+#endif
+
+ /* functions */
+
+#if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550)
+# ifndef HAVE_VSNPRINTF
+# define HAVE_VSNPRINTF
+# endif
+#endif
+#if defined(__CYGWIN__)
+# ifndef HAVE_VSNPRINTF
+# define HAVE_VSNPRINTF
+# endif
+#endif
+#ifndef HAVE_VSNPRINTF
+# ifdef MSDOS
+ /* vsnprintf may exist on some MS-DOS compilers (DJGPP?),
+ but for now we just assume it doesn't. */
+# define NO_vsnprintf
+# endif
+# ifdef __TURBOC__
+# define NO_vsnprintf
+# endif
+# ifdef WIN32
+ /* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */
+# if !defined(vsnprintf) && !defined(NO_vsnprintf)
+# define vsnprintf _vsnprintf
+# endif
+# endif
+# ifdef __SASC
+# define NO_vsnprintf
+# endif
+#endif
+#ifdef VMS
+# define NO_vsnprintf
+#endif
+
+#if defined(pyr)
+# define NO_MEMCPY
+#endif
+#if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__)
+ /* Use our own functions for small and medium model with MSC <= 5.0.
+ * You may have to use the same strategy for Borland C (untested).
+ * The __SC__ check is for Symantec.
+ */
+# define NO_MEMCPY
+#endif
+#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY)
+# define HAVE_MEMCPY
+#endif
+#ifdef HAVE_MEMCPY
+# ifdef SMALL_MEDIUM /* MSDOS small or medium model */
+# define zmemcpy _fmemcpy
+# define zmemcmp _fmemcmp
+# define zmemzero(dest, len) _fmemset(dest, 0, len)
+# else
+# define zmemcpy memcpy
+# define zmemcmp memcmp
+# define zmemzero(dest, len) memset(dest, 0, len)
+# endif
+#else
+ extern void zmemcpy OF((Bytef* dest, const Bytef* source, uInt len));
+ extern int zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len));
+ extern void zmemzero OF((Bytef* dest, uInt len));
+#endif
+
+/* Diagnostic functions */
+#ifdef DEBUG
+# include <stdio.h>
+ extern int z_verbose;
+ extern void z_error OF((char *m));
+# define Assert(cond,msg) {if(!(cond)) z_error(msg);}
+# define Trace(x) {if (z_verbose>=0) fprintf x ;}
+# define Tracev(x) {if (z_verbose>0) fprintf x ;}
+# define Tracevv(x) {if (z_verbose>1) fprintf x ;}
+# define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;}
+# define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;}
+#else
+# define Assert(cond,msg)
+# define Trace(x)
+# define Tracev(x)
+# define Tracevv(x)
+# define Tracec(c,x)
+# define Tracecv(c,x)
+#endif
+
+
+voidpf zcalloc OF((voidpf opaque, unsigned items, unsigned size));
+void zcfree OF((voidpf opaque, voidpf ptr));
+
+#define ZALLOC(strm, items, size) \
+ (*((strm)->zalloc))((strm)->opaque, (items), (size))
+#define ZFREE(strm, addr) (*((strm)->zfree))((strm)->opaque, (voidpf)(addr))
+#define TRY_FREE(s, p) {if (p) ZFREE(s, p);}
+
+#endif /* ZUTIL_H */
dbg = -g
opt = -O1 -ffast-math -fomit-frame-pointer
-inc_flags = -Isrc -Ilibs -I/usr/local/include
+inc_flags = -Isrc -I../../libs -I../../libs/zlib -I../../libs/libpng -I../../libs/jpeglib
warn_flags = -Wall -Wno-sign-compare -Wno-strict-aliasing -Wno-char-subscripts
CXXFLAGS = $(opt) $(dbg) -ansi -pedantic $(warn_flags) -MMD $(inc_flags) \
include src/common/makefile.part
include src/fxwt/makefile.part
include src/sim/makefile.part
-include libs/lib3ds/makefile.part
# get all the object files in one variable $(obj)
obj = $(3dengfx_obj) \
$(dsys_obj) \
$(common_obj) \
$(fxwt_obj) \
- $(sim_obj) \
- $(lib3ds_obj)
+ $(sim_obj)
lib3dengfx.a: $(obj)
$(AR) rcs $@ $(obj)
+++ /dev/null
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: atmosphere.c,v 1.9 2001/07/07 19:05:30 jeh Exp $
- */
-#define LIB3DS_EXPORT
-#include <lib3ds/atmosphere.h>
-#include <lib3ds/chunk.h>
-#include <lib3ds/io.h>
-
-
-/*!
- * \defgroup atmosphere Atmosphere Settings
- *
- * \author J.E. Hoffmann <je-h@gmx.net>
- */
-
-
-static Lib3dsBool
-fog_read(Lib3dsFog *fog, Lib3dsIo *io)
-{
- Lib3dsChunk c;
- Lib3dsWord chunk;
-
- if (!lib3ds_chunk_read_start(&c, LIB3DS_FOG, io)) {
- return(LIB3DS_FALSE);
- }
- fog->near_plane = lib3ds_io_read_float(io);
- fog->near_density=lib3ds_io_read_float(io);
- fog->far_plane=lib3ds_io_read_float(io);
- fog->far_density=lib3ds_io_read_float(io);
- lib3ds_chunk_read_tell(&c, io);
-
- while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
- switch (chunk) {
- case LIB3DS_LIN_COLOR_F:
- {
- int i;
- for (i=0; i<3; ++i) {
- fog->col[i]=lib3ds_io_read_float(io);
- }
- }
- break;
- case LIB3DS_COLOR_F:
- break;
- case LIB3DS_FOG_BGND:
- {
- fog->fog_background=LIB3DS_TRUE;
- }
- break;
- default:
- lib3ds_chunk_unknown(chunk);
- }
- }
-
- lib3ds_chunk_read_end(&c, io);
- return(LIB3DS_TRUE);
-}
-
-
-static Lib3dsBool
-layer_fog_read(Lib3dsLayerFog *fog, Lib3dsIo *io)
-{
- Lib3dsChunk c;
- Lib3dsWord chunk;
-
- if (!lib3ds_chunk_read_start(&c, LIB3DS_LAYER_FOG, io)) {
- return(LIB3DS_FALSE);
- }
- fog->near_y=lib3ds_io_read_float(io);
- fog->far_y=lib3ds_io_read_float(io);
- fog->density=lib3ds_io_read_float(io);
- fog->flags=lib3ds_io_read_dword(io);
- lib3ds_chunk_read_tell(&c, io);
-
- while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
- switch (chunk) {
- case LIB3DS_LIN_COLOR_F:
- lib3ds_io_read_rgb(io, fog->col);
- break;
- case LIB3DS_COLOR_F:
- lib3ds_io_read_rgb(io, fog->col);
- break;
- default:
- lib3ds_chunk_unknown(chunk);
- }
- }
-
- lib3ds_chunk_read_end(&c, io);
- return(LIB3DS_TRUE);
-}
-
-
-static Lib3dsBool
-distance_cue_read(Lib3dsDistanceCue *cue, Lib3dsIo *io)
-{
- Lib3dsChunk c;
- Lib3dsWord chunk;
-
- if (!lib3ds_chunk_read_start(&c, LIB3DS_DISTANCE_CUE, io)) {
- return(LIB3DS_FALSE);
- }
- cue->near_plane=lib3ds_io_read_float(io);
- cue->near_dimming=lib3ds_io_read_float(io);
- cue->far_plane=lib3ds_io_read_float(io);
- cue->far_dimming=lib3ds_io_read_float(io);
- lib3ds_chunk_read_tell(&c, io);
-
- while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
- switch (chunk) {
- case LIB3DS_DCUE_BGND:
- {
- cue->cue_background=LIB3DS_TRUE;
- }
- break;
- default:
- lib3ds_chunk_unknown(chunk);
- }
- }
-
- lib3ds_chunk_read_end(&c, io);
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup atmosphere
- */
-Lib3dsBool
-lib3ds_atmosphere_read(Lib3dsAtmosphere *atmosphere, Lib3dsIo *io)
-{
- Lib3dsChunk c;
-
- if (!lib3ds_chunk_read(&c, io)) {
- return(LIB3DS_FALSE);
- }
-
- switch (c.chunk) {
- case LIB3DS_FOG:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!fog_read(&atmosphere->fog, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_LAYER_FOG:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!layer_fog_read(&atmosphere->layer_fog, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_DISTANCE_CUE:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!distance_cue_read(&atmosphere->dist_cue, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_USE_FOG:
- {
- atmosphere->fog.use=LIB3DS_TRUE;
- }
- break;
- case LIB3DS_USE_LAYER_FOG:
- {
- atmosphere->fog.use=LIB3DS_TRUE;
- }
- break;
- case LIB3DS_USE_DISTANCE_CUE:
- {
- atmosphere->dist_cue.use=LIB3DS_TRUE;
- }
- break;
- }
-
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup atmosphere
- */
-Lib3dsBool
-lib3ds_atmosphere_write(Lib3dsAtmosphere *atmosphere, Lib3dsIo *io)
-{
- if (atmosphere->fog.use) { /*---- LIB3DS_FOG ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_FOG;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
- lib3ds_io_write_float(io, atmosphere->fog.near_plane);
- lib3ds_io_write_float(io, atmosphere->fog.near_density);
- lib3ds_io_write_float(io, atmosphere->fog.far_plane);
- lib3ds_io_write_float(io, atmosphere->fog.far_density);
- {
- Lib3dsChunk c;
- c.chunk=LIB3DS_COLOR_F;
- c.size=18;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_rgb(io, atmosphere->fog.col);
- }
- if (atmosphere->fog.fog_background) {
- Lib3dsChunk c;
- c.chunk=LIB3DS_FOG_BGND;
- c.size=6;
- lib3ds_chunk_write(&c,io);
- }
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- }
-
- if (atmosphere->layer_fog.use) { /*---- LIB3DS_LAYER_FOG ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_LAYER_FOG;
- c.size=40;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_float(io, atmosphere->layer_fog.near_y);
- lib3ds_io_write_float(io, atmosphere->layer_fog.far_y);
- lib3ds_io_write_float(io, atmosphere->layer_fog.near_y);
- lib3ds_io_write_dword(io, atmosphere->layer_fog.flags);
- {
- Lib3dsChunk c;
- c.chunk=LIB3DS_COLOR_F;
- c.size=18;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_rgb(io, atmosphere->fog.col);
- }
- }
-
- if (atmosphere->dist_cue.use) { /*---- LIB3DS_DISTANCE_CUE ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_DISTANCE_CUE;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
- lib3ds_io_write_float(io, atmosphere->dist_cue.near_plane);
- lib3ds_io_write_float(io, atmosphere->dist_cue.near_dimming);
- lib3ds_io_write_float(io, atmosphere->dist_cue.far_plane);
- lib3ds_io_write_float(io, atmosphere->dist_cue.far_dimming);
- if (atmosphere->dist_cue.cue_background) {
- Lib3dsChunk c;
- c.chunk=LIB3DS_DCUE_BGND;
- c.size=6;
- lib3ds_chunk_write(&c,io);
- }
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- }
-
- if (atmosphere->fog.use) { /*---- LIB3DS_USE_FOG ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_USE_FOG;
- c.size=6;
- lib3ds_chunk_write(&c,io);
- }
-
- if (atmosphere->layer_fog.use) { /*---- LIB3DS_USE_LAYER_FOG ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_USE_LAYER_FOG;
- c.size=6;
- lib3ds_chunk_write(&c,io);
- }
-
- if (atmosphere->dist_cue.use) { /*---- LIB3DS_USE_DISTANCE_CUE ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_USE_V_GRADIENT;
- c.size=6;
- lib3ds_chunk_write(&c,io);
- }
-
- return(LIB3DS_TRUE);
-}
-
-
-/*!
-
-\typedef Lib3dsAtmosphere
- \ingroup atmosphere
- \sa _Lib3dsAtmosphere
-
-*/
-
+++ /dev/null
-/* -*- c -*- */
-#ifndef INCLUDED_LIB3DS_ATMOSPHERE_H
-#define INCLUDED_LIB3DS_ATMOSPHERE_H
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: atmosphere.h,v 1.6 2004/12/31 16:17:15 reed Exp $
- */
-
-#ifndef INCLUDED_LIB3DS_TYPES_H
-#include <lib3ds/types.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*!
- * Fog atmosphere settings
- * \ingroup atmosphere
- */
-typedef struct _Lib3dsFog {
- Lib3dsBool use;
- Lib3dsRgb col;
- Lib3dsBool fog_background;
- Lib3dsFloat near_plane;
- Lib3dsFloat near_density;
- Lib3dsFloat far_plane;
- Lib3dsFloat far_density;
-} Lib3dsFog;
-
-/*!
- * Layer fog atmosphere flags
- * \ingroup atmosphere
- */
-typedef enum _Lib3dsLayerFogFlags {
- LIB3DS_BOTTOM_FALL_OFF =0x00000001,
- LIB3DS_TOP_FALL_OFF =0x00000002,
- LIB3DS_FOG_BACKGROUND =0x00100000
-} Lib3dsLayerFogFlags;
-
-/*!
- * Layer fog atmosphere settings
- * \ingroup atmosphere
- */
-typedef struct _Lib3dsLayerFog {
- Lib3dsBool use;
- Lib3dsDword flags;
- Lib3dsRgb col;
- Lib3dsFloat near_y;
- Lib3dsFloat far_y;
- Lib3dsFloat density;
-} Lib3dsLayerFog;
-
-/*!
- * Distance cue atmosphere settings
- * \ingroup atmosphere
- */
-typedef struct _Lib3dsDistanceCue {
- Lib3dsBool use;
- Lib3dsBool cue_background;
- Lib3dsFloat near_plane;
- Lib3dsFloat near_dimming;
- Lib3dsFloat far_plane;
- Lib3dsFloat far_dimming;
-} Lib3dsDistanceCue;
-
-/*!
- * Atmosphere settings
- * \ingroup atmosphere
- */
-struct _Lib3dsAtmosphere {
- Lib3dsFog fog;
- Lib3dsLayerFog layer_fog;
- Lib3dsDistanceCue dist_cue;
-};
-
-extern LIB3DSAPI Lib3dsBool lib3ds_atmosphere_read(Lib3dsAtmosphere *atmosphere, Lib3dsIo *io);
-extern LIB3DSAPI Lib3dsBool lib3ds_atmosphere_write(Lib3dsAtmosphere *atmosphere, Lib3dsIo *io);
-
-#ifdef __cplusplus
-}
-#endif
-#endif
+++ /dev/null
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: background.c,v 1.8 2001/07/07 19:05:30 jeh Exp $
- */
-#define LIB3DS_EXPORT
-#include <lib3ds/background.h>
-#include <lib3ds/chunk.h>
-#include <lib3ds/io.h>
-#include <string.h>
-#include <math.h>
-
-
-/*!
- * \defgroup background Background Settings
- *
- * \author J.E. Hoffmann <je-h@gmx.net>
- */
-
-
-static Lib3dsBool
-solid_bgnd_read(Lib3dsBackground *background, Lib3dsIo *io)
-{
- Lib3dsChunk c;
- Lib3dsWord chunk;
-
- if (!lib3ds_chunk_read_start(&c, LIB3DS_SOLID_BGND, io)) {
- return(LIB3DS_FALSE);
- }
-
- while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
- switch (chunk) {
- case LIB3DS_LIN_COLOR_F:
- lib3ds_io_read_rgb(io, background->solid.col);
- break;
- case LIB3DS_COLOR_F:
- lib3ds_io_read_rgb(io, background->solid.col);
- break;
- default:
- lib3ds_chunk_unknown(chunk);
- }
- }
-
- lib3ds_chunk_read_end(&c, io);
- return(LIB3DS_TRUE);
-}
-
-
-static Lib3dsBool
-v_gradient_read(Lib3dsBackground *background, Lib3dsIo *io)
-{
- Lib3dsChunk c;
- Lib3dsWord chunk;
- int index[2];
- Lib3dsRgb col[2][3];
- int have_lin=0;
-
-
- if (!lib3ds_chunk_read_start(&c, LIB3DS_V_GRADIENT, io)) {
- return(LIB3DS_FALSE);
- }
- background->gradient.percent=lib3ds_io_read_float(io);
- lib3ds_chunk_read_tell(&c, io);
-
- index[0]=index[1]=0;
- while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
- switch (chunk) {
- case LIB3DS_COLOR_F:
- lib3ds_io_read_rgb(io, col[0][index[0]]);
- index[0]++;
- break;
- case LIB3DS_LIN_COLOR_F:
- lib3ds_io_read_rgb(io, col[1][index[1]]);
- index[1]++;
- have_lin=1;
- break;
- default:
- lib3ds_chunk_unknown(chunk);
- }
- }
- {
- int i;
- for (i=0; i<3; ++i) {
- background->gradient.top[i]=col[have_lin][0][i];
- background->gradient.middle[i]=col[have_lin][1][i];
- background->gradient.bottom[i]=col[have_lin][2][i];
- }
- }
- lib3ds_chunk_read_end(&c, io);
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup background
- */
-Lib3dsBool
-lib3ds_background_read(Lib3dsBackground *background, Lib3dsIo *io)
-{
- Lib3dsChunk c;
-
- if (!lib3ds_chunk_read(&c, io)) {
- return(LIB3DS_FALSE);
- }
-
- switch (c.chunk) {
- case LIB3DS_BIT_MAP:
- {
- if (!lib3ds_io_read_string(io, background->bitmap.name, 64)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_SOLID_BGND:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!solid_bgnd_read(background, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_V_GRADIENT:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!v_gradient_read(background, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_USE_BIT_MAP:
- {
- background->bitmap.use=LIB3DS_TRUE;
- }
- break;
- case LIB3DS_USE_SOLID_BGND:
- {
- background->solid.use=LIB3DS_TRUE;
- }
- break;
- case LIB3DS_USE_V_GRADIENT:
- {
- background->gradient.use=LIB3DS_TRUE;
- }
- break;
- }
-
- return(LIB3DS_TRUE);
-}
-
-
-static Lib3dsBool
-colorf_write(Lib3dsRgba rgb, Lib3dsIo *io)
-{
- Lib3dsChunk c;
-
- c.chunk=LIB3DS_COLOR_F;
- c.size=18;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_rgb(io, rgb);
-
- c.chunk=LIB3DS_LIN_COLOR_F;
- c.size=18;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_rgb(io, rgb);
- return(LIB3DS_TRUE);
-}
-
-
-static Lib3dsBool
-colorf_defined(Lib3dsRgba rgb)
-{
- int i;
- for (i=0; i<3; ++i) {
- if (fabs(rgb[i])>LIB3DS_EPSILON) {
- break;
- }
- }
- return(i<3);
-}
-
-
-/*!
- * \ingroup background
- */
-Lib3dsBool
-lib3ds_background_write(Lib3dsBackground *background, Lib3dsIo *io)
-{
- if (strlen(background->bitmap.name)) { /*---- LIB3DS_BIT_MAP ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_BIT_MAP;
- c.size=6+1+strlen(background->bitmap.name);
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_string(io, background->bitmap.name);
- }
-
- if (colorf_defined(background->solid.col)) { /*---- LIB3DS_SOLID_BGND ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_SOLID_BGND;
- c.size=42;
- lib3ds_chunk_write(&c,io);
- colorf_write(background->solid.col, io);
- }
-
- if (colorf_defined(background->gradient.top) ||
- colorf_defined(background->gradient.middle) ||
- colorf_defined(background->gradient.bottom)) { /*---- LIB3DS_V_GRADIENT ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_V_GRADIENT;
- c.size=118;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_float(io, background->gradient.percent);
- colorf_write(background->gradient.top,io);
- colorf_write(background->gradient.middle,io);
- colorf_write(background->gradient.bottom,io);
- }
-
- if (background->bitmap.use) { /*---- LIB3DS_USE_BIT_MAP ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_USE_BIT_MAP;
- c.size=6;
- lib3ds_chunk_write(&c,io);
- }
-
- if (background->solid.use) { /*---- LIB3DS_USE_SOLID_BGND ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_USE_SOLID_BGND;
- c.size=6;
- lib3ds_chunk_write(&c,io);
- }
-
- if (background->gradient.use) { /*---- LIB3DS_USE_V_GRADIENT ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_USE_V_GRADIENT;
- c.size=6;
- lib3ds_chunk_write(&c,io);
- }
-
- return(LIB3DS_TRUE);
-}
-
-
-/*!
-
-\typedef Lib3dsBackground
- \ingroup background
- \sa _Lib3dsBackground
-
-*/
+++ /dev/null
-/* -*- c -*- */
-#ifndef INCLUDED_LIB3DS_BACKGROUND_H
-#define INCLUDED_LIB3DS_BACKGROUND_H
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: background.h,v 1.6 2004/12/31 16:17:15 reed Exp $
- */
-
-#ifndef INCLUDED_LIB3DS_TYPES_H
-#include <lib3ds/types.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*!
- * Bitmap background settings
- * \ingroup background
- */
-typedef struct _Lib3dsBitmap {
- Lib3dsBool use;
- char name[64];
-} Lib3dsBitmap;
-
-/*!
- * Solid color background settings
- * \ingroup background
- */
-typedef struct _Lib3dsSolid {
- Lib3dsBool use;
- Lib3dsRgb col;
-} Lib3dsSolid;
-
-/*!
- * Gradient background settings
- * \ingroup background
- */
-typedef struct _Lib3dsGradient {
- Lib3dsBool use;
- Lib3dsFloat percent;
- Lib3dsRgb top;
- Lib3dsRgb middle;
- Lib3dsRgb bottom;
-} Lib3dsGradient;
-
-/*!
- * Background settings
- * \ingroup background
- */
-struct _Lib3dsBackground {
- Lib3dsBitmap bitmap;
- Lib3dsSolid solid;
- Lib3dsGradient gradient;
-};
-
-extern LIB3DSAPI Lib3dsBool lib3ds_background_read(Lib3dsBackground *background, Lib3dsIo *io);
-extern LIB3DSAPI Lib3dsBool lib3ds_background_write(Lib3dsBackground *background, Lib3dsIo *io);
-
-#ifdef __cplusplus
-}
-#endif
-#endif
-
-
-
-
-
+++ /dev/null
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: camera.c,v 1.12 2004/11/16 07:41:44 efalk Exp $
- */
-#define LIB3DS_EXPORT
-#include <lib3ds/camera.h>
-#include <lib3ds/chunk.h>
-#include <lib3ds/io.h>
-#include <stdlib.h>
-#include <math.h>
-#include <string.h>
-#ifdef WITH_DMALLOC
-#include <dmalloc.h>
-#endif
-
-
-/*!
- * \defgroup camera Cameras
- *
- * \author J.E. Hoffmann <je-h@gmx.net>
- */
-
-
-/*!
- * Return a new Lib3dsCamera object.
- *
- * Object is initialized with the given name and fov=45. All other
- * values are 0.
- *
- * \param name Name of this camera. Must not be NULL. Must be < 64 characters.
- *
- * \return Lib3dsCamera object or NULL on failure.
- *
- * \ingroup camera
- */
-Lib3dsCamera*
-lib3ds_camera_new(const char *name)
-{
- Lib3dsCamera *camera;
-
- ASSERT(name);
- ASSERT(strlen(name)<64);
-
- camera=(Lib3dsCamera*)calloc(sizeof(Lib3dsCamera), 1);
- if (!camera) {
- return(0);
- }
- strcpy(camera->name, name);
- camera->fov=45.0f;
- return(camera);
-}
-
-
-/*!
- * Free a Lib3dsCamera object and all of its resources.
- *
- * \param camera Lib3dsCamera object to be freed.
- *
- * \ingroup camera
- */
-void
-lib3ds_camera_free(Lib3dsCamera *camera)
-{
- memset(camera, 0, sizeof(Lib3dsCamera));
- free(camera);
-}
-
-
-/*!
- * Dump information about a Lib3dsCamera object to stdout.
- *
- * \param camera Object to be dumped.
- *
- * \see lib3ds_file_dump_cameras
- *
- * \ingroup camera
- */
-void
-lib3ds_camera_dump(Lib3dsCamera *camera)
-{
- ASSERT(camera);
- printf(" name: %s\n", camera->name);
- printf(" position: (%f, %f, %f)\n",
- camera->position[0], camera->position[1], camera->position[2]);
- printf(" target (%f, %f, %f)\n",
- camera->target[0], camera->target[1], camera->target[2]);
- printf(" roll: %f\n", camera->roll);
- printf(" fov: %f\n", camera->fov);
- printf(" see_cone: %s\n", camera->see_cone ? "yes" : "no");
- printf(" near_range: %f\n", camera->near_range);
- printf(" far_range: %f\n", camera->far_range);
- printf("\n");
-}
-
-
-/*!
- * Read a camera definition from a file.
- *
- * This function is called by lib3ds_file_read(), and you probably
- * don't want to call it directly.
- *
- * \param camera A Lib3dsCamera to be filled in.
- * \param io A Lib3dsIo object previously set up by the caller.
- *
- * \return LIB3DS_TRUE on success, LIB3DS_FALSE on failure.
- *
- * \see lib3ds_file_read
- *
- * \ingroup camera
- */
-Lib3dsBool
-lib3ds_camera_read(Lib3dsCamera *camera, Lib3dsIo *io)
-{
- Lib3dsChunk c;
- Lib3dsWord chunk;
-
- if (!lib3ds_chunk_read_start(&c, LIB3DS_N_CAMERA, io)) {
- return(LIB3DS_FALSE);
- }
- {
- int i;
- for (i=0; i<3; ++i) {
- camera->position[i]=lib3ds_io_read_float(io);
- }
- for (i=0; i<3; ++i) {
- camera->target[i]=lib3ds_io_read_float(io);
- }
- }
- camera->roll=lib3ds_io_read_float(io);
- {
- float s;
- s=lib3ds_io_read_float(io);
- if (fabs(s)<LIB3DS_EPSILON) {
- camera->fov=45.0;
- }
- else {
- camera->fov=2400.0f/s;
- }
- }
- lib3ds_chunk_read_tell(&c, io);
-
- while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
- switch (chunk) {
- case LIB3DS_CAM_SEE_CONE:
- {
- camera->see_cone=LIB3DS_TRUE;
- }
- break;
- case LIB3DS_CAM_RANGES:
- {
- camera->near_range=lib3ds_io_read_float(io);
- camera->far_range=lib3ds_io_read_float(io);
- }
- break;
- default:
- lib3ds_chunk_unknown(chunk);
- }
- }
-
- lib3ds_chunk_read_end(&c, io);
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * Write a camera definition to a file.
- *
- * This function is called by lib3ds_file_write(), and you probably
- * don't want to call it directly.
- *
- * \param camera A Lib3dsCamera to be written.
- * \param io A Lib3dsIo object previously set up by the caller.
- *
- * \return LIB3DS_TRUE on success, LIB3DS_FALSE on failure.
- *
- * \see lib3ds_file_write
- *
- * \ingroup camera
- */
-Lib3dsBool
-lib3ds_camera_write(Lib3dsCamera *camera, Lib3dsIo *io)
-{
- Lib3dsChunk c;
-
- c.chunk=LIB3DS_N_CAMERA;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
-
- lib3ds_io_write_vector(io, camera->position);
- lib3ds_io_write_vector(io, camera->target);
- lib3ds_io_write_float(io, camera->roll);
- if (fabs(camera->fov)<LIB3DS_EPSILON) {
- lib3ds_io_write_float(io, 2400.0f/45.0f);
- }
- else {
- lib3ds_io_write_float(io, 2400.0f/camera->fov);
- }
-
- if (camera->see_cone) {
- Lib3dsChunk c;
- c.chunk=LIB3DS_CAM_SEE_CONE;
- c.size=6;
- lib3ds_chunk_write(&c, io);
- }
- {
- Lib3dsChunk c;
- c.chunk=LIB3DS_CAM_RANGES;
- c.size=14;
- lib3ds_chunk_write(&c, io);
- lib3ds_io_write_float(io, camera->near_range);
- lib3ds_io_write_float(io, camera->far_range);
- }
-
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
-
-\typedef Lib3dsCamera
- \ingroup camera
- \sa _Lib3dsCamera
-
-*/
+++ /dev/null
-/* -*- c -*- */
-#ifndef INCLUDED_LIB3DS_CAMERA_H
-#define INCLUDED_LIB3DS_CAMERA_H
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: camera.h,v 1.8 2004/12/31 16:17:15 reed Exp $
- */
-
-#ifndef INCLUDED_LIB3DS_TYPES_H
-#include <lib3ds/types.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*!
- * Camera object
- * \ingroup camera
- */
-struct _Lib3dsCamera {
- Lib3dsCamera *next;
- char name[64];
- Lib3dsVector position;
- Lib3dsVector target;
- Lib3dsFloat roll;
- Lib3dsFloat fov;
- Lib3dsBool see_cone;
- Lib3dsFloat near_range;
- Lib3dsFloat far_range;
-};
-
-extern LIB3DSAPI Lib3dsCamera* lib3ds_camera_new(const char *name);
-extern LIB3DSAPI void lib3ds_camera_free(Lib3dsCamera *mesh);
-extern LIB3DSAPI void lib3ds_camera_dump(Lib3dsCamera *camera);
-extern LIB3DSAPI Lib3dsBool lib3ds_camera_read(Lib3dsCamera *camera, Lib3dsIo *io);
-extern LIB3DSAPI Lib3dsBool lib3ds_camera_write(Lib3dsCamera *camera, Lib3dsIo *io);
-
-#ifdef __cplusplus
-}
-#endif
-#endif
-
+++ /dev/null
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: chunk.c,v 1.14 2001/07/07 19:05:30 jeh Exp $
- */
-#define LIB3DS_EXPORT
-#include <lib3ds/chunk.h>
-#include <lib3ds/io.h>
-#include <lib3ds/chunktable.h>
-#include <string.h>
-#include <stdarg.h>
-
-
-/*#define LIB3DS_CHUNK_DEBUG*/
-/*#define LIB3DS_CHUNK_WARNING*/
-
-
-/*!
- * \defgroup chunk Chunk Handling
- *
- * \author J.E. Hoffmann <je-h@gmx.net>
- */
-
-
-static Lib3dsBool enable_dump=LIB3DS_FALSE;
-static Lib3dsBool enable_unknown=LIB3DS_FALSE;
-static char lib3ds_chunk_level[128]="";
-
-
-static void
-lib3ds_chunk_debug_enter(Lib3dsChunk *c)
-{
- strcat(lib3ds_chunk_level, " ");
-}
-
-
-static void
-lib3ds_chunk_debug_leave(Lib3dsChunk *c)
-{
- lib3ds_chunk_level[strlen(lib3ds_chunk_level)-2]=0;
-}
-
-
-static void
-lib3ds_chunk_debug_dump(Lib3dsChunk *c)
-{
- if (enable_dump) {
- printf("%s%s (0x%X) size=%lu\n",
- lib3ds_chunk_level,
- lib3ds_chunk_name(c->chunk),
- c->chunk,
- c->size
- );
- }
-}
-
-
-/*!
- * \ingroup chunk
- */
-void
-lib3ds_chunk_enable_dump(Lib3dsBool enable, Lib3dsBool unknown)
-{
- enable_dump=enable;
- enable_unknown=unknown;
-}
-
-
-/*!
- * \ingroup chunk
- *
- * Reads a 3d-Studio chunk header from a little endian file stream.
- *
- * \param c The chunk to store the data.
- * \param f The file stream.
- *
- * \return True on success, False otherwise.
- */
-Lib3dsBool
-lib3ds_chunk_read(Lib3dsChunk *c, Lib3dsIo *io)
-{
- ASSERT(c);
- ASSERT(io);
- c->cur=lib3ds_io_tell(io);
- c->chunk=lib3ds_io_read_word(io);
- c->size=lib3ds_io_read_dword(io);
- c->end=c->cur+c->size;
- c->cur+=6;
- if (lib3ds_io_error(io) || (c->size<6)) {
- return(LIB3DS_FALSE);
- }
- return(LIB3DS_TRUE);
-
-}
-
-
-/*!
- * \ingroup chunk
- */
-Lib3dsBool
-lib3ds_chunk_read_start(Lib3dsChunk *c, Lib3dsWord chunk, Lib3dsIo *io)
-{
- ASSERT(c);
- ASSERT(io);
- if (!lib3ds_chunk_read(c, io)) {
- return(LIB3DS_FALSE);
- }
- lib3ds_chunk_debug_enter(c);
- return((chunk==0) || (c->chunk==chunk));
-}
-
-
-/*!
- * \ingroup chunk
- */
-void
-lib3ds_chunk_read_tell(Lib3dsChunk *c, Lib3dsIo *io)
-{
- c->cur=lib3ds_io_tell(io);
-}
-
-
-/*!
- * \ingroup chunk
- */
-Lib3dsWord
-lib3ds_chunk_read_next(Lib3dsChunk *c, Lib3dsIo *io)
-{
- Lib3dsChunk d;
-
- if (c->cur>=c->end) {
- ASSERT(c->cur==c->end);
- return(0);
- }
-
- lib3ds_io_seek(io, (long)c->cur, LIB3DS_SEEK_SET);
- d.chunk=lib3ds_io_read_word(io);
- d.size=lib3ds_io_read_dword(io);
- lib3ds_chunk_debug_dump(&d);
- c->cur+=d.size;
- return(d.chunk);
-}
-
-
-/*!
- * \ingroup chunk
- */
-void
-lib3ds_chunk_read_reset(Lib3dsChunk *c, Lib3dsIo *io)
-{
- lib3ds_io_seek(io, -6, LIB3DS_SEEK_CUR);
-}
-
-
-/*!
- * \ingroup chunk
- */
-void
-lib3ds_chunk_read_end(Lib3dsChunk *c, Lib3dsIo *io)
-{
- lib3ds_chunk_debug_leave(c);
- lib3ds_io_seek(io, c->end, LIB3DS_SEEK_SET);
-}
-
-
-/*!
- * \ingroup chunk
- *
- * Writes a 3d-Studio chunk header into a little endian file stream.
- *
- * \param c The chunk to be written.
- * \param f The file stream.
- *
- * \return True on success, False otherwise.
- */
-Lib3dsBool
-lib3ds_chunk_write(Lib3dsChunk *c, Lib3dsIo *io)
-{
- ASSERT(c);
- if (!lib3ds_io_write_word(io, c->chunk)) {
- LIB3DS_ERROR_LOG;
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_io_write_dword(io, c->size)) {
- LIB3DS_ERROR_LOG;
- return(LIB3DS_FALSE);
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup chunk
- */
-Lib3dsBool
-lib3ds_chunk_write_start(Lib3dsChunk *c, Lib3dsIo *io)
-{
- ASSERT(c);
- c->size=0;
- c->cur=lib3ds_io_tell(io);
- if (!lib3ds_io_write_word(io, c->chunk)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_io_write_dword(io, c->size)) {
- return(LIB3DS_FALSE);
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup chunk
- */
-Lib3dsBool
-lib3ds_chunk_write_end(Lib3dsChunk *c, Lib3dsIo *io)
-{
- ASSERT(c);
- c->size=lib3ds_io_tell(io) - c->cur;
- lib3ds_io_seek(io, c->cur+2, LIB3DS_SEEK_SET);
- if (!lib3ds_io_write_dword(io, c->size)) {
- LIB3DS_ERROR_LOG;
- return(LIB3DS_FALSE);
- }
-
- c->cur+=c->size;
- lib3ds_io_seek(io, c->cur, LIB3DS_SEEK_SET);
- if (lib3ds_io_error(io)) {
- LIB3DS_ERROR_LOG;
- return(LIB3DS_FALSE);
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup chunk
- */
-const char*
-lib3ds_chunk_name(Lib3dsWord chunk)
-{
- Lib3dsChunkTable *p;
-
- for (p=lib3ds_chunk_table; p->name!=0; ++p) {
- if (p->chunk==chunk) {
- return(p->name);
- }
- }
- return("***UNKNOWN***");
-}
-
-
-/*!
- * \ingroup chunk
- */
-void
-lib3ds_chunk_unknown(Lib3dsWord chunk)
-{
- if (enable_unknown) {
- printf("%s***WARNING*** Unknown Chunk: %s (0x%X)\n",
- lib3ds_chunk_level,
- lib3ds_chunk_name(chunk),
- chunk
- );
- }
-}
-
-
-/*!
- * \ingroup chunk
- */
-void
-lib3ds_chunk_dump_info(const char *format, ...)
-{
- if (enable_dump) {
- char s[1024];
- va_list marker;
-
- va_start(marker, format);
- vsprintf(s, format, marker);
- va_end(marker);
-
- printf("%s%s\n", lib3ds_chunk_level, s);
- }
-}
-
-
-
-
-
-
-
+++ /dev/null
-/* -*- c -*- */
-#ifndef INCLUDED_LIB3DS_CHUNK_H
-#define INCLUDED_LIB3DS_CHUNK_H
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: chunk.h,v 1.13 2004/12/31 16:17:15 reed Exp $
- */
-
-#ifndef INCLUDED_LIB3DS_TYPES_H
-#include <lib3ds/types.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef enum _Lib3dsChunks {
- LIB3DS_NULL_CHUNK =0x0000,
- LIB3DS_M3DMAGIC =0x4D4D, /*3DS file*/
- LIB3DS_SMAGIC =0x2D2D,
- LIB3DS_LMAGIC =0x2D3D,
- LIB3DS_MLIBMAGIC =0x3DAA, /*MLI file*/
- LIB3DS_MATMAGIC =0x3DFF,
- LIB3DS_CMAGIC =0xC23D, /*PRJ file*/
- LIB3DS_M3D_VERSION =0x0002,
- LIB3DS_M3D_KFVERSION =0x0005,
-
- LIB3DS_COLOR_F =0x0010,
- LIB3DS_COLOR_24 =0x0011,
- LIB3DS_LIN_COLOR_24 =0x0012,
- LIB3DS_LIN_COLOR_F =0x0013,
- LIB3DS_INT_PERCENTAGE =0x0030,
- LIB3DS_FLOAT_PERCENTAGE =0x0031,
-
- LIB3DS_MDATA =0x3D3D,
- LIB3DS_MESH_VERSION =0x3D3E,
- LIB3DS_MASTER_SCALE =0x0100,
- LIB3DS_LO_SHADOW_BIAS =0x1400,
- LIB3DS_HI_SHADOW_BIAS =0x1410,
- LIB3DS_SHADOW_MAP_SIZE =0x1420,
- LIB3DS_SHADOW_SAMPLES =0x1430,
- LIB3DS_SHADOW_RANGE =0x1440,
- LIB3DS_SHADOW_FILTER =0x1450,
- LIB3DS_RAY_BIAS =0x1460,
- LIB3DS_O_CONSTS =0x1500,
- LIB3DS_AMBIENT_LIGHT =0x2100,
- LIB3DS_BIT_MAP =0x1100,
- LIB3DS_SOLID_BGND =0x1200,
- LIB3DS_V_GRADIENT =0x1300,
- LIB3DS_USE_BIT_MAP =0x1101,
- LIB3DS_USE_SOLID_BGND =0x1201,
- LIB3DS_USE_V_GRADIENT =0x1301,
- LIB3DS_FOG =0x2200,
- LIB3DS_FOG_BGND =0x2210,
- LIB3DS_LAYER_FOG =0x2302,
- LIB3DS_DISTANCE_CUE =0x2300,
- LIB3DS_DCUE_BGND =0x2310,
- LIB3DS_USE_FOG =0x2201,
- LIB3DS_USE_LAYER_FOG =0x2303,
- LIB3DS_USE_DISTANCE_CUE =0x2301,
-
- LIB3DS_MAT_ENTRY =0xAFFF,
- LIB3DS_MAT_NAME =0xA000,
- LIB3DS_MAT_AMBIENT =0xA010,
- LIB3DS_MAT_DIFFUSE =0xA020,
- LIB3DS_MAT_SPECULAR =0xA030,
- LIB3DS_MAT_SHININESS =0xA040,
- LIB3DS_MAT_SHIN2PCT =0xA041,
- LIB3DS_MAT_TRANSPARENCY =0xA050,
- LIB3DS_MAT_XPFALL =0xA052,
- LIB3DS_MAT_USE_XPFALL =0xA240,
- LIB3DS_MAT_REFBLUR =0xA053,
- LIB3DS_MAT_SHADING =0xA100,
- LIB3DS_MAT_USE_REFBLUR =0xA250,
- LIB3DS_MAT_SELF_ILLUM =0xA080,
- LIB3DS_MAT_TWO_SIDE =0xA081,
- LIB3DS_MAT_DECAL =0xA082,
- LIB3DS_MAT_ADDITIVE =0xA083,
- LIB3DS_MAT_SELF_ILPCT =0xA084,
- LIB3DS_MAT_WIRE =0xA085,
- LIB3DS_MAT_FACEMAP =0xA088,
- LIB3DS_MAT_PHONGSOFT =0xA08C,
- LIB3DS_MAT_WIREABS =0xA08E,
- LIB3DS_MAT_WIRE_SIZE =0xA087,
- LIB3DS_MAT_TEXMAP =0xA200,
- LIB3DS_MAT_SXP_TEXT_DATA =0xA320,
- LIB3DS_MAT_TEXMASK =0xA33E,
- LIB3DS_MAT_SXP_TEXTMASK_DATA =0xA32A,
- LIB3DS_MAT_TEX2MAP =0xA33A,
- LIB3DS_MAT_SXP_TEXT2_DATA =0xA321,
- LIB3DS_MAT_TEX2MASK =0xA340,
- LIB3DS_MAT_SXP_TEXT2MASK_DATA =0xA32C,
- LIB3DS_MAT_OPACMAP =0xA210,
- LIB3DS_MAT_SXP_OPAC_DATA =0xA322,
- LIB3DS_MAT_OPACMASK =0xA342,
- LIB3DS_MAT_SXP_OPACMASK_DATA =0xA32E,
- LIB3DS_MAT_BUMPMAP =0xA230,
- LIB3DS_MAT_SXP_BUMP_DATA =0xA324,
- LIB3DS_MAT_BUMPMASK =0xA344,
- LIB3DS_MAT_SXP_BUMPMASK_DATA =0xA330,
- LIB3DS_MAT_SPECMAP =0xA204,
- LIB3DS_MAT_SXP_SPEC_DATA =0xA325,
- LIB3DS_MAT_SPECMASK =0xA348,
- LIB3DS_MAT_SXP_SPECMASK_DATA =0xA332,
- LIB3DS_MAT_SHINMAP =0xA33C,
- LIB3DS_MAT_SXP_SHIN_DATA =0xA326,
- LIB3DS_MAT_SHINMASK =0xA346,
- LIB3DS_MAT_SXP_SHINMASK_DATA =0xA334,
- LIB3DS_MAT_SELFIMAP =0xA33D,
- LIB3DS_MAT_SXP_SELFI_DATA =0xA328,
- LIB3DS_MAT_SELFIMASK =0xA34A,
- LIB3DS_MAT_SXP_SELFIMASK_DATA =0xA336,
- LIB3DS_MAT_REFLMAP =0xA220,
- LIB3DS_MAT_REFLMASK =0xA34C,
- LIB3DS_MAT_SXP_REFLMASK_DATA =0xA338,
- LIB3DS_MAT_ACUBIC =0xA310,
- LIB3DS_MAT_MAPNAME =0xA300,
- LIB3DS_MAT_MAP_TILING =0xA351,
- LIB3DS_MAT_MAP_TEXBLUR =0xA353,
- LIB3DS_MAT_MAP_USCALE =0xA354,
- LIB3DS_MAT_MAP_VSCALE =0xA356,
- LIB3DS_MAT_MAP_UOFFSET =0xA358,
- LIB3DS_MAT_MAP_VOFFSET =0xA35A,
- LIB3DS_MAT_MAP_ANG =0xA35C,
- LIB3DS_MAT_MAP_COL1 =0xA360,
- LIB3DS_MAT_MAP_COL2 =0xA362,
- LIB3DS_MAT_MAP_RCOL =0xA364,
- LIB3DS_MAT_MAP_GCOL =0xA366,
- LIB3DS_MAT_MAP_BCOL =0xA368,
-
- LIB3DS_NAMED_OBJECT =0x4000,
- LIB3DS_N_DIRECT_LIGHT =0x4600,
- LIB3DS_DL_OFF =0x4620,
- LIB3DS_DL_OUTER_RANGE =0x465A,
- LIB3DS_DL_INNER_RANGE =0x4659,
- LIB3DS_DL_MULTIPLIER =0x465B,
- LIB3DS_DL_EXCLUDE =0x4654,
- LIB3DS_DL_ATTENUATE =0x4625,
- LIB3DS_DL_SPOTLIGHT =0x4610,
- LIB3DS_DL_SPOT_ROLL =0x4656,
- LIB3DS_DL_SHADOWED =0x4630,
- LIB3DS_DL_LOCAL_SHADOW2 =0x4641,
- LIB3DS_DL_SEE_CONE =0x4650,
- LIB3DS_DL_SPOT_RECTANGULAR =0x4651,
- LIB3DS_DL_SPOT_ASPECT =0x4657,
- LIB3DS_DL_SPOT_PROJECTOR =0x4653,
- LIB3DS_DL_SPOT_OVERSHOOT =0x4652,
- LIB3DS_DL_RAY_BIAS =0x4658,
- LIB3DS_DL_RAYSHAD =0x4627,
- LIB3DS_N_CAMERA =0x4700,
- LIB3DS_CAM_SEE_CONE =0x4710,
- LIB3DS_CAM_RANGES =0x4720,
- LIB3DS_OBJ_HIDDEN =0x4010,
- LIB3DS_OBJ_VIS_LOFTER =0x4011,
- LIB3DS_OBJ_DOESNT_CAST =0x4012,
- LIB3DS_OBJ_DONT_RECVSHADOW =0x4017,
- LIB3DS_OBJ_MATTE =0x4013,
- LIB3DS_OBJ_FAST =0x4014,
- LIB3DS_OBJ_PROCEDURAL =0x4015,
- LIB3DS_OBJ_FROZEN =0x4016,
- LIB3DS_N_TRI_OBJECT =0x4100,
- LIB3DS_POINT_ARRAY =0x4110,
- LIB3DS_POINT_FLAG_ARRAY =0x4111,
- LIB3DS_FACE_ARRAY =0x4120,
- LIB3DS_MSH_MAT_GROUP =0x4130,
- LIB3DS_SMOOTH_GROUP =0x4150,
- LIB3DS_MSH_BOXMAP =0x4190,
- LIB3DS_TEX_VERTS =0x4140,
- LIB3DS_MESH_MATRIX =0x4160,
- LIB3DS_MESH_COLOR =0x4165,
- LIB3DS_MESH_TEXTURE_INFO =0x4170,
-
- LIB3DS_KFDATA =0xB000,
- LIB3DS_KFHDR =0xB00A,
- LIB3DS_KFSEG =0xB008,
- LIB3DS_KFCURTIME =0xB009,
- LIB3DS_AMBIENT_NODE_TAG =0xB001,
- LIB3DS_OBJECT_NODE_TAG =0xB002,
- LIB3DS_CAMERA_NODE_TAG =0xB003,
- LIB3DS_TARGET_NODE_TAG =0xB004,
- LIB3DS_LIGHT_NODE_TAG =0xB005,
- LIB3DS_L_TARGET_NODE_TAG =0xB006,
- LIB3DS_SPOTLIGHT_NODE_TAG =0xB007,
- LIB3DS_NODE_ID =0xB030,
- LIB3DS_NODE_HDR =0xB010,
- LIB3DS_PIVOT =0xB013,
- LIB3DS_INSTANCE_NAME =0xB011,
- LIB3DS_MORPH_SMOOTH =0xB015,
- LIB3DS_BOUNDBOX =0xB014,
- LIB3DS_POS_TRACK_TAG =0xB020,
- LIB3DS_COL_TRACK_TAG =0xB025,
- LIB3DS_ROT_TRACK_TAG =0xB021,
- LIB3DS_SCL_TRACK_TAG =0xB022,
- LIB3DS_MORPH_TRACK_TAG =0xB026,
- LIB3DS_FOV_TRACK_TAG =0xB023,
- LIB3DS_ROLL_TRACK_TAG =0xB024,
- LIB3DS_HOT_TRACK_TAG =0xB027,
- LIB3DS_FALL_TRACK_TAG =0xB028,
- LIB3DS_HIDE_TRACK_TAG =0xB029,
-
- LIB3DS_POLY_2D = 0x5000,
- LIB3DS_SHAPE_OK = 0x5010,
- LIB3DS_SHAPE_NOT_OK = 0x5011,
- LIB3DS_SHAPE_HOOK = 0x5020,
- LIB3DS_PATH_3D = 0x6000,
- LIB3DS_PATH_MATRIX = 0x6005,
- LIB3DS_SHAPE_2D = 0x6010,
- LIB3DS_M_SCALE = 0x6020,
- LIB3DS_M_TWIST = 0x6030,
- LIB3DS_M_TEETER = 0x6040,
- LIB3DS_M_FIT = 0x6050,
- LIB3DS_M_BEVEL = 0x6060,
- LIB3DS_XZ_CURVE = 0x6070,
- LIB3DS_YZ_CURVE = 0x6080,
- LIB3DS_INTERPCT = 0x6090,
- LIB3DS_DEFORM_LIMIT = 0x60A0,
-
- LIB3DS_USE_CONTOUR = 0x6100,
- LIB3DS_USE_TWEEN = 0x6110,
- LIB3DS_USE_SCALE = 0x6120,
- LIB3DS_USE_TWIST = 0x6130,
- LIB3DS_USE_TEETER = 0x6140,
- LIB3DS_USE_FIT = 0x6150,
- LIB3DS_USE_BEVEL = 0x6160,
-
- LIB3DS_DEFAULT_VIEW = 0x3000,
- LIB3DS_VIEW_TOP = 0x3010,
- LIB3DS_VIEW_BOTTOM = 0x3020,
- LIB3DS_VIEW_LEFT = 0x3030,
- LIB3DS_VIEW_RIGHT = 0x3040,
- LIB3DS_VIEW_FRONT = 0x3050,
- LIB3DS_VIEW_BACK = 0x3060,
- LIB3DS_VIEW_USER = 0x3070,
- LIB3DS_VIEW_CAMERA = 0x3080,
- LIB3DS_VIEW_WINDOW = 0x3090,
-
- LIB3DS_VIEWPORT_LAYOUT_OLD = 0x7000,
- LIB3DS_VIEWPORT_DATA_OLD = 0x7010,
- LIB3DS_VIEWPORT_LAYOUT = 0x7001,
- LIB3DS_VIEWPORT_DATA = 0x7011,
- LIB3DS_VIEWPORT_DATA_3 = 0x7012,
- LIB3DS_VIEWPORT_SIZE = 0x7020,
- LIB3DS_NETWORK_VIEW = 0x7030
-} Lib3dsChunks;
-
-typedef struct _Lib3dsChunk {
- Lib3dsWord chunk;
- Lib3dsDword size;
- Lib3dsDword end;
- Lib3dsDword cur;
-} Lib3dsChunk;
-
-extern LIB3DSAPI void lib3ds_chunk_enable_dump(Lib3dsBool enable, Lib3dsBool unknown);
-extern LIB3DSAPI Lib3dsBool lib3ds_chunk_read(Lib3dsChunk *c, Lib3dsIo *io);
-extern LIB3DSAPI Lib3dsBool lib3ds_chunk_read_start(Lib3dsChunk *c, Lib3dsWord chunk, Lib3dsIo *io);
-extern LIB3DSAPI void lib3ds_chunk_read_tell(Lib3dsChunk *c, Lib3dsIo *io);
-extern LIB3DSAPI Lib3dsWord lib3ds_chunk_read_next(Lib3dsChunk *c, Lib3dsIo *io);
-extern LIB3DSAPI void lib3ds_chunk_read_reset(Lib3dsChunk *c, Lib3dsIo *io);
-extern LIB3DSAPI void lib3ds_chunk_read_end(Lib3dsChunk *c, Lib3dsIo *io);
-extern LIB3DSAPI Lib3dsBool lib3ds_chunk_write(Lib3dsChunk *c, Lib3dsIo *io);
-extern LIB3DSAPI Lib3dsBool lib3ds_chunk_write_start(Lib3dsChunk *c, Lib3dsIo *io);
-extern LIB3DSAPI Lib3dsBool lib3ds_chunk_write_end(Lib3dsChunk *c, Lib3dsIo *io);
-extern LIB3DSAPI const char* lib3ds_chunk_name(Lib3dsWord chunk);
-extern LIB3DSAPI void lib3ds_chunk_unknown(Lib3dsWord chunk);
-extern LIB3DSAPI void lib3ds_chunk_dump_info(const char *format, ...);
-
-#ifdef __cplusplus
-}
-#endif
-#endif
-
-
+++ /dev/null
-/* -*- c -*- */
-#ifndef INCLUDED_LIB3DS_CHUNKTABLE_H
-#define INCLUDED_LIB3DS_CHUNKTABLE_H
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: chunktable.h,v 1.13 2004/12/31 16:17:15 reed Exp $
- */
-
-#ifndef INCLUDED_LIB3DS_CHUNK_H
-#include <lib3ds/chunk.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct _Lib3dsChunkTable {
- Lib3dsDword chunk;
- const char* name;
-} Lib3dsChunkTable;
-
-static Lib3dsChunkTable lib3ds_chunk_table[]={
- {LIB3DS_NULL_CHUNK, "LIB3DS_NULL_CHUNK"},
- {LIB3DS_M3DMAGIC, "LIB3DS_M3DMAGIC"},
- {LIB3DS_SMAGIC, "LIB3DS_SMAGIC"},
- {LIB3DS_LMAGIC, "LIB3DS_LMAGIC"},
- {LIB3DS_MLIBMAGIC, "LIB3DS_MLIBMAGIC"},
- {LIB3DS_MATMAGIC, "LIB3DS_MATMAGIC"},
- {LIB3DS_CMAGIC, "LIB3DS_CMAGIC"},
- {LIB3DS_M3D_VERSION, "LIB3DS_M3D_VERSION"},
- {LIB3DS_M3D_KFVERSION, "LIB3DS_M3D_KFVERSION"},
- {LIB3DS_COLOR_F, "LIB3DS_COLOR_F"},
- {LIB3DS_COLOR_24, "LIB3DS_COLOR_24"},
- {LIB3DS_LIN_COLOR_24, "LIB3DS_LIN_COLOR_24"},
- {LIB3DS_LIN_COLOR_F, "LIB3DS_LIN_COLOR_F"},
- {LIB3DS_INT_PERCENTAGE, "LIB3DS_INT_PERCENTAGE"},
- {LIB3DS_FLOAT_PERCENTAGE, "LIB3DS_FLOAT_PERCENTAGE"},
- {LIB3DS_MDATA, "LIB3DS_MDATA"},
- {LIB3DS_MESH_VERSION, "LIB3DS_MESH_VERSION"},
- {LIB3DS_MASTER_SCALE, "LIB3DS_MASTER_SCALE"},
- {LIB3DS_LO_SHADOW_BIAS, "LIB3DS_LO_SHADOW_BIAS"},
- {LIB3DS_HI_SHADOW_BIAS, "LIB3DS_HI_SHADOW_BIAS"},
- {LIB3DS_SHADOW_MAP_SIZE, "LIB3DS_SHADOW_MAP_SIZE"},
- {LIB3DS_SHADOW_SAMPLES, "LIB3DS_SHADOW_SAMPLES"},
- {LIB3DS_SHADOW_RANGE, "LIB3DS_SHADOW_RANGE"},
- {LIB3DS_SHADOW_FILTER, "LIB3DS_SHADOW_FILTER"},
- {LIB3DS_RAY_BIAS, "LIB3DS_RAY_BIAS"},
- {LIB3DS_O_CONSTS, "LIB3DS_O_CONSTS"},
- {LIB3DS_AMBIENT_LIGHT, "LIB3DS_AMBIENT_LIGHT"},
- {LIB3DS_BIT_MAP, "LIB3DS_BIT_MAP"},
- {LIB3DS_SOLID_BGND, "LIB3DS_SOLID_BGND"},
- {LIB3DS_V_GRADIENT, "LIB3DS_V_GRADIENT"},
- {LIB3DS_USE_BIT_MAP, "LIB3DS_USE_BIT_MAP"},
- {LIB3DS_USE_SOLID_BGND, "LIB3DS_USE_SOLID_BGND"},
- {LIB3DS_USE_V_GRADIENT, "LIB3DS_USE_V_GRADIENT"},
- {LIB3DS_FOG, "LIB3DS_FOG"},
- {LIB3DS_FOG_BGND, "LIB3DS_FOG_BGND"},
- {LIB3DS_LAYER_FOG, "LIB3DS_LAYER_FOG"},
- {LIB3DS_DISTANCE_CUE, "LIB3DS_DISTANCE_CUE"},
- {LIB3DS_DCUE_BGND, "LIB3DS_DCUE_BGND"},
- {LIB3DS_USE_FOG, "LIB3DS_USE_FOG"},
- {LIB3DS_USE_LAYER_FOG, "LIB3DS_USE_LAYER_FOG"},
- {LIB3DS_USE_DISTANCE_CUE, "LIB3DS_USE_DISTANCE_CUE"},
- {LIB3DS_MAT_ENTRY, "LIB3DS_MAT_ENTRY"},
- {LIB3DS_MAT_NAME, "LIB3DS_MAT_NAME"},
- {LIB3DS_MAT_AMBIENT, "LIB3DS_MAT_AMBIENT"},
- {LIB3DS_MAT_DIFFUSE, "LIB3DS_MAT_DIFFUSE"},
- {LIB3DS_MAT_SPECULAR, "LIB3DS_MAT_SPECULAR"},
- {LIB3DS_MAT_SHININESS, "LIB3DS_MAT_SHININESS"},
- {LIB3DS_MAT_SHIN2PCT, "LIB3DS_MAT_SHIN2PCT"},
- {LIB3DS_MAT_TRANSPARENCY, "LIB3DS_MAT_TRANSPARENCY"},
- {LIB3DS_MAT_XPFALL, "LIB3DS_MAT_XPFALL"},
- {LIB3DS_MAT_USE_XPFALL, "LIB3DS_MAT_USE_XPFALL"},
- {LIB3DS_MAT_REFBLUR, "LIB3DS_MAT_REFBLUR"},
- {LIB3DS_MAT_SHADING, "LIB3DS_MAT_SHADING"},
- {LIB3DS_MAT_USE_REFBLUR, "LIB3DS_MAT_USE_REFBLUR"},
- {LIB3DS_MAT_SELF_ILLUM, "LIB3DS_MAT_SELF_ILLUM"},
- {LIB3DS_MAT_TWO_SIDE, "LIB3DS_MAT_TWO_SIDE"},
- {LIB3DS_MAT_DECAL, "LIB3DS_MAT_DECAL"},
- {LIB3DS_MAT_ADDITIVE, "LIB3DS_MAT_ADDITIVE"},
- {LIB3DS_MAT_SELF_ILPCT, "LIB3DS_MAT_SELF_ILPCT"},
- {LIB3DS_MAT_WIRE, "LIB3DS_MAT_WIRE"},
- {LIB3DS_MAT_FACEMAP, "LIB3DS_MAT_FACEMAP"},
- {LIB3DS_MAT_PHONGSOFT, "LIB3DS_MAT_PHONGSOFT"},
- {LIB3DS_MAT_WIREABS, "LIB3DS_MAT_WIREABS"},
- {LIB3DS_MAT_WIRE_SIZE, "LIB3DS_MAT_WIRE_SIZE"},
- {LIB3DS_MAT_TEXMAP, "LIB3DS_MAT_TEXMAP"},
- {LIB3DS_MAT_SXP_TEXT_DATA, "LIB3DS_MAT_SXP_TEXT_DATA"},
- {LIB3DS_MAT_TEXMASK, "LIB3DS_MAT_TEXMASK"},
- {LIB3DS_MAT_SXP_TEXTMASK_DATA, "LIB3DS_MAT_SXP_TEXTMASK_DATA"},
- {LIB3DS_MAT_TEX2MAP, "LIB3DS_MAT_TEX2MAP"},
- {LIB3DS_MAT_SXP_TEXT2_DATA, "LIB3DS_MAT_SXP_TEXT2_DATA"},
- {LIB3DS_MAT_TEX2MASK, "LIB3DS_MAT_TEX2MASK"},
- {LIB3DS_MAT_SXP_TEXT2MASK_DATA, "LIB3DS_MAT_SXP_TEXT2MASK_DATA"},
- {LIB3DS_MAT_OPACMAP, "LIB3DS_MAT_OPACMAP"},
- {LIB3DS_MAT_SXP_OPAC_DATA, "LIB3DS_MAT_SXP_OPAC_DATA"},
- {LIB3DS_MAT_OPACMASK, "LIB3DS_MAT_OPACMASK"},
- {LIB3DS_MAT_SXP_OPACMASK_DATA, "LIB3DS_MAT_SXP_OPACMASK_DATA"},
- {LIB3DS_MAT_BUMPMAP, "LIB3DS_MAT_BUMPMAP"},
- {LIB3DS_MAT_SXP_BUMP_DATA, "LIB3DS_MAT_SXP_BUMP_DATA"},
- {LIB3DS_MAT_BUMPMASK, "LIB3DS_MAT_BUMPMASK"},
- {LIB3DS_MAT_SXP_BUMPMASK_DATA, "LIB3DS_MAT_SXP_BUMPMASK_DATA"},
- {LIB3DS_MAT_SPECMAP, "LIB3DS_MAT_SPECMAP"},
- {LIB3DS_MAT_SXP_SPEC_DATA, "LIB3DS_MAT_SXP_SPEC_DATA"},
- {LIB3DS_MAT_SPECMASK, "LIB3DS_MAT_SPECMASK"},
- {LIB3DS_MAT_SXP_SPECMASK_DATA, "LIB3DS_MAT_SXP_SPECMASK_DATA"},
- {LIB3DS_MAT_SHINMAP, "LIB3DS_MAT_SHINMAP"},
- {LIB3DS_MAT_SXP_SHIN_DATA, "LIB3DS_MAT_SXP_SHIN_DATA"},
- {LIB3DS_MAT_SHINMASK, "LIB3DS_MAT_SHINMASK"},
- {LIB3DS_MAT_SXP_SHINMASK_DATA, "LIB3DS_MAT_SXP_SHINMASK_DATA"},
- {LIB3DS_MAT_SELFIMAP, "LIB3DS_MAT_SELFIMAP"},
- {LIB3DS_MAT_SXP_SELFI_DATA, "LIB3DS_MAT_SXP_SELFI_DATA"},
- {LIB3DS_MAT_SELFIMASK, "LIB3DS_MAT_SELFIMASK"},
- {LIB3DS_MAT_SXP_SELFIMASK_DATA, "LIB3DS_MAT_SXP_SELFIMASK_DATA"},
- {LIB3DS_MAT_REFLMAP, "LIB3DS_MAT_REFLMAP"},
- {LIB3DS_MAT_REFLMASK, "LIB3DS_MAT_REFLMASK"},
- {LIB3DS_MAT_SXP_REFLMASK_DATA, "LIB3DS_MAT_SXP_REFLMASK_DATA"},
- {LIB3DS_MAT_ACUBIC, "LIB3DS_MAT_ACUBIC"},
- {LIB3DS_MAT_MAPNAME, "LIB3DS_MAT_MAPNAME"},
- {LIB3DS_MAT_MAP_TILING, "LIB3DS_MAT_MAP_TILING"},
- {LIB3DS_MAT_MAP_TEXBLUR, "LIB3DS_MAT_MAP_TEXBLUR"},
- {LIB3DS_MAT_MAP_USCALE, "LIB3DS_MAT_MAP_USCALE"},
- {LIB3DS_MAT_MAP_VSCALE, "LIB3DS_MAT_MAP_VSCALE"},
- {LIB3DS_MAT_MAP_UOFFSET, "LIB3DS_MAT_MAP_UOFFSET"},
- {LIB3DS_MAT_MAP_VOFFSET, "LIB3DS_MAT_MAP_VOFFSET"},
- {LIB3DS_MAT_MAP_ANG, "LIB3DS_MAT_MAP_ANG"},
- {LIB3DS_MAT_MAP_COL1, "LIB3DS_MAT_MAP_COL1"},
- {LIB3DS_MAT_MAP_COL2, "LIB3DS_MAT_MAP_COL2"},
- {LIB3DS_MAT_MAP_RCOL, "LIB3DS_MAT_MAP_RCOL"},
- {LIB3DS_MAT_MAP_GCOL, "LIB3DS_MAT_MAP_GCOL"},
- {LIB3DS_MAT_MAP_BCOL, "LIB3DS_MAT_MAP_BCOL"},
- {LIB3DS_NAMED_OBJECT, "LIB3DS_NAMED_OBJECT"},
- {LIB3DS_N_DIRECT_LIGHT, "LIB3DS_N_DIRECT_LIGHT"},
- {LIB3DS_DL_OFF, "LIB3DS_DL_OFF"},
- {LIB3DS_DL_OUTER_RANGE, "LIB3DS_DL_OUTER_RANGE"},
- {LIB3DS_DL_INNER_RANGE, "LIB3DS_DL_INNER_RANGE"},
- {LIB3DS_DL_MULTIPLIER, "LIB3DS_DL_MULTIPLIER"},
- {LIB3DS_DL_EXCLUDE, "LIB3DS_DL_EXCLUDE"},
- {LIB3DS_DL_ATTENUATE, "LIB3DS_DL_ATTENUATE"},
- {LIB3DS_DL_SPOTLIGHT, "LIB3DS_DL_SPOTLIGHT"},
- {LIB3DS_DL_SPOT_ROLL, "LIB3DS_DL_SPOT_ROLL"},
- {LIB3DS_DL_SHADOWED, "LIB3DS_DL_SHADOWED"},
- {LIB3DS_DL_LOCAL_SHADOW2, "LIB3DS_DL_LOCAL_SHADOW2"},
- {LIB3DS_DL_SEE_CONE, "LIB3DS_DL_SEE_CONE"},
- {LIB3DS_DL_SPOT_RECTANGULAR, "LIB3DS_DL_SPOT_RECTANGULAR"},
- {LIB3DS_DL_SPOT_ASPECT, "LIB3DS_DL_SPOT_ASPECT"},
- {LIB3DS_DL_SPOT_PROJECTOR, "LIB3DS_DL_SPOT_PROJECTOR"},
- {LIB3DS_DL_SPOT_OVERSHOOT, "LIB3DS_DL_SPOT_OVERSHOOT"},
- {LIB3DS_DL_RAY_BIAS, "LIB3DS_DL_RAY_BIAS"},
- {LIB3DS_DL_RAYSHAD, "LIB3DS_DL_RAYSHAD"},
- {LIB3DS_N_CAMERA, "LIB3DS_N_CAMERA"},
- {LIB3DS_CAM_SEE_CONE, "LIB3DS_CAM_SEE_CONE"},
- {LIB3DS_CAM_RANGES, "LIB3DS_CAM_RANGES"},
- {LIB3DS_OBJ_HIDDEN, "LIB3DS_OBJ_HIDDEN"},
- {LIB3DS_OBJ_VIS_LOFTER, "LIB3DS_OBJ_VIS_LOFTER"},
- {LIB3DS_OBJ_DOESNT_CAST, "LIB3DS_OBJ_DOESNT_CAST"},
- {LIB3DS_OBJ_DONT_RECVSHADOW, "LIB3DS_OBJ_DONT_RECVSHADOW"},
- {LIB3DS_OBJ_MATTE, "LIB3DS_OBJ_MATTE"},
- {LIB3DS_OBJ_FAST, "LIB3DS_OBJ_FAST"},
- {LIB3DS_OBJ_PROCEDURAL, "LIB3DS_OBJ_PROCEDURAL"},
- {LIB3DS_OBJ_FROZEN, "LIB3DS_OBJ_FROZEN"},
- {LIB3DS_N_TRI_OBJECT, "LIB3DS_N_TRI_OBJECT"},
- {LIB3DS_POINT_ARRAY, "LIB3DS_POINT_ARRAY"},
- {LIB3DS_POINT_FLAG_ARRAY, "LIB3DS_POINT_FLAG_ARRAY"},
- {LIB3DS_FACE_ARRAY, "LIB3DS_FACE_ARRAY"},
- {LIB3DS_MSH_MAT_GROUP, "LIB3DS_MSH_MAT_GROUP"},
- {LIB3DS_SMOOTH_GROUP, "LIB3DS_SMOOTH_GROUP"},
- {LIB3DS_MSH_BOXMAP, "LIB3DS_MSH_BOXMAP"},
- {LIB3DS_TEX_VERTS, "LIB3DS_TEX_VERTS"},
- {LIB3DS_MESH_MATRIX, "LIB3DS_MESH_MATRIX"},
- {LIB3DS_MESH_COLOR, "LIB3DS_MESH_COLOR"},
- {LIB3DS_MESH_TEXTURE_INFO, "LIB3DS_MESH_TEXTURE_INFO"},
- {LIB3DS_KFDATA, "LIB3DS_KFDATA"},
- {LIB3DS_KFHDR, "LIB3DS_KFHDR"},
- {LIB3DS_KFSEG, "LIB3DS_KFSEG"},
- {LIB3DS_KFCURTIME, "LIB3DS_KFCURTIME"},
- {LIB3DS_AMBIENT_NODE_TAG, "LIB3DS_AMBIENT_NODE_TAG"},
- {LIB3DS_OBJECT_NODE_TAG, "LIB3DS_OBJECT_NODE_TAG"},
- {LIB3DS_CAMERA_NODE_TAG, "LIB3DS_CAMERA_NODE_TAG"},
- {LIB3DS_TARGET_NODE_TAG, "LIB3DS_TARGET_NODE_TAG"},
- {LIB3DS_LIGHT_NODE_TAG, "LIB3DS_LIGHT_NODE_TAG"},
- {LIB3DS_L_TARGET_NODE_TAG, "LIB3DS_L_TARGET_NODE_TAG"},
- {LIB3DS_SPOTLIGHT_NODE_TAG, "LIB3DS_SPOTLIGHT_NODE_TAG"},
- {LIB3DS_NODE_ID, "LIB3DS_NODE_ID"},
- {LIB3DS_NODE_HDR, "LIB3DS_NODE_HDR"},
- {LIB3DS_PIVOT, "LIB3DS_PIVOT"},
- {LIB3DS_INSTANCE_NAME, "LIB3DS_INSTANCE_NAME"},
- {LIB3DS_MORPH_SMOOTH, "LIB3DS_MORPH_SMOOTH"},
- {LIB3DS_BOUNDBOX, "LIB3DS_BOUNDBOX"},
- {LIB3DS_POS_TRACK_TAG, "LIB3DS_POS_TRACK_TAG"},
- {LIB3DS_COL_TRACK_TAG, "LIB3DS_COL_TRACK_TAG"},
- {LIB3DS_ROT_TRACK_TAG, "LIB3DS_ROT_TRACK_TAG"},
- {LIB3DS_SCL_TRACK_TAG, "LIB3DS_SCL_TRACK_TAG"},
- {LIB3DS_MORPH_TRACK_TAG, "LIB3DS_MORPH_TRACK_TAG"},
- {LIB3DS_FOV_TRACK_TAG, "LIB3DS_FOV_TRACK_TAG"},
- {LIB3DS_ROLL_TRACK_TAG, "LIB3DS_ROLL_TRACK_TAG"},
- {LIB3DS_HOT_TRACK_TAG, "LIB3DS_HOT_TRACK_TAG"},
- {LIB3DS_FALL_TRACK_TAG, "LIB3DS_FALL_TRACK_TAG"},
- {LIB3DS_HIDE_TRACK_TAG, "LIB3DS_HIDE_TRACK_TAG"},
- {LIB3DS_POLY_2D, "LIB3DS_POLY_2D"},
- {LIB3DS_SHAPE_OK, "LIB3DS_SHAPE_OK"},
- {LIB3DS_SHAPE_NOT_OK, "LIB3DS_SHAPE_NOT_OK"},
- {LIB3DS_SHAPE_HOOK, "LIB3DS_SHAPE_HOOK"},
- {LIB3DS_PATH_3D, "LIB3DS_PATH_3D"},
- {LIB3DS_PATH_MATRIX, "LIB3DS_PATH_MATRIX"},
- {LIB3DS_SHAPE_2D, "LIB3DS_SHAPE_2D"},
- {LIB3DS_M_SCALE, "LIB3DS_M_SCALE"},
- {LIB3DS_M_TWIST, "LIB3DS_M_TWIST"},
- {LIB3DS_M_TEETER, "LIB3DS_M_TEETER"},
- {LIB3DS_M_FIT, "LIB3DS_M_FIT"},
- {LIB3DS_M_BEVEL, "LIB3DS_M_BEVEL"},
- {LIB3DS_XZ_CURVE, "LIB3DS_XZ_CURVE"},
- {LIB3DS_YZ_CURVE, "LIB3DS_YZ_CURVE"},
- {LIB3DS_INTERPCT, "LIB3DS_INTERPCT"},
- {LIB3DS_DEFORM_LIMIT, "LIB3DS_DEFORM_LIMIT"},
- {LIB3DS_USE_CONTOUR, "LIB3DS_USE_CONTOUR"},
- {LIB3DS_USE_TWEEN, "LIB3DS_USE_TWEEN"},
- {LIB3DS_USE_SCALE, "LIB3DS_USE_SCALE"},
- {LIB3DS_USE_TWIST, "LIB3DS_USE_TWIST"},
- {LIB3DS_USE_TEETER, "LIB3DS_USE_TEETER"},
- {LIB3DS_USE_FIT, "LIB3DS_USE_FIT"},
- {LIB3DS_USE_BEVEL, "LIB3DS_USE_BEVEL"},
- {LIB3DS_DEFAULT_VIEW, "LIB3DS_DEFAULT_VIEW"},
- {LIB3DS_VIEW_TOP, "LIB3DS_VIEW_TOP"},
- {LIB3DS_VIEW_BOTTOM, "LIB3DS_VIEW_BOTTOM"},
- {LIB3DS_VIEW_LEFT, "LIB3DS_VIEW_LEFT"},
- {LIB3DS_VIEW_RIGHT, "LIB3DS_VIEW_RIGHT"},
- {LIB3DS_VIEW_FRONT, "LIB3DS_VIEW_FRONT"},
- {LIB3DS_VIEW_BACK, "LIB3DS_VIEW_BACK"},
- {LIB3DS_VIEW_USER, "LIB3DS_VIEW_USER"},
- {LIB3DS_VIEW_CAMERA, "LIB3DS_VIEW_CAMERA"},
- {LIB3DS_VIEW_WINDOW, "LIB3DS_VIEW_WINDOW"},
- {LIB3DS_VIEWPORT_LAYOUT_OLD, "LIB3DS_VIEWPORT_LAYOUT_OLD"},
- {LIB3DS_VIEWPORT_DATA_OLD, "LIB3DS_VIEWPORT_DATA_OLD"},
- {LIB3DS_VIEWPORT_LAYOUT, "LIB3DS_VIEWPORT_LAYOUT"},
- {LIB3DS_VIEWPORT_DATA, "LIB3DS_VIEWPORT_DATA"},
- {LIB3DS_VIEWPORT_DATA_3, "LIB3DS_VIEWPORT_DATA_3"},
- {LIB3DS_VIEWPORT_SIZE, "LIB3DS_VIEWPORT_SIZE"},
- {LIB3DS_NETWORK_VIEW, "LIB3DS_NETWORK_VIEW"},
- {0,0}
-};
-
-#ifdef __cplusplus
-}
-#endif
-#endif
-
+++ /dev/null
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: ease.c,v 1.4 2001/01/12 10:29:17 jeh Exp $
- */
-#define LIB3DS_EXPORT
-#include <lib3ds/ease.h>
-
-
-/*!
- * \defgroup ease Ease
- *
- * \author J.E. Hoffmann <je-h@gmx.net>
- */
-
-
-/*!
- * \ingroup ease
- */
-Lib3dsFloat
-lib3ds_ease(Lib3dsFloat fp, Lib3dsFloat fc, Lib3dsFloat fn,
- Lib3dsFloat ease_from, Lib3dsFloat ease_to)
-{
- Lib3dsDouble s,step;
- Lib3dsDouble tofrom;
- Lib3dsDouble a;
-
- s=step=(Lib3dsFloat)(fc-fp)/(fn-fp);
- tofrom=ease_to+ease_from;
- if (tofrom!=0.0) {
- if (tofrom>1.0) {
- ease_to=(Lib3dsFloat)(ease_to/tofrom);
- ease_from=(Lib3dsFloat)(ease_from/tofrom);
- }
- a=1.0/(2.0-(ease_to+ease_from));
-
- if (step<ease_from) s=a/ease_from*step*step;
- else {
- if ((1.0-ease_to)<=step) {
- step=1.0-step;
- s=1.0-a/ease_to*step*step;
- }
- else {
- s=((2.0*step)-ease_from)*a;
- }
- }
- }
- return((Lib3dsFloat)s);
-}
+++ /dev/null
-/* -*- c -*- */
-#ifndef INCLUDED_LIB3DS_EASE_H
-#define INCLUDED_LIB3DS_EASE_H
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: ease.h,v 1.5 2004/12/31 16:17:15 reed Exp $
- */
-
-#ifndef INCLUDED_LIB3DS_TYPES_H
-#include <lib3ds/types.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-extern LIB3DSAPI Lib3dsFloat lib3ds_ease(Lib3dsFloat fp, Lib3dsFloat fc,
- Lib3dsFloat fn, Lib3dsFloat ease_from, Lib3dsFloat ease_to);
-
-#ifdef __cplusplus
-}
-#endif
-#endif
-
+++ /dev/null
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: file.c,v 1.23 2005/01/11 10:20:36 madmac Exp $
- */
-#define LIB3DS_EXPORT
-#include <lib3ds/file.h>
-#include <lib3ds/chunk.h>
-#include <lib3ds/io.h>
-#include <lib3ds/material.h>
-#include <lib3ds/mesh.h>
-#include <lib3ds/camera.h>
-#include <lib3ds/light.h>
-#include <lib3ds/node.h>
-#include <lib3ds/vector.h>
-#include <stdlib.h>
-#include <string.h>
-#include <math.h>
-#ifdef WITH_DMALLOC
-#include <dmalloc.h>
-#endif
-
-
-
-/*!
- * \defgroup file Files
- *
- * \author J.E. Hoffmann <je-h@gmx.net>
- */
-
-
-static Lib3dsBool
-fileio_error_func(void *self)
-{
- FILE *f = (FILE*)self;
- return(ferror(f)!=0);
-}
-
-
-static long
-fileio_seek_func(void *self, long offset, Lib3dsIoSeek origin)
-{
- FILE *f = (FILE*)self;
- int o;
- switch (origin) {
- case LIB3DS_SEEK_SET:
- o = SEEK_SET;
- break;
- case LIB3DS_SEEK_CUR:
- o = SEEK_CUR;
- break;
- case LIB3DS_SEEK_END:
- o = SEEK_END;
- break;
- default:
- ASSERT(0);
- return(0);
- }
- return (fseek(f, offset, o));
-}
-
-
-static long
-fileio_tell_func(void *self)
-{
- FILE *f = (FILE*)self;
- return(ftell(f));
-}
-
-
-static int
-fileio_read_func(void *self, Lib3dsByte *buffer, int size)
-{
- FILE *f = (FILE*)self;
- return(fread(buffer, 1, size, f));
-}
-
-
-static int
-fileio_write_func(void *self, const Lib3dsByte *buffer, int size)
-{
- FILE *f = (FILE*)self;
- return(fwrite(buffer, 1, size, f));
-}
-
-
-/*!
- * Loads a .3DS file from disk into memory.
- *
- * \param filename The filename of the .3DS file
- *
- * \return A pointer to the Lib3dsFile structure containing the
- * data of the .3DS file.
- * If the .3DS file can not be loaded NULL is returned.
- *
- * \note To free the returned structure use lib3ds_free.
- *
- * \see lib3ds_file_save
- * \see lib3ds_file_new
- * \see lib3ds_file_free
- *
- * \ingroup file
- */
-Lib3dsFile*
-lib3ds_file_load(const char *filename)
-{
- FILE *f;
- Lib3dsFile *file;
- Lib3dsIo *io;
-
-
- f = fopen(filename, "rb");
- if (!f) {
- return(0);
- }
- file = lib3ds_file_new();
- if (!file) {
- fclose(f);
- return(0);
- }
- io = lib3ds_io_new(
- f,
- fileio_error_func,
- fileio_seek_func,
- fileio_tell_func,
- fileio_read_func,
- fileio_write_func
- );
- if (!io) {
- lib3ds_file_free(file);
- fclose(f);
- return(0);
- }
-
- if (!lib3ds_file_read(file, io)) {
- free(file);
- fclose(f);
- return(0);
- }
-
- lib3ds_io_free(io);
- fclose(f);
- return(file);
-}
-
-
-/*!
- * Saves a .3DS file from memory to disk.
- *
- * \param file A pointer to a Lib3dsFile structure containing the
- * the data that should be stored.
- * \param filename The filename of the .3DS file to store the data in.
- *
- * \return TRUE on success, FALSE otherwise.
- *
- * \see lib3ds_file_load
- *
- * \ingroup file
- */
-Lib3dsBool
-lib3ds_file_save(Lib3dsFile *file, const char *filename)
-{
- FILE *f;
- Lib3dsIo *io;
- Lib3dsBool result;
-
- f = fopen(filename, "wb");
- if (!f) {
- return(LIB3DS_FALSE);
- }
- io = lib3ds_io_new(
- f,
- fileio_error_func,
- fileio_seek_func,
- fileio_tell_func,
- fileio_read_func,
- fileio_write_func
- );
- if (!io) {
- fclose(f);
- return LIB3DS_FALSE;
- }
-
- result = lib3ds_file_write(file, io);
-
- fclose(f);
-
- lib3ds_io_free(io);
- return(result);
-}
-
-
-/*!
- * Creates and returns a new, empty Lib3dsFile object.
- *
- * \return A pointer to the Lib3dsFile structure.
- * If the structure cannot be allocated, NULL is returned.
- *
- * \ingroup file
- */
-Lib3dsFile*
-lib3ds_file_new()
-{
- Lib3dsFile *file;
-
- file=(Lib3dsFile*)calloc(sizeof(Lib3dsFile),1);
- if (!file) {
- return(0);
- }
- file->mesh_version=3;
- file->master_scale=1.0f;
- file->keyf_revision=5;
- strcpy(file->name, "LIB3DS");
-
- file->frames=100;
- file->segment_from=0;
- file->segment_to=100;
- file->current_frame=0;
-
- return(file);
-}
-
-
-/*!
- * Free a Lib3dsFile object and all of its resources.
- *
- * \param file The Lib3dsFile object to be freed.
- *
- * \ingroup file
- */
-void
-lib3ds_file_free(Lib3dsFile* file)
-{
- ASSERT(file);
- lib3ds_viewport_set_views(&file->viewport,0);
- {
- Lib3dsMaterial *p,*q;
-
- for (p=file->materials; p; p=q) {
- q=p->next;
- lib3ds_material_free(p);
- }
- file->materials=0;
- }
- {
- Lib3dsCamera *p,*q;
-
- for (p=file->cameras; p; p=q) {
- q=p->next;
- lib3ds_camera_free(p);
- }
- file->cameras=0;
- }
- {
- Lib3dsLight *p,*q;
-
- for (p=file->lights; p; p=q) {
- q=p->next;
- lib3ds_light_free(p);
- }
- file->lights=0;
- }
- {
- Lib3dsMesh *p,*q;
-
- for (p=file->meshes; p; p=q) {
- q=p->next;
- lib3ds_mesh_free(p);
- }
- file->meshes=0;
- }
- {
- Lib3dsNode *p,*q;
-
- for (p=file->nodes; p; p=q) {
- q=p->next;
- lib3ds_node_free(p);
- }
- }
- free(file);
-}
-
-
-/*!
- * Evaluate all of the nodes in this Lib3dsFile object.
- *
- * \param file The Lib3dsFile object to be evaluated.
- * \param t time value, between 0. and file->frames
- *
- * \see lib3ds_node_eval
- *
- * \ingroup file
- */
-void
-lib3ds_file_eval(Lib3dsFile *file, Lib3dsFloat t)
-{
- Lib3dsNode *p;
-
- for (p=file->nodes; p!=0; p=p->next) {
- lib3ds_node_eval(p, t);
- }
-}
-
-
-static Lib3dsBool
-named_object_read(Lib3dsFile *file, Lib3dsIo *io)
-{
- Lib3dsChunk c;
- char name[64];
- Lib3dsWord chunk;
-
- if (!lib3ds_chunk_read_start(&c, LIB3DS_NAMED_OBJECT, io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_io_read_string(io, name, 64)) {
- return(LIB3DS_FALSE);
- }
- lib3ds_chunk_dump_info(" NAME=%s", name);
- lib3ds_chunk_read_tell(&c, io);
-
- while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
- switch (chunk) {
- case LIB3DS_N_TRI_OBJECT:
- {
- Lib3dsMesh *mesh;
-
- mesh=lib3ds_mesh_new(name);
- if (!mesh) {
- return(LIB3DS_FALSE);
- }
- lib3ds_chunk_read_reset(&c, io);
- if (!lib3ds_mesh_read(mesh, io)) {
- return(LIB3DS_FALSE);
- }
- lib3ds_file_insert_mesh(file, mesh);
- }
- break;
- case LIB3DS_N_CAMERA:
- {
- Lib3dsCamera *camera;
-
- camera=lib3ds_camera_new(name);
- if (!camera) {
- return(LIB3DS_FALSE);
- }
- lib3ds_chunk_read_reset(&c, io);
- if (!lib3ds_camera_read(camera, io)) {
- return(LIB3DS_FALSE);
- }
- lib3ds_file_insert_camera(file, camera);
- }
- break;
- case LIB3DS_N_DIRECT_LIGHT:
- {
- Lib3dsLight *light;
-
- light=lib3ds_light_new(name);
- if (!light) {
- return(LIB3DS_FALSE);
- }
- lib3ds_chunk_read_reset(&c, io);
- if (!lib3ds_light_read(light, io)) {
- return(LIB3DS_FALSE);
- }
- lib3ds_file_insert_light(file, light);
- }
- break;
- default:
- lib3ds_chunk_unknown(chunk);
- }
- }
-
- lib3ds_chunk_read_end(&c, io);
- return(LIB3DS_TRUE);
-}
-
-
-static Lib3dsBool
-ambient_read(Lib3dsFile *file, Lib3dsIo *io)
-{
- Lib3dsChunk c;
- Lib3dsWord chunk;
- Lib3dsBool have_lin=LIB3DS_FALSE;
-
- if (!lib3ds_chunk_read_start(&c, LIB3DS_AMBIENT_LIGHT, io)) {
- return(LIB3DS_FALSE);
- }
-
- while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
- switch (chunk) {
- case LIB3DS_LIN_COLOR_F:
- {
- int i;
- for (i=0; i<3; ++i) {
- file->ambient[i]=lib3ds_io_read_float(io);
- }
- }
- have_lin=LIB3DS_TRUE;
- break;
- case LIB3DS_COLOR_F:
- {
- /* gamma corrected color chunk
- replaced in 3ds R3 by LIN_COLOR_24 */
- if (!have_lin) {
- int i;
- for (i=0; i<3; ++i) {
- file->ambient[i]=lib3ds_io_read_float(io);
- }
- }
- }
- break;
- default:
- lib3ds_chunk_unknown(chunk);
- }
- }
-
- lib3ds_chunk_read_end(&c, io);
- return(LIB3DS_TRUE);
-}
-
-
-static Lib3dsBool
-mdata_read(Lib3dsFile *file, Lib3dsIo *io)
-{
- Lib3dsChunk c;
- Lib3dsWord chunk;
-
- if (!lib3ds_chunk_read_start(&c, LIB3DS_MDATA, io)) {
- return(LIB3DS_FALSE);
- }
-
- while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
- switch (chunk) {
- case LIB3DS_MESH_VERSION:
- {
- file->mesh_version=lib3ds_io_read_intd(io);
- }
- break;
- case LIB3DS_MASTER_SCALE:
- {
- file->master_scale=lib3ds_io_read_float(io);
- }
- break;
- case LIB3DS_SHADOW_MAP_SIZE:
- case LIB3DS_LO_SHADOW_BIAS:
- case LIB3DS_HI_SHADOW_BIAS:
- case LIB3DS_SHADOW_SAMPLES:
- case LIB3DS_SHADOW_RANGE:
- case LIB3DS_SHADOW_FILTER:
- case LIB3DS_RAY_BIAS:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!lib3ds_shadow_read(&file->shadow, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_VIEWPORT_LAYOUT:
- case LIB3DS_DEFAULT_VIEW:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!lib3ds_viewport_read(&file->viewport, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_O_CONSTS:
- {
- int i;
- for (i=0; i<3; ++i) {
- file->construction_plane[i]=lib3ds_io_read_float(io);
- }
- }
- break;
- case LIB3DS_AMBIENT_LIGHT:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!ambient_read(file, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_BIT_MAP:
- case LIB3DS_SOLID_BGND:
- case LIB3DS_V_GRADIENT:
- case LIB3DS_USE_BIT_MAP:
- case LIB3DS_USE_SOLID_BGND:
- case LIB3DS_USE_V_GRADIENT:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!lib3ds_background_read(&file->background, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_FOG:
- case LIB3DS_LAYER_FOG:
- case LIB3DS_DISTANCE_CUE:
- case LIB3DS_USE_FOG:
- case LIB3DS_USE_LAYER_FOG:
- case LIB3DS_USE_DISTANCE_CUE:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!lib3ds_atmosphere_read(&file->atmosphere, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_MAT_ENTRY:
- {
- Lib3dsMaterial *material;
-
- material=lib3ds_material_new();
- if (!material) {
- return(LIB3DS_FALSE);
- }
- lib3ds_chunk_read_reset(&c, io);
- if (!lib3ds_material_read(material, io)) {
- return(LIB3DS_FALSE);
- }
- lib3ds_file_insert_material(file, material);
- }
- break;
- case LIB3DS_NAMED_OBJECT:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!named_object_read(file, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- default:
- lib3ds_chunk_unknown(chunk);
- }
- }
-
- lib3ds_chunk_read_end(&c, io);
- return(LIB3DS_TRUE);
-}
-
-
-static Lib3dsBool
-kfdata_read(Lib3dsFile *file, Lib3dsIo *io)
-{
- Lib3dsChunk c;
- Lib3dsWord chunk;
-
- if (!lib3ds_chunk_read_start(&c, LIB3DS_KFDATA, io)) {
- return(LIB3DS_FALSE);
- }
-
- while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
- switch (chunk) {
- case LIB3DS_KFHDR:
- {
- file->keyf_revision=lib3ds_io_read_word(io);
- if (!lib3ds_io_read_string(io, file->name, 12+1)) {
- return(LIB3DS_FALSE);
- }
- file->frames=lib3ds_io_read_intd(io);
- }
- break;
- case LIB3DS_KFSEG:
- {
- file->segment_from=lib3ds_io_read_intd(io);
- file->segment_to=lib3ds_io_read_intd(io);
- }
- break;
- case LIB3DS_KFCURTIME:
- {
- file->current_frame=lib3ds_io_read_intd(io);
- }
- break;
- case LIB3DS_VIEWPORT_LAYOUT:
- case LIB3DS_DEFAULT_VIEW:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!lib3ds_viewport_read(&file->viewport_keyf, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_AMBIENT_NODE_TAG:
- {
- Lib3dsNode *node;
-
- node=lib3ds_node_new_ambient();
- if (!node) {
- return(LIB3DS_FALSE);
- }
- lib3ds_chunk_read_reset(&c, io);
- if (!lib3ds_node_read(node, file, io)) {
- return(LIB3DS_FALSE);
- }
- lib3ds_file_insert_node(file, node);
- }
- break;
- case LIB3DS_OBJECT_NODE_TAG:
- {
- Lib3dsNode *node;
-
- node=lib3ds_node_new_object();
- if (!node) {
- return(LIB3DS_FALSE);
- }
- lib3ds_chunk_read_reset(&c, io);
- if (!lib3ds_node_read(node, file, io)) {
- return(LIB3DS_FALSE);
- }
- lib3ds_file_insert_node(file, node);
- }
- break;
- case LIB3DS_CAMERA_NODE_TAG:
- {
- Lib3dsNode *node;
-
- node=lib3ds_node_new_camera();
- if (!node) {
- return(LIB3DS_FALSE);
- }
- lib3ds_chunk_read_reset(&c, io);
- if (!lib3ds_node_read(node, file, io)) {
- return(LIB3DS_FALSE);
- }
- lib3ds_file_insert_node(file, node);
- }
- break;
- case LIB3DS_TARGET_NODE_TAG:
- {
- Lib3dsNode *node;
-
- node=lib3ds_node_new_target();
- if (!node) {
- return(LIB3DS_FALSE);
- }
- lib3ds_chunk_read_reset(&c, io);
- if (!lib3ds_node_read(node, file, io)) {
- return(LIB3DS_FALSE);
- }
- lib3ds_file_insert_node(file, node);
- }
- break;
- case LIB3DS_LIGHT_NODE_TAG:
- case LIB3DS_SPOTLIGHT_NODE_TAG:
- {
- Lib3dsNode *node;
-
- node=lib3ds_node_new_light();
- if (!node) {
- return(LIB3DS_FALSE);
- }
- lib3ds_chunk_read_reset(&c, io);
- if (!lib3ds_node_read(node, file, io)) {
- return(LIB3DS_FALSE);
- }
- lib3ds_file_insert_node(file, node);
- }
- break;
- case LIB3DS_L_TARGET_NODE_TAG:
- {
- Lib3dsNode *node;
-
- node=lib3ds_node_new_spot();
- if (!node) {
- return(LIB3DS_FALSE);
- }
- lib3ds_chunk_read_reset(&c, io);
- if (!lib3ds_node_read(node, file, io)) {
- return(LIB3DS_FALSE);
- }
- lib3ds_file_insert_node(file, node);
- }
- break;
- default:
- lib3ds_chunk_unknown(chunk);
- }
- }
-
- lib3ds_chunk_read_end(&c, io);
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * Read 3ds file data into a Lib3dsFile object.
- *
- * \param file The Lib3dsFile object to be filled.
- * \param io A Lib3dsIo object previously set up by the caller.
- *
- * \return LIB3DS_TRUE on success, LIB3DS_FALSE on failure.
- *
- * \ingroup file
- */
-Lib3dsBool
-lib3ds_file_read(Lib3dsFile *file, Lib3dsIo *io)
-{
- Lib3dsChunk c;
- Lib3dsWord chunk;
-
- if (!lib3ds_chunk_read_start(&c, 0, io)) {
- return(LIB3DS_FALSE);
- }
- switch (c.chunk) {
- case LIB3DS_MDATA:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!mdata_read(file, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_M3DMAGIC:
- case LIB3DS_MLIBMAGIC:
- case LIB3DS_CMAGIC:
- {
- while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
- switch (chunk) {
- case LIB3DS_M3D_VERSION:
- {
- file->mesh_version=lib3ds_io_read_dword(io);
- }
- break;
- case LIB3DS_MDATA:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!mdata_read(file, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_KFDATA:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!kfdata_read(file, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- default:
- lib3ds_chunk_unknown(chunk);
- }
- }
- }
- break;
- default:
- lib3ds_chunk_unknown(c.chunk);
- return(LIB3DS_FALSE);
- }
-
- lib3ds_chunk_read_end(&c, io);
- return(LIB3DS_TRUE);
-}
-
-
-static Lib3dsBool
-colorf_write(Lib3dsRgba rgb, Lib3dsIo *io)
-{
- Lib3dsChunk c;
-
- c.chunk=LIB3DS_COLOR_F;
- c.size=18;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_rgb(io, rgb);
-
- c.chunk=LIB3DS_LIN_COLOR_F;
- c.size=18;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_rgb(io, rgb);
- return(LIB3DS_TRUE);
-}
-
-
-static Lib3dsBool
-mdata_write(Lib3dsFile *file, Lib3dsIo *io)
-{
- Lib3dsChunk c;
-
- c.chunk=LIB3DS_MDATA;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
-
- { /*---- LIB3DS_MESH_VERSION ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MESH_VERSION;
- c.size=10;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_intd(io, file->mesh_version);
- }
- { /*---- LIB3DS_MASTER_SCALE ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MASTER_SCALE;
- c.size=10;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_float(io, file->master_scale);
- }
- { /*---- LIB3DS_O_CONSTS ----*/
- int i;
- for (i=0; i<3; ++i) {
- if (fabs(file->construction_plane[i])>LIB3DS_EPSILON) {
- break;
- }
- }
- if (i<3) {
- Lib3dsChunk c;
- c.chunk=LIB3DS_O_CONSTS;
- c.size=18;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_vector(io, file->construction_plane);
- }
- }
-
- { /*---- LIB3DS_AMBIENT_LIGHT ----*/
- int i;
- for (i=0; i<3; ++i) {
- if (fabs(file->ambient[i])>LIB3DS_EPSILON) {
- break;
- }
- }
- if (i<3) {
- Lib3dsChunk c;
- c.chunk=LIB3DS_AMBIENT_LIGHT;
- c.size=42;
- lib3ds_chunk_write(&c,io);
- colorf_write(file->ambient,io);
- }
- }
- lib3ds_background_write(&file->background, io);
- lib3ds_atmosphere_write(&file->atmosphere, io);
- lib3ds_shadow_write(&file->shadow, io);
- lib3ds_viewport_write(&file->viewport, io);
- {
- Lib3dsMaterial *p;
- for (p=file->materials; p!=0; p=p->next) {
- if (!lib3ds_material_write(p,io)) {
- return(LIB3DS_FALSE);
- }
- }
- }
- {
- Lib3dsCamera *p;
- Lib3dsChunk c;
-
- for (p=file->cameras; p!=0; p=p->next) {
- c.chunk=LIB3DS_NAMED_OBJECT;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
- lib3ds_io_write_string(io, p->name);
- lib3ds_camera_write(p,io);
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- }
- }
- {
- Lib3dsLight *p;
- Lib3dsChunk c;
-
- for (p=file->lights; p!=0; p=p->next) {
- c.chunk=LIB3DS_NAMED_OBJECT;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
- lib3ds_io_write_string(io,p->name);
- lib3ds_light_write(p,io);
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- }
- }
- {
- Lib3dsMesh *p;
- Lib3dsChunk c;
-
- for (p=file->meshes; p!=0; p=p->next) {
- c.chunk=LIB3DS_NAMED_OBJECT;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
- lib3ds_io_write_string(io, p->name);
- lib3ds_mesh_write(p,io);
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- }
- }
-
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- return(LIB3DS_TRUE);
-}
-
-
-
-static Lib3dsBool
-nodes_write(Lib3dsNode *node, Lib3dsFile *file, Lib3dsIo *io)
-{
- {
- Lib3dsNode *p;
- for (p=node->childs; p!=0; p=p->next) {
- if (!lib3ds_node_write(p, file, io)) {
- return(LIB3DS_FALSE);
- }
- nodes_write(p, file, io);
- }
- }
- return(LIB3DS_TRUE);
-}
-
-
-static Lib3dsBool
-kfdata_write(Lib3dsFile *file, Lib3dsIo *io)
-{
- Lib3dsChunk c;
-
- if (!file->nodes) {
- return(LIB3DS_TRUE);
- }
-
- c.chunk=LIB3DS_KFDATA;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
-
- { /*---- LIB3DS_KFHDR ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_KFHDR;
- c.size=6 + 2 + strlen(file->name)+1 +4;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_intw(io, file->keyf_revision);
- lib3ds_io_write_string(io, file->name);
- lib3ds_io_write_intd(io, file->frames);
- }
- { /*---- LIB3DS_KFSEG ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_KFSEG;
- c.size=14;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_intd(io, file->segment_from);
- lib3ds_io_write_intd(io, file->segment_to);
- }
- { /*---- LIB3DS_KFCURTIME ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_KFCURTIME;
- c.size=10;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_intd(io, file->current_frame);
- }
- lib3ds_viewport_write(&file->viewport_keyf, io);
-
- {
- Lib3dsNode *p;
- for (p=file->nodes; p!=0; p=p->next) {
- if (!lib3ds_node_write(p, file, io)) {
- return(LIB3DS_FALSE);
- }
- if (!nodes_write(p, file, io)) {
- return(LIB3DS_FALSE);
- }
- }
- }
-
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * Write 3ds file data from a Lib3dsFile object to a file.
- *
- * \param file The Lib3dsFile object to be written.
- * \param io A Lib3dsIo object previously set up by the caller.
- *
- * \return LIB3DS_TRUE on success, LIB3DS_FALSE on failure.
- *
- * \ingroup file
- */
-Lib3dsBool
-lib3ds_file_write(Lib3dsFile *file, Lib3dsIo *io)
-{
- Lib3dsChunk c;
-
- c.chunk=LIB3DS_M3DMAGIC;
- if (!lib3ds_chunk_write_start(&c,io)) {
- LIB3DS_ERROR_LOG;
- return(LIB3DS_FALSE);
- }
-
- { /*---- LIB3DS_M3D_VERSION ----*/
- Lib3dsChunk c;
-
- c.chunk=LIB3DS_M3D_VERSION;
- c.size=10;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_dword(io, file->mesh_version);
- }
-
- if (!mdata_write(file, io)) {
- return(LIB3DS_FALSE);
- }
- if (!kfdata_write(file, io)) {
- return(LIB3DS_FALSE);
- }
-
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * Insert a new Lib3dsMaterial object into the materials list of
- * a Lib3dsFile object.
- *
- * The new Lib3dsMaterial object is inserted into the materials list
- * in alphabetic order by name.
- *
- * \param file The Lib3dsFile object to be modified.
- * \param material The Lib3dsMaterial object to be inserted into file->materials
- *
- * \ingroup file
- */
-void
-lib3ds_file_insert_material(Lib3dsFile *file, Lib3dsMaterial *material)
-{
- Lib3dsMaterial *p,*q;
-
- ASSERT(file);
- ASSERT(material);
- ASSERT(!material->next);
-
- q=0;
- for (p=file->materials; p!=0; p=p->next) {
- if (strcmp(material->name, p->name)<0) {
- break;
- }
- q=p;
- }
- if (!q) {
- material->next=file->materials;
- file->materials=material;
- }
- else {
- material->next=q->next;
- q->next=material;
- }
-}
-
-
-/*!
- * Remove a Lib3dsMaterial object from the materials list of
- * a Lib3dsFile object.
- *
- * If the Lib3dsMaterial is not found in the materials list, nothing is
- * done (except that an error log message may be generated.)
- *
- * \param file The Lib3dsFile object to be modified.
- * \param material The Lib3dsMaterial object to be removed from file->materials
- *
- * \ingroup file
- */
-void
-lib3ds_file_remove_material(Lib3dsFile *file, Lib3dsMaterial *material)
-{
- Lib3dsMaterial *p,*q;
-
- ASSERT(file);
- ASSERT(material);
- ASSERT(file->materials);
- for (p=0,q=file->materials; q; p=q,q=q->next) {
- if (q==material) {
- break;
- }
- }
- if (!q) {
- ASSERT(LIB3DS_FALSE);
- return;
- }
- if (!p) {
- file->materials=material->next;
- }
- else {
- p->next=q->next;
- }
- material->next=0;
-}
-
-
-/*!
- * Return a Lib3dsMaterial object by name.
- *
- * \param file Lib3dsFile object to be searched.
- * \param name Name of the Lib3dsMaterial object to be searched for.
- *
- * \return A pointer to the named Lib3dsMaterial, or NULL if not found.
- *
- * \ingroup file
- */
-Lib3dsMaterial*
-lib3ds_file_material_by_name(Lib3dsFile *file, const char *name)
-{
- Lib3dsMaterial *p;
-
- ASSERT(file);
- for (p=file->materials; p!=0; p=p->next) {
- if (strcmp(p->name,name)==0) {
- return(p);
- }
- }
- return(0);
-}
-
-
-/*!
- * Dump all Lib3dsMaterial objects found in a Lib3dsFile object.
- *
- * \param file Lib3dsFile object to be dumped.
- *
- * \see lib3ds_material_dump
- *
- * \ingroup file
- */
-void
-lib3ds_file_dump_materials(Lib3dsFile *file)
-{
- Lib3dsMaterial *p;
-
- ASSERT(file);
- for (p=file->materials; p!=0; p=p->next) {
- lib3ds_material_dump(p);
- }
-}
-
-
-/*!
- * Insert a new Lib3dsMesh object into the meshes list of
- * a Lib3dsFile object.
- *
- * The new Lib3dsMesh object is inserted into the meshes list
- * in alphabetic order by name.
- *
- * \param file The Lib3dsFile object to be modified.
- * \param material The Lib3dsMesh object to be inserted into file->meshes
- *
- * \ingroup file
- */
-void
-lib3ds_file_insert_mesh(Lib3dsFile *file, Lib3dsMesh *mesh)
-{
- Lib3dsMesh *p,*q;
-
- ASSERT(file);
- ASSERT(mesh);
- ASSERT(!mesh->next);
-
- q=0;
- for (p=file->meshes; p!=0; p=p->next) {
- if (strcmp(mesh->name, p->name)<0) {
- break;
- }
- q=p;
- }
- if (!q) {
- mesh->next=file->meshes;
- file->meshes=mesh;
- }
- else {
- mesh->next=q->next;
- q->next=mesh;
- }
-}
-
-
-/*!
- * Remove a Lib3dsMesh object from the meshes list of
- * a Lib3dsFile object.
- *
- * If the Lib3dsMesh is not found in the meshes list, nothing is done
- * (except that an error log message may be generated.)
- *
- * \param file The Lib3dsFile object to be modified.
- * \param material The Lib3dsMesh object to be removed from file->meshes
- *
- * \ingroup file
- */
-void
-lib3ds_file_remove_mesh(Lib3dsFile *file, Lib3dsMesh *mesh)
-{
- Lib3dsMesh *p,*q;
-
- ASSERT(file);
- ASSERT(mesh);
- ASSERT(file->meshes);
- for (p=0,q=file->meshes; q; p=q,q=q->next) {
- if (q==mesh) {
- break;
- }
- }
- if (!q) {
- ASSERT(LIB3DS_FALSE);
- return;
- }
- if (!p) {
- file->meshes=mesh->next;
- }
- else {
- p->next=q->next;
- }
- mesh->next=0;
-}
-
-
-/*!
- * Return a Lib3dsMesh object from a Lib3dsFile by name.
- *
- * \param file Lib3dsFile object to be searched.
- * \param name Name of the Lib3dsMesh object to be searched for.
- *
- * \return A pointer to the named Lib3dsMesh, or NULL if not found.
- *
- * \ingroup file
- */
-Lib3dsMesh*
-lib3ds_file_mesh_by_name(Lib3dsFile *file, const char *name)
-{
- Lib3dsMesh *p;
-
- ASSERT(file);
- for (p=file->meshes; p!=0; p=p->next) {
- if (strcmp(p->name,name)==0) {
- return(p);
- }
- }
- return(0);
-}
-
-
-/*!
- * Dump all Lib3dsMesh objects found in a Lib3dsFile object.
- *
- * \param file Lib3dsFile object to be dumped.
- *
- * \see lib3ds_mesh_dump
- *
- * \ingroup file
- */
-void
-lib3ds_file_dump_meshes(Lib3dsFile *file)
-{
- Lib3dsMesh *p;
-
- ASSERT(file);
- for (p=file->meshes; p!=0; p=p->next) {
- lib3ds_mesh_dump(p);
- }
-}
-
-
-static void
-dump_instances(Lib3dsNode *node, const char* parent)
-{
- Lib3dsNode *p;
- char name[255];
-
- ASSERT(node);
- ASSERT(parent);
- strcpy(name, parent);
- strcat(name, ".");
- strcat(name, node->name);
- if (node->type==LIB3DS_OBJECT_NODE) {
- printf(" %s : %s\n", name, node->data.object.instance);
- }
- for (p=node->childs; p!=0; p=p->next) {
- dump_instances(p, parent);
- }
-}
-
-
-/*!
- * Dump all Lib3dsNode object names found in a Lib3dsFile object.
- *
- * For each node of type OBJECT_NODE, its name and data.object.instance
- * fields are printed to stdout. Consider using lib3ds_file_dump_nodes()
- * instead, as that function dumps more information.
- *
- * Nodes are dumped recursively.
- *
- * \param file Lib3dsFile object to be dumped.
- *
- * \see lib3ds_file_dump_nodes
- *
- * \ingroup file
- */
-void
-lib3ds_file_dump_instances(Lib3dsFile *file)
-{
- Lib3dsNode *p;
-
- ASSERT(file);
- for (p=file->nodes; p!=0; p=p->next) {
- dump_instances(p,"");
- }
-}
-
-
-/*!
- * Insert a new Lib3dsCamera object into the cameras list of
- * a Lib3dsFile object.
- *
- * The new Lib3dsCamera object is inserted into the cameras list
- * in alphabetic order by name.
- *
- * \param file The Lib3dsFile object to be modified.
- * \param material The Lib3dsCamera object to be inserted into file->cameras
- *
- * \ingroup file
- */
-void
-lib3ds_file_insert_camera(Lib3dsFile *file, Lib3dsCamera *camera)
-{
- Lib3dsCamera *p,*q;
-
- ASSERT(file);
- ASSERT(camera);
- ASSERT(!camera->next);
-
- q=0;
- for (p=file->cameras; p!=0; p=p->next) {
- if (strcmp(camera->name, p->name)<0) {
- break;
- }
- q=p;
- }
- if (!q) {
- camera->next=file->cameras;
- file->cameras=camera;
- }
- else {
- camera->next=q->next;
- q->next=camera;
- }
-}
-
-
-/*!
- * Remove a Lib3dsCamera object from the cameras list of
- * a Lib3dsFile object.
- *
- * If the Lib3dsCamera is not found in the cameras list, nothing is done
- * (except that an error log message may be generated.)
- *
- * \param file The Lib3dsFile object to be modified.
- * \param material The Lib3dsCamera object to be removed from file->cameras
- *
- * \ingroup file
- */
-void
-lib3ds_file_remove_camera(Lib3dsFile *file, Lib3dsCamera *camera)
-{
- Lib3dsCamera *p,*q;
-
- ASSERT(file);
- ASSERT(camera);
- ASSERT(file->cameras);
- for (p=0,q=file->cameras; q; p=q,q=q->next) {
- if (q==camera) {
- break;
- }
- }
- if (!q) {
- ASSERT(LIB3DS_FALSE);
- return;
- }
- if (!p) {
- file->cameras=camera->next;
- }
- else {
- p->next=q->next;
- }
- camera->next=0;
-}
-
-
-/*!
- * Return a Lib3dsCamera object from a Lib3dsFile by name.
- *
- * \param file Lib3dsFile object to be searched.
- * \param name Name of the Lib3dsCamera object to be searched for.
- *
- * \return A pointer to the named Lib3dsCamera, or NULL if not found.
- *
- * \ingroup file
- */
-Lib3dsCamera*
-lib3ds_file_camera_by_name(Lib3dsFile *file, const char *name)
-{
- Lib3dsCamera *p;
-
- ASSERT(file);
- for (p=file->cameras; p!=0; p=p->next) {
- if (strcmp(p->name,name)==0) {
- return(p);
- }
- }
- return(0);
-}
-
-
-/*!
- * Dump all Lib3dsCamera objects found in a Lib3dsFile object.
- *
- * \param file Lib3dsFile object to be dumped.
- *
- * \see lib3ds_camera_dump
- *
- * \ingroup file
- */
-void
-lib3ds_file_dump_cameras(Lib3dsFile *file)
-{
- Lib3dsCamera *p;
-
- ASSERT(file);
- for (p=file->cameras; p!=0; p=p->next) {
- lib3ds_camera_dump(p);
- }
-}
-
-
-/*!
- * Insert a new Lib3dsLight object into the lights list of
- * a Lib3dsFile object.
- *
- * The new Lib3dsLight object is inserted into the lights list
- * in alphabetic order by name.
- *
- * \param file The Lib3dsFile object to be modified.
- * \param material The Lib3dsLight object to be inserted into file->lights
- *
- * \ingroup file
- */
-void
-lib3ds_file_insert_light(Lib3dsFile *file, Lib3dsLight *light)
-{
- Lib3dsLight *p,*q;
-
- ASSERT(file);
- ASSERT(light);
- ASSERT(!light->next);
-
- q=0;
- for (p=file->lights; p!=0; p=p->next) {
- if (strcmp(light->name, p->name)<0) {
- break;
- }
- q=p;
- }
- if (!q) {
- light->next=file->lights;
- file->lights=light;
- }
- else {
- light->next=q->next;
- q->next=light;
- }
-}
-
-
-/*!
- * Remove a Lib3dsLight object from the lights list of
- * a Lib3dsFile object.
- *
- * If the Lib3dsLight is not found in the lights list, nothing is done
- * (except that an error log message may be generated.)
- *
- * \param file The Lib3dsFile object to be modified.
- * \param material The Lib3dsLight object to be removed from file->lights
- *
- * \ingroup file
- */
-void
-lib3ds_file_remove_light(Lib3dsFile *file, Lib3dsLight *light)
-{
- Lib3dsLight *p,*q;
-
- ASSERT(file);
- ASSERT(light);
- ASSERT(file->lights);
- for (p=0,q=file->lights; q; p=q,q=q->next) {
- if (q==light) {
- break;
- }
- }
- if (!q) {
- ASSERT(LIB3DS_FALSE);
- return;
- }
- if (!p) {
- file->lights=light->next;
- }
- else {
- p->next=q->next;
- }
- light->next=0;
-}
-
-
-/*!
- * Return a Lib3dsLight object from a Lib3dsFile by name.
- *
- * \param file Lib3dsFile object to be searched.
- * \param name Name of the Lib3dsLight object to be searched for.
- *
- * \return A pointer to the named Lib3dsLight, or NULL if not found.
- *
- * \ingroup file
- */
-Lib3dsLight*
-lib3ds_file_light_by_name(Lib3dsFile *file, const char *name)
-{
- Lib3dsLight *p;
-
- ASSERT(file);
- for (p=file->lights; p!=0; p=p->next) {
- if (strcmp(p->name,name)==0) {
- return(p);
- }
- }
- return(0);
-}
-
-
-/*!
- * Dump all Lib3dsLight objects found in a Lib3dsFile object.
- *
- * \param file Lib3dsFile object to be dumped.
- *
- * \see lib3ds_light_dump
- *
- * \ingroup file
- */
-void
-lib3ds_file_dump_lights(Lib3dsFile *file)
-{
- Lib3dsLight *p;
-
- ASSERT(file);
- for (p=file->lights; p!=0; p=p->next) {
- lib3ds_light_dump(p);
- }
-}
-
-
-/*!
- * Compute the bounding box for Lib3dsFile objects.
- *
- * This function computes the bounding box for all meshes
- * in the Lib3dsFile object. Cameras and lights are not included.
- *
- * \param file The Lib3dsFile object to be examined.
- * \param min Returned minimum x,y,z values.
- * \param max Returned maximum x,y,z values.
- *
- * \ingroup file
- */
-void
-lib3ds_object_bounding_box(Lib3dsFile *file, Lib3dsVector min, Lib3dsVector max)
-{
- {
- Lib3dsVector lmin, lmax;
- Lib3dsMesh *p=file->meshes;
-
- if (p) {
- lib3ds_mesh_bounding_box(p, min, max);
- p = p->next;
- }
- while (p) {
- lib3ds_mesh_bounding_box(p, lmin, lmax);
- lib3ds_vector_min(min, lmin);
- lib3ds_vector_max(max, lmax);
- p=p->next;
- }
- }
-}
-
-
-/*!
- * Compute the bounding box for a Lib3dsFile.
- *
- * This function computes the bounding box for all meshes, cameras,
- * and lights in the Lib3dsFile object.
- *
- * \param file The Lib3dsFile object to be examined.
- * \param min Returned minimum x,y,z values.
- * \param max Returned maximum x,y,z values.
- *
- * \ingroup file
- */
-void
-lib3ds_file_bounding_box(Lib3dsFile *file, Lib3dsVector min, Lib3dsVector max)
-{
- Lib3dsBool init=LIB3DS_FALSE;
-
- {
- Lib3dsVector lmin, lmax;
- Lib3dsMesh *p=file->meshes;
-
- if (!init && p) {
- init = LIB3DS_TRUE;
- lib3ds_mesh_bounding_box(p, min, max);
- p = p->next;
- }
- while (p) {
- lib3ds_mesh_bounding_box(p, lmin, lmax);
- lib3ds_vector_min(min, lmin);
- lib3ds_vector_max(max, lmax);
- p=p->next;
- }
- }
- {
- Lib3dsCamera *p=file->cameras;
- if (!init && p) {
- init = LIB3DS_TRUE;
- lib3ds_vector_copy(min, p->position);
- lib3ds_vector_copy(max, p->position);
- }
-
- while (p) {
- lib3ds_vector_min(min, p->position);
- lib3ds_vector_max(max, p->position);
- lib3ds_vector_min(min, p->target);
- lib3ds_vector_max(max, p->target);
- p=p->next;
- }
- }
- {
- Lib3dsLight *p=file->lights;
- if (!init && p) {
- init = LIB3DS_TRUE;
- lib3ds_vector_copy(min, p->position);
- lib3ds_vector_copy(max, p->position);
- }
-
- while (p) {
- lib3ds_vector_min(min, p->position);
- lib3ds_vector_max(max, p->position);
- if (p->spot_light) {
- lib3ds_vector_min(min, p->spot);
- lib3ds_vector_max(max, p->spot);
- }
- p=p->next;
- }
- }
-}
-
-
-/*!
- * Return a node object by name and type.
- *
- * This function performs a recursive search for the specified node.
- * Both name and type must match.
- *
- * \param file The Lib3dsFile to be searched.
- * \param name The target node name.
- * \param type The target node type
- *
- * \return A pointer to the first matching node, or NULL if not found.
- *
- * \see lib3ds_node_by_name
- *
- * \ingroup file
- */
-Lib3dsNode*
-lib3ds_file_node_by_name(Lib3dsFile *file, const char* name, Lib3dsNodeTypes type)
-{
- Lib3dsNode *p,*q;
-
- ASSERT(file);
- for (p=file->nodes; p!=0; p=p->next) {
- if ((p->type==type) && (strcmp(p->name, name)==0)) {
- return(p);
- }
- q=lib3ds_node_by_name(p, name, type);
- if (q) {
- return(q);
- }
- }
- return(0);
-}
-
-
-/*!
- * Return a node object by id.
- *
- * This function performs a recursive search for the specified node.
- *
- * \param file The Lib3dsFile to be searched.
- * \param node_id The target node id.
- *
- * \return A pointer to the first matching node, or NULL if not found.
- *
- * \see lib3ds_node_by_id
- *
- * \ingroup file
- */
-Lib3dsNode*
-lib3ds_file_node_by_id(Lib3dsFile *file, Lib3dsWord node_id)
-{
- Lib3dsNode *p,*q;
-
- ASSERT(file);
- for (p=file->nodes; p!=0; p=p->next) {
- if (p->node_id==node_id) {
- return(p);
- }
- q=lib3ds_node_by_id(p, node_id);
- if (q) {
- return(q);
- }
- }
- return(0);
-}
-
-
-/*!
- * Insert a new node into a Lib3dsFile object.
- *
- * If the node's parent_id structure is not LIB3DS_NO_PARENT and the
- * specified parent is found inside the Lib3dsFile object, then the
- * node is inserted as a child of that parent. If the parent_id
- * structure is LIB3DS_NO_PARENT or the specified parent is not found,
- * then the node is inserted at the top level.
- *
- * Node is inserted in alphabetic order by name.
- *
- * Finally, if any other top-level nodes in file specify this node as
- * their parent, they are relocated as a child of this node.
- *
- * \param file The Lib3dsFile object to be modified.
- * \param node The node to be inserted into file
- *
- * \ingroup file
- */
-void
-lib3ds_file_insert_node(Lib3dsFile *file, Lib3dsNode *node)
-{
- Lib3dsNode *parent,*p,*n;
-
- ASSERT(node);
- ASSERT(!node->next);
- ASSERT(!node->parent);
-
- parent=0;
- if (node->parent_id!=LIB3DS_NO_PARENT) {
- parent=lib3ds_file_node_by_id(file, node->parent_id);
- }
- node->parent=parent;
-
- if (!parent) {
- for (p=0,n=file->nodes; n!=0; p=n,n=n->next) {
- if (strcmp(n->name, node->name)>0) {
- break;
- }
- }
- if (!p) {
- node->next=file->nodes;
- file->nodes=node;
- }
- else {
- node->next=p->next;
- p->next=node;
- }
- }
- else {
- for (p=0,n=parent->childs; n!=0; p=n,n=n->next) {
- if (strcmp(n->name, node->name)>0) {
- break;
- }
- }
- if (!p) {
- node->next=parent->childs;
- parent->childs=node;
- }
- else {
- node->next=p->next;
- p->next=node;
- }
- }
-
- if (node->node_id!=LIB3DS_NO_PARENT) {
- for (n=file->nodes; n!=0; n=p) {
- p=n->next;
- if (n->parent_id==node->node_id) {
- lib3ds_file_remove_node(file, n);
- lib3ds_file_insert_node(file, n);
- }
- }
- }
-}
-
-
-/*!
- * Remove a node from the a Lib3dsFile object.
- *
- * \param file The Lib3dsFile object to be modified.
- * \param node The Lib3dsNode object to be removed from file
- *
- * \return LIB3DS_TRUE on success, LIB3DS_FALSE if node is not found in file
- *
- * \ingroup file
- */
-Lib3dsBool
-lib3ds_file_remove_node(Lib3dsFile *file, Lib3dsNode *node)
-{
- Lib3dsNode *p,*n;
-
- if (node->parent) {
- for (p=0,n=node->parent->childs; n; p=n,n=n->next) {
- if (n==node) {
- break;
- }
- }
- if (!n) {
- return(LIB3DS_FALSE);
- }
-
- if (!p) {
- node->parent->childs=n->next;
- }
- else {
- p->next=n->next;
- }
- }
- else {
- for (p=0,n=file->nodes; n; p=n,n=n->next) {
- if (n==node) {
- break;
- }
- }
- if (!n) {
- return(LIB3DS_FALSE);
- }
-
- if (!p) {
- file->nodes=n->next;
- }
- else {
- p->next=n->next;
- }
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * Dump all node objects found in a Lib3dsFile object.
- *
- * Nodes are dumped recursively.
- *
- * \param file Lib3dsFile object to be dumped.
- *
- * \see lib3ds_node_dump
- *
- * \ingroup file
- */
-void
-lib3ds_file_dump_nodes(Lib3dsFile *file)
-{
- Lib3dsNode *p;
-
- ASSERT(file);
- for (p=file->nodes; p!=0; p=p->next) {
- lib3ds_node_dump(p,1);
- }
-}
-
-
-/*!
-
-\typedef Lib3dsFile
- \ingroup file
- \sa _Lib3dsFile
-
-*/
-
-
-
-/* Programming trick to force users to compile their source code against the
- * correct headers. The symbol lib3ds_version1_3 will be defined iff the users
- * compile with the current version of <lib3ds/types.h>
- */
-
-/*
-extern int lib3ds_version1_3;
-static const int *lib3ds_version = &lib3ds_version1_3;
-*/
+++ /dev/null
-/* -*- c -*- */
-#ifndef INCLUDED_LIB3DS_FILE_H
-#define INCLUDED_LIB3DS_FILE_H
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: file.h,v 1.19 2005/06/13 11:29:10 madmac Exp $
- */
-/* The symbol LIB3DS_VERSION contains the current version number
- which can be used to check the version at compile time.
- The major, minor and micro version number is encoded as follows:
- Version x.y.z becomes the decimal number xyyzz. */
-#define LIB3DS_VERSION 10300
-
-#ifndef INCLUDED_LIB3DS_BACKGROUND_H
-#include <lib3ds/background.h>
-#endif
-#ifndef INCLUDED_LIB3DS_ATMOSPHERE_H
-#include <lib3ds/atmosphere.h>
-#endif
-#ifndef INCLUDED_LIB3DS_SHADOW_H
-#include <lib3ds/shadow.h>
-#endif
-#ifndef INCLUDED_LIB3DS_VIEWPORT_H
-#include <lib3ds/viewport.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*!
- * 3ds file structure
- * \ingroup file
- */
-struct _Lib3dsFile {
- Lib3dsDword mesh_version;
- Lib3dsWord keyf_revision;
- char name[12+1];
- Lib3dsFloat master_scale;
- Lib3dsVector construction_plane;
- Lib3dsRgb ambient;
- Lib3dsShadow shadow;
- Lib3dsBackground background;
- Lib3dsAtmosphere atmosphere;
- Lib3dsViewport viewport;
- Lib3dsViewport viewport_keyf;
- Lib3dsIntd frames;
- Lib3dsIntd segment_from;
- Lib3dsIntd segment_to;
- Lib3dsIntd current_frame;
- Lib3dsMaterial *materials;
- Lib3dsMesh *meshes;
- Lib3dsCamera *cameras;
- Lib3dsLight *lights;
- Lib3dsNode *nodes;
-};
-
-extern LIB3DSAPI Lib3dsFile* lib3ds_file_load(const char *filename);
-extern LIB3DSAPI Lib3dsBool lib3ds_file_save(Lib3dsFile *file, const char *filename);
-extern LIB3DSAPI Lib3dsFile* lib3ds_file_new();
-extern LIB3DSAPI void lib3ds_file_free(Lib3dsFile *file);
-extern LIB3DSAPI void lib3ds_file_eval(Lib3dsFile *file, Lib3dsFloat t);
-extern LIB3DSAPI Lib3dsBool lib3ds_file_read(Lib3dsFile *file, Lib3dsIo *io);
-extern LIB3DSAPI Lib3dsBool lib3ds_file_write(Lib3dsFile *file, Lib3dsIo *io);
-extern LIB3DSAPI void lib3ds_file_insert_material(Lib3dsFile *file, Lib3dsMaterial *material);
-extern LIB3DSAPI void lib3ds_file_remove_material(Lib3dsFile *file, Lib3dsMaterial *material);
-extern LIB3DSAPI Lib3dsMaterial* lib3ds_file_material_by_name(Lib3dsFile *file, const char *name);
-extern LIB3DSAPI void lib3ds_file_dump_materials(Lib3dsFile *file);
-extern LIB3DSAPI void lib3ds_file_insert_mesh(Lib3dsFile *file, Lib3dsMesh *mesh);
-extern LIB3DSAPI void lib3ds_file_remove_mesh(Lib3dsFile *file, Lib3dsMesh *mesh);
-extern LIB3DSAPI Lib3dsMesh* lib3ds_file_mesh_by_name(Lib3dsFile *file, const char *name);
-extern LIB3DSAPI void lib3ds_file_dump_meshes(Lib3dsFile *file);
-extern LIB3DSAPI void lib3ds_file_dump_instances(Lib3dsFile *file);
-extern LIB3DSAPI void lib3ds_file_insert_camera(Lib3dsFile *file, Lib3dsCamera *camera);
-extern LIB3DSAPI void lib3ds_file_remove_camera(Lib3dsFile *file, Lib3dsCamera *camera);
-extern LIB3DSAPI Lib3dsCamera* lib3ds_file_camera_by_name(Lib3dsFile *file, const char *name);
-extern LIB3DSAPI void lib3ds_file_dump_cameras(Lib3dsFile *file);
-extern LIB3DSAPI void lib3ds_file_insert_light(Lib3dsFile *file, Lib3dsLight *light);
-extern LIB3DSAPI void lib3ds_file_remove_light(Lib3dsFile *file, Lib3dsLight *light);
-extern LIB3DSAPI Lib3dsLight* lib3ds_file_light_by_name(Lib3dsFile *file, const char *name);
-extern LIB3DSAPI void lib3ds_file_dump_lights(Lib3dsFile *file);
-extern LIB3DSAPI Lib3dsNode* lib3ds_file_node_by_name(Lib3dsFile *file, const char* name,
- Lib3dsNodeTypes type);
-extern LIB3DSAPI Lib3dsNode* lib3ds_file_node_by_id(Lib3dsFile *file, Lib3dsWord node_id);
-extern LIB3DSAPI void lib3ds_file_insert_node(Lib3dsFile *file, Lib3dsNode *node);
-extern LIB3DSAPI Lib3dsBool lib3ds_file_remove_node(Lib3dsFile *file, Lib3dsNode *node);
-extern LIB3DSAPI void lib3ds_file_dump_nodes(Lib3dsFile *file);
-extern LIB3DSAPI void lib3ds_object_bounding_box(Lib3dsFile *file,
- Lib3dsVector min, Lib3dsVector max);
-extern LIB3DSAPI void lib3ds_file_bounding_box(Lib3dsFile *file,
- Lib3dsVector min, Lib3dsVector max);
-
-#ifdef __cplusplus
-}
-#endif
-#endif
-
+++ /dev/null
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: float.c,v 1.4 2001/01/12 10:29:17 jeh Exp $
- */
-#define LIB3DS_EXPORT
-#include <lib3ds/float.h>
-
-
-/*!
- * \defgroup float Floating Point Mathematics
- *
- * \author J.E. Hoffmann <je-h@gmx.net>
- */
-
-
-/*!
- * \ingroup float
- */
-Lib3dsFloat
-lib3ds_float_cubic(Lib3dsFloat a, Lib3dsFloat p, Lib3dsFloat q, Lib3dsFloat b, Lib3dsFloat t)
-{
- Lib3dsDouble x,y,z,w;
-
- x=2*t*t*t - 3*t*t + 1;
- y=-2*t*t*t + 3*t*t;
- z=t*t*t - 2*t*t + t;
- w=t*t*t - t*t;
- return((Lib3dsFloat)(x*a + y*b + z*p + w*q));
-}
-
+++ /dev/null
-/* -*- c -*- */
-#ifndef INCLUDED_LIB3DS_FLOAT_H
-#define INCLUDED_LIB3DS_FLOAT_H
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: float.h,v 1.5 2004/12/31 16:17:15 reed Exp $
- */
-
-#ifndef INCLUDED_LIB3DS_TYPES_H
-#include <lib3ds/types.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-extern LIB3DSAPI Lib3dsFloat lib3ds_float_cubic(Lib3dsFloat a, Lib3dsFloat p,
- Lib3dsFloat q, Lib3dsFloat b, Lib3dsFloat t);
-
-#ifdef __cplusplus
-}
-#endif
-#endif
-
+++ /dev/null
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: io.c,v 1.3 2001/07/11 13:47:35 jeh Exp $
- */
-#define LIB3DS_EXPORT
-#include <lib3ds/io.h>
-#include <stdlib.h>
-#include <string.h>
-
-
-/*!
- * \defgroup io Binary Input/Ouput Abstraction Layer
- *
- * \author J.E. Hoffmann <je-h@gmx.net>
- */
-
-
-struct _Lib3dsIo {
- void *self;
- Lib3dsIoErrorFunc error_func;
- Lib3dsIoSeekFunc seek_func;
- Lib3dsIoTellFunc tell_func;
- Lib3dsIoReadFunc read_func;
- Lib3dsIoWriteFunc write_func;
-};
-
-
-Lib3dsIo*
-lib3ds_io_new(void *self, Lib3dsIoErrorFunc error_func, Lib3dsIoSeekFunc seek_func,
- Lib3dsIoTellFunc tell_func, Lib3dsIoReadFunc read_func, Lib3dsIoWriteFunc write_func)
-{
- Lib3dsIo *io = calloc(sizeof(Lib3dsIo),1);
- ASSERT(io);
- if (!io) {
- return 0;
- }
-
- io->self = self;
- io->error_func = error_func;
- io->seek_func = seek_func;
- io->tell_func = tell_func;
- io->read_func = read_func;
- io->write_func = write_func;
-
- return io;
-}
-
-
-void
-lib3ds_io_free(Lib3dsIo *io)
-{
- ASSERT(io);
- if (!io) {
- return;
- }
- free(io);
-}
-
-
-Lib3dsBool
-lib3ds_io_error(Lib3dsIo *io)
-{
- ASSERT(io);
- if (!io || !io->error_func) {
- return 0;
- }
- return (*io->error_func)(io->self);
-}
-
-
-long
-lib3ds_io_seek(Lib3dsIo *io, long offset, Lib3dsIoSeek origin)
-{
- ASSERT(io);
- if (!io || !io->seek_func) {
- return 0;
- }
- return (*io->seek_func)(io->self, offset, origin);
-}
-
-
-long
-lib3ds_io_tell(Lib3dsIo *io)
-{
- ASSERT(io);
- if (!io || !io->tell_func) {
- return 0;
- }
- return (*io->tell_func)(io->self);
-}
-
-
-int
-lib3ds_io_read(Lib3dsIo *io, Lib3dsByte *buffer, int size)
-{
- ASSERT(io);
- if (!io || !io->read_func) {
- return 0;
- }
- return (*io->read_func)(io->self, buffer, size);
-}
-
-
-int
-lib3ds_io_write(Lib3dsIo *io, const Lib3dsByte *buffer, int size)
-{
- ASSERT(io);
- if (!io || !io->write_func) {
- return 0;
- }
- return (*io->write_func)(io->self, buffer, size);
-}
-
-
-/*!
- * \ingroup io
- *
- * Read a byte from a file stream.
- */
-Lib3dsByte
-lib3ds_io_read_byte(Lib3dsIo *io)
-{
- Lib3dsByte b;
-
- ASSERT(io);
- lib3ds_io_read(io, &b, 1);
- return(b);
-}
-
-
-/**
- * Read a word from a file stream in little endian format.
- */
-Lib3dsWord
-lib3ds_io_read_word(Lib3dsIo *io)
-{
- Lib3dsByte b[2];
- Lib3dsWord w;
-
- ASSERT(io);
- lib3ds_io_read(io, b, 2);
- w=((Lib3dsWord)b[1] << 8) |
- ((Lib3dsWord)b[0]);
- return(w);
-}
-
-
-/*!
- * \ingroup io
- *
- * Read a dword from file a stream in little endian format.
- */
-Lib3dsDword
-lib3ds_io_read_dword(Lib3dsIo *io)
-{
- Lib3dsByte b[4];
- Lib3dsDword d;
-
- ASSERT(io);
- lib3ds_io_read(io, b, 4);
- d=((Lib3dsDword)b[3] << 24) |
- ((Lib3dsDword)b[2] << 16) |
- ((Lib3dsDword)b[1] << 8) |
- ((Lib3dsDword)b[0]);
- return(d);
-}
-
-
-/*!
- * \ingroup io
- *
- * Read a signed byte from a file stream.
- */
-Lib3dsIntb
-lib3ds_io_read_intb(Lib3dsIo *io)
-{
- Lib3dsIntb b;
-
- ASSERT(io);
- lib3ds_io_read(io, (Lib3dsByte*)&b, 1);
- return(b);
-}
-
-
-/*!
- * \ingroup io
- *
- * Read a signed word from a file stream in little endian format.
- */
-Lib3dsIntw
-lib3ds_io_read_intw(Lib3dsIo *io)
-{
- Lib3dsByte b[2];
- Lib3dsWord w;
-
- ASSERT(io);
- lib3ds_io_read(io, b, 2);
- w=((Lib3dsWord)b[1] << 8) |
- ((Lib3dsWord)b[0]);
- return((Lib3dsIntw)w);
-}
-
-
-/*!
- * \ingroup io
- *
- * Read a signed dword a from file stream in little endian format.
- */
-Lib3dsIntd
-lib3ds_io_read_intd(Lib3dsIo *io)
-{
- Lib3dsByte b[4];
- Lib3dsDword d;
-
- ASSERT(io);
- lib3ds_io_read(io, b, 4);
- d=((Lib3dsDword)b[3] << 24) |
- ((Lib3dsDword)b[2] << 16) |
- ((Lib3dsDword)b[1] << 8) |
- ((Lib3dsDword)b[0]);
- return((Lib3dsIntd)d);
-}
-
-
-/*!
- * \ingroup io
- *
- * Read a float from a file stream in little endian format.
- */
-Lib3dsFloat
-lib3ds_io_read_float(Lib3dsIo *io)
-{
- Lib3dsByte b[4];
- Lib3dsDword d;
-
- ASSERT(io);
- lib3ds_io_read(io, b, 4);
- d=((Lib3dsDword)b[3] << 24) |
- ((Lib3dsDword)b[2] << 16) |
- ((Lib3dsDword)b[1] << 8) |
- ((Lib3dsDword)b[0]);
- return(*((Lib3dsFloat*)&d));
-}
-
-
-/*!
- * \ingroup io
- * \ingroup vector
- *
- * Read a vector from a file stream in little endian format.
- *
- * \param io IO input handle.
- * \param v The vector to store the data.
- */
-Lib3dsBool
-lib3ds_io_read_vector(Lib3dsIo *io, Lib3dsVector v)
-{
- ASSERT(io);
-
- v[0]=lib3ds_io_read_float(io);
- v[1]=lib3ds_io_read_float(io);
- v[2]=lib3ds_io_read_float(io);
-
- return(!lib3ds_io_error(io));
-}
-
-
-/*!
- * \ingroup io
- */
-Lib3dsBool
-lib3ds_io_read_rgb(Lib3dsIo *io, Lib3dsRgb rgb)
-{
- ASSERT(io);
-
- rgb[0]=lib3ds_io_read_float(io);
- rgb[1]=lib3ds_io_read_float(io);
- rgb[2]=lib3ds_io_read_float(io);
-
- return(!lib3ds_io_error(io));
-}
-
-
-/*!
- * \ingroup io
- *
- * Read a zero-terminated string from a file stream.
- *
- * \param io IO input handle.
- * \param s The buffer to store the read string.
- * \param buflen Buffer length.
- *
- * \return True on success, False otherwise.
- */
-Lib3dsBool
-lib3ds_io_read_string(Lib3dsIo *io, char *s, int buflen)
-{
- char c;
- int k=0;
-
- ASSERT(io);
- for (;;) {
- if (lib3ds_io_read(io, (Lib3dsByte*)&c, 1)!=1) {
- return LIB3DS_FALSE;
- }
- *s++ = c;
- if (!c) {
- break;
- }
- ++k;
- if (k>=buflen) {
- return(LIB3DS_FALSE);
- }
- }
-
- return(!lib3ds_io_error(io));
-}
-
-
-/*!
- * \ingroup io
- *
- * Writes a byte into a file stream.
- */
-Lib3dsBool
-lib3ds_io_write_byte(Lib3dsIo *io, Lib3dsByte b)
-{
- ASSERT(io);
- if (lib3ds_io_write(io, &b, 1)!=1) {
- return(LIB3DS_FALSE);
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup io
- *
- * Writes a word into a little endian file stream.
- */
-Lib3dsBool
-lib3ds_io_write_word(Lib3dsIo *io, Lib3dsWord w)
-{
- Lib3dsByte b[2];
-
- ASSERT(io);
- b[1]=((Lib3dsWord)w & 0xFF00) >> 8;
- b[0]=((Lib3dsWord)w & 0x00FF);
- if (lib3ds_io_write(io, b, 2)!=2) {
- return(LIB3DS_FALSE);
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup io
- *
- * Writes a dword into a little endian file stream.
- */
-Lib3dsBool
-lib3ds_io_write_dword(Lib3dsIo *io, Lib3dsDword d)
-{
- Lib3dsByte b[4];
-
- ASSERT(io);
- b[3]=(Lib3dsByte)(((Lib3dsDword)d & 0xFF000000) >> 24);
- b[2]=(Lib3dsByte)(((Lib3dsDword)d & 0x00FF0000) >> 16);
- b[1]=(Lib3dsByte)(((Lib3dsDword)d & 0x0000FF00) >> 8);
- b[0]=(Lib3dsByte)(((Lib3dsDword)d & 0x000000FF));
- if (lib3ds_io_write(io, b, 4)!=4) {
- return(LIB3DS_FALSE);
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup io
- *
- * Writes a signed byte in a file stream.
- */
-Lib3dsBool
-lib3ds_io_write_intb(Lib3dsIo *io, Lib3dsIntb b)
-{
- ASSERT(io);
- if (lib3ds_io_write(io, (Lib3dsByte*)&b, 1)!=1) {
- return(LIB3DS_FALSE);
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup io
- *
- * Writes a signed word into a little endian file stream.
- */
-Lib3dsBool
-lib3ds_io_write_intw(Lib3dsIo *io, Lib3dsIntw w)
-{
- Lib3dsByte b[2];
-
- ASSERT(io);
- b[1]=((Lib3dsWord)w & 0xFF00) >> 8;
- b[0]=((Lib3dsWord)w & 0x00FF);
- if (lib3ds_io_write(io, b, 2)!=2) {
- return(LIB3DS_FALSE);
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup io
- *
- * Writes a signed dword into a little endian file stream.
- */
-Lib3dsBool
-lib3ds_io_write_intd(Lib3dsIo *io, Lib3dsIntd d)
-{
- Lib3dsByte b[4];
-
- ASSERT(io);
- b[3]=(Lib3dsByte)(((Lib3dsDword)d & 0xFF000000) >> 24);
- b[2]=(Lib3dsByte)(((Lib3dsDword)d & 0x00FF0000) >> 16);
- b[1]=(Lib3dsByte)(((Lib3dsDword)d & 0x0000FF00) >> 8);
- b[0]=(Lib3dsByte)(((Lib3dsDword)d & 0x000000FF));
- if (lib3ds_io_write(io, b, 4)!=4) {
- return(LIB3DS_FALSE);
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup io
- *
- * Writes a float into a little endian file stream.
- */
-Lib3dsBool
-lib3ds_io_write_float(Lib3dsIo *io, Lib3dsFloat l)
-{
- Lib3dsByte b[4];
- Lib3dsDword d;
-
- ASSERT(io);
- d=*((Lib3dsDword*)&l);
- b[3]=(Lib3dsByte)(((Lib3dsDword)d & 0xFF000000) >> 24);
- b[2]=(Lib3dsByte)(((Lib3dsDword)d & 0x00FF0000) >> 16);
- b[1]=(Lib3dsByte)(((Lib3dsDword)d & 0x0000FF00) >> 8);
- b[0]=(Lib3dsByte)(((Lib3dsDword)d & 0x000000FF));
- if (lib3ds_io_write(io, b, 4)!=4) {
- return(LIB3DS_FALSE);
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup io
- * \ingroup vector
- *
- * Writes a vector into a file stream in little endian format.
- */
-Lib3dsBool
-lib3ds_io_write_vector(Lib3dsIo *io, Lib3dsVector v)
-{
- int i;
- for (i=0; i<3; ++i) {
- if (!lib3ds_io_write_float(io, v[i])) {
- return(LIB3DS_FALSE);
- }
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup io
- */
-Lib3dsBool
-lib3ds_io_write_rgb(Lib3dsIo *io, Lib3dsRgb rgb)
-{
- int i;
- for (i=0; i<3; ++i) {
- if (!lib3ds_io_write_float(io, rgb[i])) {
- return(LIB3DS_FALSE);
- }
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup io
- *
- * Writes a zero-terminated string into a file stream.
- */
-Lib3dsBool
-lib3ds_io_write_string(Lib3dsIo *io, const char *s)
-{
- ASSERT(s);
- ASSERT(io);
- lib3ds_io_write(io, (const Lib3dsByte*)s, strlen(s)+1);
- return(!lib3ds_io_error(io));
-}
+++ /dev/null
-/* -*- c -*- */
-#ifndef INCLUDED_LIB3DS_IO_H
-#define INCLUDED_LIB3DS_IO_H
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: io.h,v 1.3 2004/12/31 16:17:15 reed Exp $
- */
-
-#ifndef INCLUDED_LIB3DS_TYPES_H
-#include <lib3ds/types.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef enum _Lib3dsIoSeek {
- LIB3DS_SEEK_SET =0,
- LIB3DS_SEEK_CUR =1,
- LIB3DS_SEEK_END =2
-} Lib3dsIoSeek;
-
-typedef Lib3dsBool (*Lib3dsIoErrorFunc)(void *self);
-typedef long (*Lib3dsIoSeekFunc)(void *self, long offset, Lib3dsIoSeek origin);
-typedef long (*Lib3dsIoTellFunc)(void *self);
-typedef int (*Lib3dsIoReadFunc)(void *self, Lib3dsByte *buffer, int size);
-typedef int (*Lib3dsIoWriteFunc)(void *self, const Lib3dsByte *buffer, int size);
-
-extern LIB3DSAPI Lib3dsIo* lib3ds_io_new(void *self, Lib3dsIoErrorFunc error_func,
- Lib3dsIoSeekFunc seek_func, Lib3dsIoTellFunc tell_func,
- Lib3dsIoReadFunc read_func, Lib3dsIoWriteFunc write_func);
-extern LIB3DSAPI void lib3ds_io_free(Lib3dsIo *io);
-extern LIB3DSAPI Lib3dsBool lib3ds_io_error(Lib3dsIo *io);
-extern LIB3DSAPI long lib3ds_io_seek(Lib3dsIo *io, long offset, Lib3dsIoSeek origin);
-extern LIB3DSAPI long lib3ds_io_tell(Lib3dsIo *io);
-extern LIB3DSAPI int lib3ds_io_read(Lib3dsIo *io, Lib3dsByte *buffer, int size);
-extern LIB3DSAPI int lib3ds_io_write(Lib3dsIo *io, const Lib3dsByte *buffer, int size);
-
-extern LIB3DSAPI Lib3dsByte lib3ds_io_read_byte(Lib3dsIo *io);
-extern LIB3DSAPI Lib3dsWord lib3ds_io_read_word(Lib3dsIo *io);
-extern LIB3DSAPI Lib3dsDword lib3ds_io_read_dword(Lib3dsIo *io);
-extern LIB3DSAPI Lib3dsIntb lib3ds_io_read_intb(Lib3dsIo *io);
-extern LIB3DSAPI Lib3dsIntw lib3ds_io_read_intw(Lib3dsIo *io);
-extern LIB3DSAPI Lib3dsIntd lib3ds_io_read_intd(Lib3dsIo *io);
-extern LIB3DSAPI Lib3dsFloat lib3ds_io_read_float(Lib3dsIo *io);
-extern LIB3DSAPI Lib3dsBool lib3ds_io_read_vector(Lib3dsIo *io, Lib3dsVector v);
-extern LIB3DSAPI Lib3dsBool lib3ds_io_read_rgb(Lib3dsIo *io, Lib3dsRgb rgb);
-extern LIB3DSAPI Lib3dsBool lib3ds_io_read_string(Lib3dsIo *io, char *s, int buflen);
-
-extern LIB3DSAPI Lib3dsBool lib3ds_io_write_byte(Lib3dsIo *io, Lib3dsByte b);
-extern LIB3DSAPI Lib3dsBool lib3ds_io_write_word(Lib3dsIo *io, Lib3dsWord w);
-extern LIB3DSAPI Lib3dsBool lib3ds_io_write_dword(Lib3dsIo *io, Lib3dsDword d);
-extern LIB3DSAPI Lib3dsBool lib3ds_io_write_intb(Lib3dsIo *io, Lib3dsIntb b);
-extern LIB3DSAPI Lib3dsBool lib3ds_io_write_intw(Lib3dsIo *io, Lib3dsIntw w);
-extern LIB3DSAPI Lib3dsBool lib3ds_io_write_intd(Lib3dsIo *io, Lib3dsIntd d);
-extern LIB3DSAPI Lib3dsBool lib3ds_io_write_float(Lib3dsIo *io, Lib3dsFloat l);
-extern LIB3DSAPI Lib3dsBool lib3ds_io_write_vector(Lib3dsIo *io, Lib3dsVector v);
-extern LIB3DSAPI Lib3dsBool lib3ds_io_write_rgb(Lib3dsIo *io, Lib3dsRgb rgb);
-extern LIB3DSAPI Lib3dsBool lib3ds_io_write_string(Lib3dsIo *io, const char *s);
-
-#ifdef __cplusplus
-}
-#endif
-#endif
-
+++ /dev/null
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: light.c,v 1.10 2001/07/11 13:47:35 jeh Exp $
- */
-#define LIB3DS_EXPORT
-#include <lib3ds/light.h>
-#include <lib3ds/chunk.h>
-#include <lib3ds/io.h>
-#include <stdlib.h>
-#include <math.h>
-#include <string.h>
-#ifdef WITH_DMALLOC
-#include <dmalloc.h>
-#endif
-
-
-/*!
- * \defgroup light Lights
- *
- * \author J.E. Hoffmann <je-h@gmx.net>
- */
-/*!
-
-\typedef Lib3dsLight
- \ingroup light
- \sa _Lib3dsLight
-
-*/
-
-
-
-/*!
- * \ingroup light
- */
-Lib3dsLight*
-lib3ds_light_new(const char *name)
-{
- Lib3dsLight *light;
-
- ASSERT(name);
- ASSERT(strlen(name)<64);
-
- light=(Lib3dsLight*)calloc(sizeof(Lib3dsLight), 1);
- if (!light) {
- return(0);
- }
- strcpy(light->name, name);
- return(light);
-}
-
-
-/*!
- * \ingroup light
- */
-void
-lib3ds_light_free(Lib3dsLight *light)
-{
- memset(light, 0, sizeof(Lib3dsLight));
- free(light);
-}
-
-
-/*!
- * \ingroup light
- */
-void
-lib3ds_light_dump(Lib3dsLight *light)
-{
- ASSERT(light);
- printf(" name: %s\n", light->name);
- printf(" spot_light: %s\n", light->spot_light ? "yes" : "no");
- printf(" see_cone: %s\n", light->see_cone ? "yes" : "no");
- printf(" color: (%f, %f, %f)\n",
- light->color[0], light->color[1], light->color[2]);
- printf(" position (%f, %f, %f)\n",
- light->position[0], light->position[1], light->position[2]);
- printf(" spot (%f, %f, %f)\n",
- light->spot[0], light->spot[1], light->spot[2]);
- printf(" roll: %f\n", light->roll);
- printf(" off: %s\n", light->off ? "yes" : "no");
- printf(" outer_range: %f\n", light->outer_range);
- printf(" inner_range: %f\n", light->inner_range);
- printf(" multiplier: %f\n", light->multiplier);
- printf(" attenuation: %f\n", light->attenuation);
- printf(" rectangular_spot: %s\n", light->rectangular_spot ? "yes" : "no");
- printf(" shadowed: %s\n", light->shadowed ? "yes" : "no");
- printf(" shadow_bias: %f\n", light->shadow_bias);
- printf(" shadow_filter: %f\n", light->shadow_filter);
- printf(" shadow_size: %d\n", light->shadow_size);
- printf(" spot_aspect: %f\n", light->spot_aspect);
- printf(" use_projector: %s\n", light->use_projector ? "yes" : "no");
- printf(" projector: %s\n", light->projector);
- printf(" spot_overshoot: %d\n", (int)light->spot_overshoot);
- printf(" ray_shadows: %s\n", light->ray_shadows ? "yes" : "no");
- printf(" ray_bias: %f\n", light->ray_bias);
- printf(" hot_spot: %f\n", light->hot_spot);
- printf(" fall_off: %f\n", light->fall_off);
- printf("\n");
-}
-
-
-/*!
- * \ingroup light
- */
-static Lib3dsBool
-spotlight_read(Lib3dsLight *light, Lib3dsIo *io)
-{
- Lib3dsChunk c;
- Lib3dsWord chunk;
- int i;
-
- if (!lib3ds_chunk_read_start(&c, LIB3DS_DL_SPOTLIGHT, io)) {
- return(LIB3DS_FALSE);
- }
- light->spot_light=LIB3DS_TRUE;
- for (i=0; i<3; ++i) {
- light->spot[i]=lib3ds_io_read_float(io);
- }
- light->hot_spot = lib3ds_io_read_float(io);
- light->fall_off = lib3ds_io_read_float(io);
- lib3ds_chunk_read_tell(&c, io);
-
- while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
- switch (chunk) {
- case LIB3DS_DL_SPOT_ROLL:
- {
- light->roll=lib3ds_io_read_float(io);
- }
- break;
- case LIB3DS_DL_SHADOWED:
- {
- light->shadowed=LIB3DS_TRUE;
- }
- break;
- case LIB3DS_DL_LOCAL_SHADOW2:
- {
- light->shadow_bias=lib3ds_io_read_float(io);
- light->shadow_filter=lib3ds_io_read_float(io);
- light->shadow_size=lib3ds_io_read_intw(io);
- }
- break;
- case LIB3DS_DL_SEE_CONE:
- {
- light->see_cone=LIB3DS_TRUE;
- }
- break;
- case LIB3DS_DL_SPOT_RECTANGULAR:
- {
- light->rectangular_spot=LIB3DS_TRUE;
- }
- break;
- case LIB3DS_DL_SPOT_ASPECT:
- {
- light->spot_aspect=lib3ds_io_read_float(io);
- }
- break;
- case LIB3DS_DL_SPOT_PROJECTOR:
- {
- light->use_projector=LIB3DS_TRUE;
- if (!lib3ds_io_read_string(io, light->projector, 64)) {
- return(LIB3DS_FALSE);
- }
- }
- case LIB3DS_DL_SPOT_OVERSHOOT:
- {
- light->spot_overshoot=LIB3DS_TRUE;
- }
- break;
- case LIB3DS_DL_RAY_BIAS:
- {
- light->ray_bias=lib3ds_io_read_float(io);
- }
- break;
- case LIB3DS_DL_RAYSHAD:
- {
- light->ray_shadows=LIB3DS_TRUE;
- }
- break;
- default:
- lib3ds_chunk_unknown(chunk);
- }
- }
-
- lib3ds_chunk_read_end(&c, io);
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup light
- */
-Lib3dsBool
-lib3ds_light_read(Lib3dsLight *light, Lib3dsIo *io)
-{
- Lib3dsChunk c;
- Lib3dsWord chunk;
-
- if (!lib3ds_chunk_read_start(&c, LIB3DS_N_DIRECT_LIGHT, io)) {
- return(LIB3DS_FALSE);
- }
- {
- int i;
- for (i=0; i<3; ++i) {
- light->position[i]=lib3ds_io_read_float(io);
- }
- }
- lib3ds_chunk_read_tell(&c, io);
-
- while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
- switch (chunk) {
- case LIB3DS_COLOR_F:
- {
- int i;
- for (i=0; i<3; ++i) {
- light->color[i]=lib3ds_io_read_float(io);
- }
- }
- break;
- case LIB3DS_DL_OFF:
- {
- light->off=LIB3DS_TRUE;
- }
- break;
- case LIB3DS_DL_OUTER_RANGE:
- {
- light->outer_range=lib3ds_io_read_float(io);
- }
- break;
- case LIB3DS_DL_INNER_RANGE:
- {
- light->inner_range=lib3ds_io_read_float(io);
- }
- break;
- case LIB3DS_DL_MULTIPLIER:
- {
- light->multiplier=lib3ds_io_read_float(io);
- }
- break;
- case LIB3DS_DL_EXCLUDE:
- {
- /* FIXME: */
- lib3ds_chunk_unknown(chunk);
- }
- case LIB3DS_DL_ATTENUATE:
- {
- light->attenuation=lib3ds_io_read_float(io);
- }
- break;
- case LIB3DS_DL_SPOTLIGHT:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!spotlight_read(light, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- default:
- lib3ds_chunk_unknown(chunk);
- }
- }
-
- lib3ds_chunk_read_end(&c, io);
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup light
- */
-Lib3dsBool
-lib3ds_light_write(Lib3dsLight *light, Lib3dsIo *io)
-{
- Lib3dsChunk c;
-
- c.chunk=LIB3DS_N_DIRECT_LIGHT;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
- lib3ds_io_write_vector(io, light->position);
- { /*---- LIB3DS_COLOR_F ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_COLOR_F;
- c.size=18;
- lib3ds_chunk_write(&c, io);
- lib3ds_io_write_rgb(io, light->color);
- }
- if (light->off) { /*---- LIB3DS_DL_OFF ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_DL_OFF;
- c.size=6;
- lib3ds_chunk_write(&c, io);
- }
- { /*---- LIB3DS_DL_OUTER_RANGE ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_DL_OUTER_RANGE;
- c.size=10;
- lib3ds_chunk_write(&c, io);
- lib3ds_io_write_float(io, light->outer_range);
- }
- { /*---- LIB3DS_DL_INNER_RANGE ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_DL_INNER_RANGE;
- c.size=10;
- lib3ds_chunk_write(&c, io);
- lib3ds_io_write_float(io, light->inner_range);
- }
- { /*---- LIB3DS_DL_MULTIPLIER ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_DL_MULTIPLIER;
- c.size=10;
- lib3ds_chunk_write(&c, io);
- lib3ds_io_write_float(io, light->multiplier);
- }
- if (light->attenuation) { /*---- LIB3DS_DL_ATTENUATE ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_DL_ATTENUATE;
- c.size=6;
- lib3ds_chunk_write(&c, io);
- }
-
- if (light->spot_light) {
- Lib3dsChunk c;
-
- c.chunk=LIB3DS_DL_SPOTLIGHT;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
- lib3ds_io_write_vector(io, light->spot);
- lib3ds_io_write_float(io, light->hot_spot);
- lib3ds_io_write_float(io, light->fall_off);
-
- { /*---- LIB3DS_DL_SPOT_ROLL ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_DL_SPOT_ROLL;
- c.size=10;
- lib3ds_chunk_write(&c, io);
- lib3ds_io_write_float(io, light->roll);
- }
- if (light->shadowed) { /*---- LIB3DS_DL_SHADOWED ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_DL_SHADOWED;
- c.size=6;
- lib3ds_chunk_write(&c, io);
- }
- if ((fabs(light->shadow_bias)>LIB3DS_EPSILON) ||
- (fabs(light->shadow_filter)>LIB3DS_EPSILON) ||
- (light->shadow_size!=0)) { /*---- LIB3DS_DL_LOCAL_SHADOW2 ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_DL_LOCAL_SHADOW2;
- c.size=16;
- lib3ds_chunk_write(&c, io);
- lib3ds_io_write_float(io, light->shadow_bias);
- lib3ds_io_write_float(io, light->shadow_filter);
- lib3ds_io_write_intw(io, light->shadow_size);
- }
- if (light->see_cone) { /*---- LIB3DS_DL_SEE_CONE ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_DL_SEE_CONE;
- c.size=6;
- lib3ds_chunk_write(&c, io);
- }
- if (light->rectangular_spot) { /*---- LIB3DS_DL_SPOT_RECTANGULAR ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_DL_SPOT_RECTANGULAR;
- c.size=6;
- lib3ds_chunk_write(&c, io);
- }
- if (fabs(light->spot_aspect)>LIB3DS_EPSILON) { /*---- LIB3DS_DL_SPOT_ASPECT ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_DL_SPOT_ASPECT;
- c.size=10;
- lib3ds_chunk_write(&c, io);
- lib3ds_io_write_float(io, light->spot_aspect);
- }
- if (light->use_projector) { /*---- LIB3DS_DL_SPOT_PROJECTOR ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_DL_SPOT_PROJECTOR;
- c.size=10;
- lib3ds_chunk_write(&c, io);
- lib3ds_io_write_string(io, light->projector);
- }
- if (light->spot_overshoot) { /*---- LIB3DS_DL_SPOT_OVERSHOOT ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_DL_SPOT_OVERSHOOT;
- c.size=6;
- lib3ds_chunk_write(&c, io);
- }
- if (fabs(light->ray_bias)>LIB3DS_EPSILON) { /*---- LIB3DS_DL_RAY_BIAS ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_DL_RAY_BIAS;
- c.size=10;
- lib3ds_chunk_write(&c, io);
- lib3ds_io_write_float(io, light->ray_bias);
- }
- if (light->ray_shadows) { /*---- LIB3DS_DL_RAYSHAD ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_DL_RAYSHAD;
- c.size=6;
- lib3ds_chunk_write(&c, io);
- }
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- }
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- return(LIB3DS_TRUE);
-}
-
-
+++ /dev/null
-/* -*- c -*- */
-#ifndef INCLUDED_LIB3DS_LIGHT_H
-#define INCLUDED_LIB3DS_LIGHT_H
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: light.h,v 1.10 2004/12/31 16:17:15 reed Exp $
- */
-
-#ifndef INCLUDED_LIB3DS_TYPES_H
-#include <lib3ds/types.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*!
- * Light
- * \ingroup light
- */
-struct _Lib3dsLight {
- Lib3dsLight *next;
- char name[64];
- Lib3dsBool spot_light;
- Lib3dsBool see_cone;
- Lib3dsRgb color;
- Lib3dsVector position;
- Lib3dsVector spot;
- Lib3dsFloat roll;
- Lib3dsBool off;
- Lib3dsFloat outer_range;
- Lib3dsFloat inner_range;
- Lib3dsFloat multiplier;
- /*const char** excludes;*/
- Lib3dsFloat attenuation;
- Lib3dsBool rectangular_spot;
- Lib3dsBool shadowed;
- Lib3dsFloat shadow_bias;
- Lib3dsFloat shadow_filter;
- Lib3dsIntw shadow_size;
- Lib3dsFloat spot_aspect;
- Lib3dsBool use_projector;
- char projector[64];
- Lib3dsIntd spot_overshoot;
- Lib3dsBool ray_shadows;
- Lib3dsFloat ray_bias;
- Lib3dsFloat hot_spot;
- Lib3dsFloat fall_off;
-};
-
-extern LIB3DSAPI Lib3dsLight* lib3ds_light_new(const char *name);
-extern LIB3DSAPI void lib3ds_light_free(Lib3dsLight *mesh);
-extern LIB3DSAPI void lib3ds_light_dump(Lib3dsLight *light);
-extern LIB3DSAPI Lib3dsBool lib3ds_light_read(Lib3dsLight *light, Lib3dsIo *io);
-extern LIB3DSAPI Lib3dsBool lib3ds_light_write(Lib3dsLight *light, Lib3dsIo *io);
-
-#ifdef __cplusplus
-}
-#endif
-#endif
-
+++ /dev/null
-lib3ds_obj = \
- libs/lib3ds/atmosphere.o \
- libs/lib3ds/background.o \
- libs/lib3ds/camera.o \
- libs/lib3ds/chunk.o \
- libs/lib3ds/ease.o \
- libs/lib3ds/file.o \
- libs/lib3ds/float.o \
- libs/lib3ds/io.o \
- libs/lib3ds/light.o \
- libs/lib3ds/material.o \
- libs/lib3ds/matrix.o \
- libs/lib3ds/mesh.o \
- libs/lib3ds/node.o \
- libs/lib3ds/quat.o \
- libs/lib3ds/shadow.o \
- libs/lib3ds/tcb.o \
- libs/lib3ds/tracks.o \
- libs/lib3ds/vector.o \
- libs/lib3ds/viewport.o
+++ /dev/null
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: material.c,v 1.18 2004/11/20 08:31:31 efalk Exp $
- */
-#define LIB3DS_EXPORT
-#include <lib3ds/material.h>
-#include <lib3ds/chunk.h>
-#include <lib3ds/io.h>
-#include <stdlib.h>
-#include <math.h>
-#include <string.h>
-#ifdef WITH_DMALLOC
-#include <dmalloc.h>
-#endif
-
-
-/*!
- * \defgroup material Materials
- *
- * \author J.E. Hoffmann <je-h@gmx.net>
- */
-
-
-static void
-initialize_texture_map(Lib3dsTextureMap *map)
-{
- map->flags = 0x10;
- map->percent = 1.0f;
- map->scale[0] = 1.0f;
- map->scale[1] = 1.0f;
-}
-
-
-/*!
- * Creates and returns a new, empty Lib3dsMaterial object.
- *
- * Initial value of the material is a shiny grey.
- *
- * \return A pointer to the Lib3dsMaterial structure.
- * If the structure cannot be allocated, NULL is returned.
- *
- * \ingroup material
- */
-Lib3dsMaterial*
-lib3ds_material_new()
-{
- Lib3dsMaterial *mat;
-
- mat = (Lib3dsMaterial*)calloc(sizeof(Lib3dsMaterial), 1);
- if (!mat) {
- return(0);
- }
-
- mat->ambient[0] = mat->ambient[1] = mat->ambient[2] = 0.588235f;
- mat->diffuse[0] = mat->diffuse[1] = mat->diffuse[2] = 0.588235f;
- mat->specular[0] = mat->specular[1] = mat->specular[2] = 0.898039f;
- mat->shininess = 0.1f;
- mat->wire_size = 1.0f;
- mat->shading = 3;
-
- initialize_texture_map(&mat->texture1_map);
- initialize_texture_map(&mat->texture1_mask);
- initialize_texture_map(&mat->texture2_map);
- initialize_texture_map(&mat->texture2_mask);
- initialize_texture_map(&mat->opacity_map);
- initialize_texture_map(&mat->opacity_mask);
- initialize_texture_map(&mat->bump_map);
- initialize_texture_map(&mat->bump_mask);
- initialize_texture_map(&mat->specular_map);
- initialize_texture_map(&mat->specular_mask);
- initialize_texture_map(&mat->shininess_map);
- initialize_texture_map(&mat->shininess_mask);
- initialize_texture_map(&mat->self_illum_map);
- initialize_texture_map(&mat->self_illum_mask);
- initialize_texture_map(&mat->reflection_map);
- initialize_texture_map(&mat->reflection_mask);
-
- return(mat);
-}
-
-
-/*!
- * \ingroup material
- */
-void
-lib3ds_material_free(Lib3dsMaterial *material)
-{
- memset(material, 0, sizeof(Lib3dsMaterial));
- free(material);
-}
-
-
-static Lib3dsBool
-color_read(Lib3dsRgba rgb, Lib3dsIo *io)
-{
- Lib3dsChunk c;
- Lib3dsWord chunk;
- Lib3dsBool have_lin=LIB3DS_FALSE;
-
- if (!lib3ds_chunk_read_start(&c, 0, io)) {
- return(LIB3DS_FALSE);
- }
-
- while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
- switch (chunk) {
- case LIB3DS_LIN_COLOR_24:
- {
- int i;
- for (i=0; i<3; ++i) {
- rgb[i]=1.0f*lib3ds_io_read_byte(io)/255.0f;
- }
- rgb[3]=1.0f;
- }
- have_lin=LIB3DS_TRUE;
- break;
- case LIB3DS_COLOR_24:
- /* gamma corrected color chunk
- replaced in 3ds R3 by LIN_COLOR_24 */
- if (!have_lin) {
- int i;
- for (i=0; i<3; ++i) {
- rgb[i]=1.0f*lib3ds_io_read_byte(io)/255.0f;
- }
- rgb[3]=1.0f;
- }
- break;
- default:
- lib3ds_chunk_unknown(chunk);
- }
- }
-
- lib3ds_chunk_read_end(&c, io);
- return(LIB3DS_TRUE);
-}
-
-
-static Lib3dsBool
-int_percentage_read(Lib3dsFloat *p, Lib3dsIo *io)
-{
- Lib3dsChunk c;
- Lib3dsWord chunk;
-
- if (!lib3ds_chunk_read_start(&c, 0, io)) {
- return(LIB3DS_FALSE);
- }
-
- while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
- switch (chunk) {
- case LIB3DS_INT_PERCENTAGE:
- {
- Lib3dsIntw i=lib3ds_io_read_intw(io);
- *p=(Lib3dsFloat)(1.0*i/100.0);
- }
- break;
- default:
- lib3ds_chunk_unknown(chunk);
- }
- }
-
- lib3ds_chunk_read_end(&c, io);
- return(LIB3DS_TRUE);
-}
-
-
-static Lib3dsBool
-texture_map_read(Lib3dsTextureMap *map, Lib3dsIo *io)
-{
- Lib3dsChunk c;
- Lib3dsWord chunk;
-
- if (!lib3ds_chunk_read_start(&c, 0, io)) {
- return(LIB3DS_FALSE);
- }
-
- while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
- switch (chunk) {
- case LIB3DS_INT_PERCENTAGE:
- {
- map->percent=1.0f*lib3ds_io_read_intw(io)/100.0f;
- }
- break;
- case LIB3DS_MAT_MAPNAME:
- {
- if (!lib3ds_io_read_string(io, map->name, 64)) {
- return(LIB3DS_FALSE);
- }
- lib3ds_chunk_dump_info(" NAME=%s", map->name);
- }
- break;
- case LIB3DS_MAT_MAP_TILING:
- {
- map->flags=lib3ds_io_read_word(io);
- }
- break;
- case LIB3DS_MAT_MAP_TEXBLUR:
- {
- map->blur=lib3ds_io_read_float(io);
- }
- break;
- case LIB3DS_MAT_MAP_USCALE:
- {
- map->scale[0]=lib3ds_io_read_float(io);
- }
- break;
- case LIB3DS_MAT_MAP_VSCALE:
- {
- map->scale[1]=lib3ds_io_read_float(io);
- }
- break;
- case LIB3DS_MAT_MAP_UOFFSET:
- {
- map->offset[0]=lib3ds_io_read_float(io);
- }
- break;
- case LIB3DS_MAT_MAP_VOFFSET:
- {
- map->offset[1]=lib3ds_io_read_float(io);
- }
- break;
- case LIB3DS_MAT_MAP_ANG:
- {
- map->rotation=lib3ds_io_read_float(io);
- }
- break;
- case LIB3DS_MAT_MAP_COL1:
- {
- map->tint_1[0]=1.0f*lib3ds_io_read_byte(io)/255.0f;
- map->tint_1[1]=1.0f*lib3ds_io_read_byte(io)/255.0f;
- map->tint_1[2]=1.0f*lib3ds_io_read_byte(io)/255.0f;
- }
- break;
- case LIB3DS_MAT_MAP_COL2:
- {
- map->tint_2[0]=1.0f*lib3ds_io_read_byte(io)/255.0f;
- map->tint_2[1]=1.0f*lib3ds_io_read_byte(io)/255.0f;
- map->tint_2[2]=1.0f*lib3ds_io_read_byte(io)/255.0f;
- }
- break;
- case LIB3DS_MAT_MAP_RCOL:
- {
- map->tint_r[0]=1.0f*lib3ds_io_read_byte(io)/255.0f;
- map->tint_r[1]=1.0f*lib3ds_io_read_byte(io)/255.0f;
- map->tint_r[2]=1.0f*lib3ds_io_read_byte(io)/255.0f;
- }
- break;
- case LIB3DS_MAT_MAP_GCOL:
- {
- map->tint_g[0]=1.0f*lib3ds_io_read_byte(io)/255.0f;
- map->tint_g[1]=1.0f*lib3ds_io_read_byte(io)/255.0f;
- map->tint_g[2]=1.0f*lib3ds_io_read_byte(io)/255.0f;
- }
- break;
- case LIB3DS_MAT_MAP_BCOL:
- {
- map->tint_b[0]=1.0f*lib3ds_io_read_byte(io)/255.0f;
- map->tint_b[1]=1.0f*lib3ds_io_read_byte(io)/255.0f;
- map->tint_b[2]=1.0f*lib3ds_io_read_byte(io)/255.0f;
- }
- break;
- default:
- lib3ds_chunk_unknown(chunk);
- }
- }
-
- lib3ds_chunk_read_end(&c, io);
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup material
- */
-static void
-texture_dump(const char *maptype, Lib3dsTextureMap *texture)
-{
- ASSERT(texture);
- if (strlen(texture->name)==0) {
- return;
- }
- printf(" %s:\n", maptype);
- printf(" name: %s\n", texture->name);
- printf(" flags: %X\n", (unsigned)texture->flags);
- printf(" percent: %f\n", texture->percent);
- printf(" blur: %f\n", texture->blur);
- printf(" scale: (%f, %f)\n", texture->scale[0], texture->scale[1]);
- printf(" offset: (%f, %f)\n", texture->offset[0], texture->offset[1]);
- printf(" rotation: %f\n", texture->rotation);
- printf(" tint_1: (%f, %f, %f)\n",
- texture->tint_1[0], texture->tint_1[1], texture->tint_1[2]);
- printf(" tint_2: (%f, %f, %f)\n",
- texture->tint_2[0], texture->tint_2[1], texture->tint_2[2]);
- printf(" tint_r: (%f, %f, %f)\n",
- texture->tint_r[0], texture->tint_r[1], texture->tint_r[2]);
- printf(" tint_g: (%f, %f, %f)\n",
- texture->tint_g[0], texture->tint_g[1], texture->tint_g[2]);
- printf(" tint_b: (%f, %f, %f)\n",
- texture->tint_b[0], texture->tint_b[1], texture->tint_b[2]);
-}
-
-
-/*!
- * \ingroup material
- */
-void
-lib3ds_material_dump(Lib3dsMaterial *material)
-{
- ASSERT(material);
- printf(" name: %s\n", material->name);
- printf(" ambient: (%f, %f, %f)\n",
- material->ambient[0], material->ambient[1], material->ambient[2]);
- printf(" diffuse: (%f, %f, %f)\n",
- material->diffuse[0], material->diffuse[1], material->diffuse[2]);
- printf(" specular: (%f, %f, %f)\n",
- material->specular[0], material->specular[1], material->specular[2]);
- printf(" shininess: %f\n", material->shininess);
- printf(" shin_strength: %f\n", material->shin_strength);
- printf(" use_blur: %s\n", material->use_blur ? "yes" : "no");
- printf(" blur: %f\n", material->blur);
- printf(" falloff: %f\n", material->falloff);
- printf(" additive: %s\n", material->additive ? "yes" : "no");
- printf(" use_falloff: %s\n", material->use_falloff ? "yes" : "no");
- printf(" self_illum: %s\n", material->self_illum ? "yes" : "no");
- printf(" self_ilpct: %f\n", material->self_ilpct);
- printf(" shading: %d\n", material->shading);
- printf(" soften: %s\n", material->soften ? "yes" : "no");
- printf(" face_map: %s\n", material->face_map ? "yes" : "no");
- printf(" two_sided: %s\n", material->two_sided ? "yes" : "no");
- printf(" map_decal: %s\n", material->map_decal ? "yes" : "no");
- printf(" use_wire: %s\n", material->use_wire ? "yes" : "no");
- printf(" use_wire_abs: %s\n", material->use_wire_abs ? "yes" : "no");
- printf(" wire_size: %f\n", material->wire_size);
- texture_dump("texture1_map", &material->texture1_map);
- texture_dump("texture1_mask", &material->texture1_mask);
- texture_dump("texture2_map", &material->texture2_map);
- texture_dump("texture2_mask", &material->texture2_mask);
- texture_dump("opacity_map", &material->opacity_map);
- texture_dump("opacity_mask", &material->opacity_mask);
- texture_dump("bump_map", &material->bump_map);
- texture_dump("bump_mask", &material->bump_mask);
- texture_dump("specular_map", &material->specular_map);
- texture_dump("specular_mask", &material->specular_mask);
- texture_dump("shininess_map", &material->shininess_map);
- texture_dump("shininess_mask", &material->shininess_mask);
- texture_dump("self_illum_map", &material->self_illum_map);
- texture_dump("self_illum_mask", &material->self_illum_mask);
- texture_dump("reflection_map", &material->reflection_map);
- texture_dump("reflection_mask", &material->reflection_mask);
- printf(" autorefl_map:\n");
- printf(" flags %X\n", (unsigned)material->autorefl_map.flags);
- printf(" level %d\n", (int)material->autorefl_map.level);
- printf(" size %d\n", (int)material->autorefl_map.size);
- printf(" frame_step %d\n", (int)material->autorefl_map.frame_step);
- printf("\n");
-}
-
-
-/*!
- * \ingroup material
- */
-Lib3dsBool
-lib3ds_material_read(Lib3dsMaterial *material, Lib3dsIo *io)
-{
- Lib3dsChunk c;
- Lib3dsWord chunk;
-
- ASSERT(material);
- if (!lib3ds_chunk_read_start(&c, LIB3DS_MAT_ENTRY, io)) {
- return(LIB3DS_FALSE);
- }
-
- while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
- switch (chunk) {
- case LIB3DS_MAT_NAME:
- {
- if (!lib3ds_io_read_string(io, material->name, 64)) {
- return(LIB3DS_FALSE);
- }
- lib3ds_chunk_dump_info(" NAME=%s", material->name);
- }
- break;
- case LIB3DS_MAT_AMBIENT:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!color_read(material->ambient, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_MAT_DIFFUSE:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!color_read(material->diffuse, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_MAT_SPECULAR:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!color_read(material->specular, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_MAT_SHININESS:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!int_percentage_read(&material->shininess, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_MAT_SHIN2PCT:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!int_percentage_read(&material->shin_strength, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_MAT_TRANSPARENCY:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!int_percentage_read(&material->transparency, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_MAT_XPFALL:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!int_percentage_read(&material->falloff, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_MAT_SELF_ILPCT:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!int_percentage_read(&material->self_ilpct, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_MAT_USE_XPFALL:
- {
- material->use_falloff=LIB3DS_TRUE;
- }
- break;
- case LIB3DS_MAT_REFBLUR:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!int_percentage_read(&material->blur, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_MAT_USE_REFBLUR:
- {
- material->use_blur=LIB3DS_TRUE;
- }
- break;
- case LIB3DS_MAT_SHADING:
- {
- material->shading=lib3ds_io_read_intw(io);
- }
- break;
- case LIB3DS_MAT_SELF_ILLUM:
- {
- material->self_illum=LIB3DS_TRUE;
- }
- break;
- case LIB3DS_MAT_TWO_SIDE:
- {
- material->two_sided=LIB3DS_TRUE;
- }
- break;
- case LIB3DS_MAT_DECAL:
- {
- material->map_decal=LIB3DS_TRUE;
- }
- break;
- case LIB3DS_MAT_ADDITIVE:
- {
- material->additive=LIB3DS_TRUE;
- }
- break;
- case LIB3DS_MAT_FACEMAP:
- {
- material->face_map=LIB3DS_TRUE;
- }
- break;
- case LIB3DS_MAT_PHONGSOFT:
- {
- material->soften=LIB3DS_TRUE;
- }
- break;
- case LIB3DS_MAT_WIRE:
- {
- material->use_wire=LIB3DS_TRUE;
- }
- break;
- case LIB3DS_MAT_WIREABS:
- {
- material->use_wire_abs=LIB3DS_TRUE;
- }
- break;
- case LIB3DS_MAT_WIRE_SIZE:
- {
- material->wire_size=lib3ds_io_read_float(io);
- }
- break;
- case LIB3DS_MAT_TEXMAP:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!texture_map_read(&material->texture1_map, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_MAT_TEXMASK:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!texture_map_read(&material->texture1_mask, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_MAT_TEX2MAP:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!texture_map_read(&material->texture2_map, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_MAT_TEX2MASK:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!texture_map_read(&material->texture2_mask, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_MAT_OPACMAP:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!texture_map_read(&material->opacity_map, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_MAT_OPACMASK:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!texture_map_read(&material->opacity_mask, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_MAT_BUMPMAP:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!texture_map_read(&material->bump_map, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_MAT_BUMPMASK:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!texture_map_read(&material->bump_mask, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_MAT_SPECMAP:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!texture_map_read(&material->specular_map, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_MAT_SPECMASK:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!texture_map_read(&material->specular_mask, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_MAT_SHINMAP:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!texture_map_read(&material->shininess_map, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_MAT_SHINMASK:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!texture_map_read(&material->shininess_mask, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_MAT_SELFIMAP:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!texture_map_read(&material->self_illum_map, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_MAT_SELFIMASK:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!texture_map_read(&material->self_illum_mask, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_MAT_REFLMAP:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!texture_map_read(&material->reflection_map, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_MAT_REFLMASK:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!texture_map_read(&material->reflection_mask, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_MAT_ACUBIC:
- {
- lib3ds_io_read_intb(io);
- material->autorefl_map.level=lib3ds_io_read_intb(io);
- material->autorefl_map.flags=lib3ds_io_read_intw(io);
- material->autorefl_map.size=lib3ds_io_read_intd(io);
- material->autorefl_map.frame_step=lib3ds_io_read_intd(io);
- }
- break;
- default:
- lib3ds_chunk_unknown(chunk);
- }
- }
-
- lib3ds_chunk_read_end(&c, io);
- return(LIB3DS_TRUE);
-}
-
-
-static Lib3dsBool
-color_write(Lib3dsRgba rgb, Lib3dsIo *io)
-{
- Lib3dsChunk c;
-
- c.chunk=LIB3DS_COLOR_24;
- c.size=9;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*rgb[0]+0.5));
- lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*rgb[1]+0.5));
- lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*rgb[2]+0.5));
-
- c.chunk=LIB3DS_LIN_COLOR_24;
- c.size=9;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*rgb[0]+0.5));
- lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*rgb[1]+0.5));
- lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*rgb[2]+0.5));
-
- return(LIB3DS_TRUE);
-}
-
-
-static Lib3dsBool
-int_percentage_write(Lib3dsFloat p, Lib3dsIo *io)
-{
- Lib3dsChunk c;
-
- c.chunk=LIB3DS_INT_PERCENTAGE;
- c.size=8;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_intw(io, (Lib3dsByte)floor(100.0*p+0.5));
-
- return(LIB3DS_TRUE);
-}
-
-
-static Lib3dsBool
-texture_map_write(Lib3dsWord chunk, Lib3dsTextureMap *map, Lib3dsIo *io)
-{
- Lib3dsChunk c;
-
- if (strlen(map->name)==0) {
- return(LIB3DS_TRUE);
- }
- c.chunk=chunk;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
-
- int_percentage_write(map->percent,io);
-
- { /*---- LIB3DS_MAT_MAPNAME ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_MAPNAME;
- c.size=6+strlen(map->name)+1;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_string(io, map->name);
- }
-
- { /*---- LIB3DS_MAT_MAP_TILING ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_MAP_TILING;
- c.size=8;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_word(io, (Lib3dsWord)map->flags);
- }
-
- { /*---- LIB3DS_MAT_MAP_TEXBLUR ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_MAP_TEXBLUR;
- c.size=10;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_float(io, map->blur);
- }
-
- { /*---- LIB3DS_MAT_MAP_USCALE ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_MAP_USCALE;
- c.size=10;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_float(io, map->scale[0]);
- }
-
- { /*---- LIB3DS_MAT_MAP_VSCALE ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_MAP_VSCALE;
- c.size=10;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_float(io, map->scale[1]);
- }
-
- { /*---- LIB3DS_MAT_MAP_UOFFSET ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_MAP_UOFFSET;
- c.size=10;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_float(io, map->offset[0]);
- }
-
- { /*---- LIB3DS_MAT_MAP_VOFFSET ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_MAP_VOFFSET;
- c.size=10;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_float(io, map->offset[1]);
- }
-
- { /*---- LIB3DS_MAT_MAP_ANG ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_MAP_ANG;
- c.size=10;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_float(io, map->rotation);
- }
-
- { /*---- LIB3DS_MAT_MAP_COL1 ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_MAP_COL1;
- c.size=9;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_1[0]+0.5));
- lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_1[1]+0.5));
- lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_1[2]+0.5));
- }
-
- { /*---- LIB3DS_MAT_MAP_COL2 ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_MAP_COL2;
- c.size=9;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_2[0]+0.5));
- lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_2[1]+0.5));
- lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_2[2]+0.5));
- }
-
- { /*---- LIB3DS_MAT_MAP_RCOL ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_MAP_RCOL;
- c.size=9;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_r[0]+0.5));
- lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_r[1]+0.5));
- lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_r[2]+0.5));
- }
-
- { /*---- LIB3DS_MAT_MAP_GCOL ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_MAP_GCOL;
- c.size=9;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_g[0]+0.5));
- lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_g[1]+0.5));
- lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_g[2]+0.5));
- }
-
- { /*---- LIB3DS_MAT_MAP_BCOL ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_MAP_BCOL;
- c.size=9;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_b[0]+0.5));
- lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_b[1]+0.5));
- lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*map->tint_b[2]+0.5));
- }
-
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup material
- */
-Lib3dsBool
-lib3ds_material_write(Lib3dsMaterial *material, Lib3dsIo *io)
-{
- Lib3dsChunk c;
-
- c.chunk=LIB3DS_MAT_ENTRY;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
-
- { /*---- LIB3DS_MAT_NAME ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_NAME;
- c.size=6+strlen(material->name)+1;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_string(io, material->name);
- }
-
- { /*---- LIB3DS_MAT_AMBIENT ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_AMBIENT;
- c.size=24;
- lib3ds_chunk_write(&c,io);
- color_write(material->ambient,io);
- }
-
- { /*---- LIB3DS_MAT_DIFFUSE ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_DIFFUSE;
- c.size=24;
- lib3ds_chunk_write(&c,io);
- color_write(material->diffuse,io);
- }
-
- { /*---- LIB3DS_MAT_SPECULAR ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_SPECULAR;
- c.size=24;
- lib3ds_chunk_write(&c,io);
- color_write(material->specular,io);
- }
-
- { /*---- LIB3DS_MAT_SHININESS ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_SHININESS;
- c.size=14;
- lib3ds_chunk_write(&c,io);
- int_percentage_write(material->shininess,io);
- }
-
- { /*---- LIB3DS_MAT_SHIN2PCT ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_SHIN2PCT;
- c.size=14;
- lib3ds_chunk_write(&c,io);
- int_percentage_write(material->shin_strength,io);
- }
-
- { /*---- LIB3DS_MAT_TRANSPARENCY ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_TRANSPARENCY;
- c.size=14;
- lib3ds_chunk_write(&c,io);
- int_percentage_write(material->transparency,io);
- }
-
- { /*---- LIB3DS_MAT_XPFALL ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_XPFALL;
- c.size=14;
- lib3ds_chunk_write(&c,io);
- int_percentage_write(material->falloff,io);
- }
-
- if (material->use_falloff) { /*---- LIB3DS_MAT_USE_XPFALL ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_USE_XPFALL;
- c.size=6;
- lib3ds_chunk_write(&c,io);
- }
-
- { /*---- LIB3DS_MAT_SHADING ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_SHADING;
- c.size=8;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_intw(io, material->shading);
- }
-
- { /*---- LIB3DS_MAT_REFBLUR ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_REFBLUR;
- c.size=14;
- lib3ds_chunk_write(&c,io);
- int_percentage_write(material->blur,io);
- }
-
- if (material->use_blur) { /*---- LIB3DS_MAT_USE_REFBLUR ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_USE_REFBLUR;
- c.size=6;
- lib3ds_chunk_write(&c,io);
- }
-
- if (material->self_illum) { /*---- LIB3DS_MAT_SELF_ILLUM ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_SELF_ILLUM;
- c.size=6;
- lib3ds_chunk_write(&c,io);
- }
-
- if (material->two_sided) { /*---- LIB3DS_MAT_TWO_SIDE ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_TWO_SIDE;
- c.size=6;
- lib3ds_chunk_write(&c,io);
- }
-
- if (material->map_decal) { /*---- LIB3DS_MAT_DECAL ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_DECAL;
- c.size=6;
- lib3ds_chunk_write(&c,io);
- }
-
- if (material->additive) { /*---- LIB3DS_MAT_ADDITIVE ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_ADDITIVE;
- c.size=6;
- lib3ds_chunk_write(&c,io);
- }
-
- if (material->use_wire) { /*---- LIB3DS_MAT_WIRE ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_WIRE;
- c.size=6;
- lib3ds_chunk_write(&c,io);
- }
-
- if (material->use_wire_abs) { /*---- LIB3DS_MAT_WIREABS ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_WIREABS;
- c.size=6;
- lib3ds_chunk_write(&c,io);
- }
-
- { /*---- LIB3DS_MAT_WIRE_SIZE ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_WIRE_SIZE;
- c.size=10;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_float(io, material->wire_size);
- }
-
- if (material->face_map) { /*---- LIB3DS_MAT_FACEMAP ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_FACEMAP;
- c.size=6;
- lib3ds_chunk_write(&c,io);
- }
-
- if (material->soften) { /*---- LIB3DS_MAT_PHONGSOFT ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MAT_PHONGSOFT;
- c.size=6;
- lib3ds_chunk_write(&c,io);
- }
-
- if (!texture_map_write(LIB3DS_MAT_TEXMAP, &material->texture1_map, io)) {
- return(LIB3DS_FALSE);
- }
- if (!texture_map_write(LIB3DS_MAT_TEXMASK, &material->texture1_mask, io)) {
- return(LIB3DS_FALSE);
- }
- if (!texture_map_write(LIB3DS_MAT_TEX2MAP, &material->texture2_map, io)) {
- return(LIB3DS_FALSE);
- }
- if (!texture_map_write(LIB3DS_MAT_TEX2MASK, &material->texture2_mask, io)) {
- return(LIB3DS_FALSE);
- }
- if (!texture_map_write(LIB3DS_MAT_OPACMAP, &material->opacity_map, io)) {
- return(LIB3DS_FALSE);
- }
- if (!texture_map_write(LIB3DS_MAT_OPACMASK, &material->opacity_mask, io)) {
- return(LIB3DS_FALSE);
- }
- if (!texture_map_write(LIB3DS_MAT_BUMPMAP, &material->bump_map, io)) {
- return(LIB3DS_FALSE);
- }
- if (!texture_map_write(LIB3DS_MAT_BUMPMASK, &material->bump_mask, io)) {
- return(LIB3DS_FALSE);
- }
- if (!texture_map_write(LIB3DS_MAT_SPECMAP, &material->specular_map, io)) {
- return(LIB3DS_FALSE);
- }
- if (!texture_map_write(LIB3DS_MAT_SPECMASK, &material->specular_mask, io)) {
- return(LIB3DS_FALSE);
- }
- if (!texture_map_write(LIB3DS_MAT_SHINMAP, &material->shininess_map, io)) {
- return(LIB3DS_FALSE);
- }
- if (!texture_map_write(LIB3DS_MAT_SHINMASK, &material->shininess_mask, io)) {
- return(LIB3DS_FALSE);
- }
- if (!texture_map_write(LIB3DS_MAT_SELFIMAP, &material->self_illum_map, io)) {
- return(LIB3DS_FALSE);
- }
- if (!texture_map_write(LIB3DS_MAT_SELFIMASK, &material->self_illum_mask, io)) {
- return(LIB3DS_FALSE);
- }
- if (!texture_map_write(LIB3DS_MAT_REFLMAP, &material->reflection_map, io)) {
- return(LIB3DS_FALSE);
- }
- if (!texture_map_write(LIB3DS_MAT_REFLMASK, &material->reflection_mask, io)) {
- return(LIB3DS_FALSE);
- }
-
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
-
-\typedef Lib3dsMaterial
- \ingroup material
- \sa _Lib3dsMaterial
-
-*/
-
+++ /dev/null
-/* -*- c -*- */
-#ifndef INCLUDED_LIB3DS_MATERIAL_H
-#define INCLUDED_LIB3DS_MATERIAL_H
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: material.h,v 1.15 2004/12/31 16:17:15 reed Exp $
- */
-
-#ifndef INCLUDED_LIB3DS_TYPES_H
-#include <lib3ds/types.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*!
- * \ingroup material
- */
-typedef enum _Lib3dsTextureMapFlags {
- LIB3DS_DECALE =0x0001,
- LIB3DS_MIRROR =0x0002,
- LIB3DS_NEGATE =0x0004,
- LIB3DS_NO_TILE =0x0008,
- LIB3DS_SUMMED_AREA =0x0010,
- LIB3DS_ALPHA_SOURCE =0x0020,
- LIB3DS_TINT =0x0040,
- LIB3DS_IGNORE_ALPHA =0x0080,
- LIB3DS_RGB_TINT =0x0100
-} Lib3dsTextureMapFlags;
-
-/*!
- * Mateial texture map
- * \ingroup material
- */
-typedef struct _Lib3dsTextureMap {
- Lib3dsUserData user;
- char name[64];
- Lib3dsDword flags;
- Lib3dsFloat percent;
- Lib3dsFloat blur;
- Lib3dsFloat scale[2];
- Lib3dsFloat offset[2];
- Lib3dsFloat rotation;
- Lib3dsRgb tint_1;
- Lib3dsRgb tint_2;
- Lib3dsRgb tint_r;
- Lib3dsRgb tint_g;
- Lib3dsRgb tint_b;
-} Lib3dsTextureMap;
-
-/*!
- * \ingroup material
- */
-typedef enum _Lib3dsAutoReflMapFlags {
- LIB3DS_USE_REFL_MAP =0x0001,
- LIB3DS_READ_FIRST_FRAME_ONLY =0x0004,
- LIB3DS_FLAT_MIRROR =0x0008
-} Lib3dsAutoReflectionMapFlags;
-
-/*!
- * \ingroup material
- */
-typedef enum _Lib3dsAutoReflMapAntiAliasLevel {
- LIB3DS_ANTI_ALIAS_NONE =0,
- LIB3DS_ANTI_ALIAS_LOW =1,
- LIB3DS_ANTI_ALIAS_MEDIUM =2,
- LIB3DS_ANTI_ALIAS_HIGH =3
-} Lib3dsAutoReflMapAntiAliasLevel;
-
-/*!
- * Auto reflection map settings
- * \ingroup material
- */
-typedef struct _Lib3dsAutoReflMap {
- Lib3dsDword flags;
- Lib3dsIntd level;
- Lib3dsIntd size;
- Lib3dsIntd frame_step;
-} Lib3dsAutoReflMap;
-
-/*!
- * \ingroup material
- */
-typedef enum _Lib3dsMaterialShading {
- LIB3DS_WIRE_FRAME =0,
- LIB3DS_FLAT =1,
- LIB3DS_GOURAUD =2,
- LIB3DS_PHONG =3,
- LIB3DS_METAL =4
-} Lib3dsMaterialShading;
-
-/*!
- * Material
- * \ingroup material
- */
-struct _Lib3dsMaterial {
- Lib3dsUserData user; /*! Arbitrary user data */
- Lib3dsMaterial *next;
- char name[64]; /*! Material name */
- Lib3dsRgba ambient; /*! Material ambient reflectivity */
- Lib3dsRgba diffuse; /*! Material diffuse reflectivity */
- Lib3dsRgba specular; /*! Material specular reflectivity */
- Lib3dsFloat shininess; /*! Material specular exponent */
- Lib3dsFloat shin_strength;
- Lib3dsBool use_blur;
- Lib3dsFloat blur;
- Lib3dsFloat transparency;
- Lib3dsFloat falloff;
- Lib3dsBool additive;
- Lib3dsFloat self_ilpct;
- Lib3dsBool use_falloff;
- Lib3dsBool self_illum;
- Lib3dsIntw shading;
- Lib3dsBool soften;
- Lib3dsBool face_map;
- Lib3dsBool two_sided; /*! Material visible from back */
- Lib3dsBool map_decal;
- Lib3dsBool use_wire;
- Lib3dsBool use_wire_abs;
- Lib3dsFloat wire_size;
- Lib3dsTextureMap texture1_map;
- Lib3dsTextureMap texture1_mask;
- Lib3dsTextureMap texture2_map;
- Lib3dsTextureMap texture2_mask;
- Lib3dsTextureMap opacity_map;
- Lib3dsTextureMap opacity_mask;
- Lib3dsTextureMap bump_map;
- Lib3dsTextureMap bump_mask;
- Lib3dsTextureMap specular_map;
- Lib3dsTextureMap specular_mask;
- Lib3dsTextureMap shininess_map;
- Lib3dsTextureMap shininess_mask;
- Lib3dsTextureMap self_illum_map;
- Lib3dsTextureMap self_illum_mask;
- Lib3dsTextureMap reflection_map;
- Lib3dsTextureMap reflection_mask;
- Lib3dsAutoReflMap autorefl_map;
-};
-
-extern LIB3DSAPI Lib3dsMaterial* lib3ds_material_new();
-extern LIB3DSAPI void lib3ds_material_free(Lib3dsMaterial *material);
-extern LIB3DSAPI void lib3ds_material_dump(Lib3dsMaterial *material);
-extern LIB3DSAPI Lib3dsBool lib3ds_material_read(Lib3dsMaterial *material, Lib3dsIo *io);
-extern LIB3DSAPI Lib3dsBool lib3ds_material_write(Lib3dsMaterial *material, Lib3dsIo *io);
-
-#ifdef __cplusplus
-}
-#endif
-#endif
-
-
-
+++ /dev/null
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: matrix.c,v 1.10 2004/11/16 07:41:44 efalk Exp $
- */
-#define LIB3DS_EXPORT
-#include <lib3ds/matrix.h>
-#include <lib3ds/quat.h>
-#include <lib3ds/vector.h>
-#include <string.h>
-#include <math.h>
-
-
-/*!
- * \defgroup matrix Matrix Mathematics
- *
- * \author J.E. Hoffmann <je-h@gmx.net>
- */
-/*!
- * \typedef Lib3dsMatrix
- * \ingroup matrix
- */
-
-
-/*!
- * Clear a matrix to all zeros.
- *
- * \param m Matrix to be cleared.
- *
- * \ingroup matrix
- */
-void
-lib3ds_matrix_zero(Lib3dsMatrix m)
-{
- int i,j;
-
- for (i=0; i<4; i++) {
- for (j=0; j<4; j++) m[i][j]=0.0f;
- }
-}
-
-
-/*!
- * Set a matrix to identity.
- *
- * \param m Matrix to be set.
- *
- * \ingroup matrix
- */
-void
-lib3ds_matrix_identity(Lib3dsMatrix m)
-{
- int i,j;
-
- for (i=0; i<4; i++) {
- for (j=0; j<4; j++) m[i][j]=0.0;
- }
- for (i=0; i<4; i++) m[i][i]=1.0;
-}
-
-
-/*!
- * Copy a matrix.
- *
- * \ingroup matrix
- */
-void
-lib3ds_matrix_copy(Lib3dsMatrix dest, Lib3dsMatrix src)
-{
- memcpy(dest, src, sizeof(Lib3dsMatrix));
-}
-
-
-/*!
- * Negate a matrix -- all elements negated.
- *
- * \ingroup matrix
- */
-void
-lib3ds_matrix_neg(Lib3dsMatrix m)
-{
- int i,j;
-
- for (j=0; j<4; j++) {
- for (i=0; i<4; i++) {
- m[j][i]=-m[j][i];
- }
- }
-}
-
-
-/*!
- * Set all matrix elements to their absolute value.
- *
- * \ingroup matrix
- */
-void
-lib3ds_matrix_abs(Lib3dsMatrix m)
-{
- int i,j;
-
- for (j=0; j<4; j++) {
- for (i=0; i<4; i++) {
- m[j][i]=(Lib3dsFloat)fabs(m[j][i]);
- }
- }
-}
-
-
-/*!
- * Transpose a matrix in place.
- *
- * \ingroup matrix
- */
-void
-lib3ds_matrix_transpose(Lib3dsMatrix m)
-{
- int i,j;
- Lib3dsFloat swp;
-
- for (j=0; j<4; j++) {
- for (i=j+1; i<4; i++) {
- swp=m[j][i];
- m[j][i]=m[i][j];
- m[i][j]=swp;
- }
- }
-}
-
-
-/*!
- * Add two matrices.
- *
- * \ingroup matrix
- */
-void
-lib3ds_matrix_add(Lib3dsMatrix m, Lib3dsMatrix a, Lib3dsMatrix b)
-{
- int i,j;
-
- for (j=0; j<4; j++) {
- for (i=0; i<4; i++) {
- m[j][i]=a[j][i]+b[j][i];
- }
- }
-}
-
-
-/*!
- * Subtract two matrices.
- *
- * \param m Result.
- * \param a Addend.
- * \param b Minuend.
- *
- * \ingroup matrix
- */
-void
-lib3ds_matrix_sub(Lib3dsMatrix m, Lib3dsMatrix a, Lib3dsMatrix b)
-{
- int i,j;
-
- for (j=0; j<4; j++) {
- for (i=0; i<4; i++) {
- m[j][i]=a[j][i]-b[j][i];
- }
- }
-}
-
-
-/*!
- * Multiply two matrices.
- *
- * \param m Result.
- * \param a Left matrix.
- * \param b Right matrix.
- *
- * \ingroup matrix
- */
-void
-lib3ds_matrix_mul(Lib3dsMatrix m, Lib3dsMatrix a, Lib3dsMatrix b)
-{
- int i,j,k;
- Lib3dsFloat ab;
-
- for (j=0; j<4; j++) {
- for (i=0; i<4; i++) {
- ab=0.0f;
- for (k=0; k<4; k++) ab+=a[k][i]*b[j][k];
- m[j][i]=ab;
- }
- }
-}
-
-
-/*!
- * Multiply a matrix by a scalar.
- *
- * \param m Matrix to be set.
- * \param k Scalar.
- *
- * \ingroup matrix
- */
-void
-lib3ds_matrix_scalar(Lib3dsMatrix m, Lib3dsFloat k)
-{
- int i,j;
-
- for (j=0; j<4; j++) {
- for (i=0; i<4; i++) {
- m[j][i]*=k;
- }
- }
-}
-
-
-static Lib3dsFloat
-det2x2(
- Lib3dsFloat a, Lib3dsFloat b,
- Lib3dsFloat c, Lib3dsFloat d)
-{
- return((a)*(d)-(b)*(c));
-}
-
-
-static Lib3dsFloat
-det3x3(
- Lib3dsFloat a1, Lib3dsFloat a2, Lib3dsFloat a3,
- Lib3dsFloat b1, Lib3dsFloat b2, Lib3dsFloat b3,
- Lib3dsFloat c1, Lib3dsFloat c2, Lib3dsFloat c3)
-{
- return(
- a1*det2x2(b2,b3,c2,c3)-
- b1*det2x2(a2,a3,c2,c3)+
- c1*det2x2(a2,a3,b2,b3)
- );
-}
-
-
-/*!
- * Find determinant of a matrix.
- *
- * \ingroup matrix
- */
-Lib3dsFloat
-lib3ds_matrix_det(Lib3dsMatrix m)
-{
- Lib3dsFloat a1,a2,a3,a4,b1,b2,b3,b4,c1,c2,c3,c4,d1,d2,d3,d4;
-
- a1 = m[0][0];
- b1 = m[1][0];
- c1 = m[2][0];
- d1 = m[3][0];
- a2 = m[0][1];
- b2 = m[1][1];
- c2 = m[2][1];
- d2 = m[3][1];
- a3 = m[0][2];
- b3 = m[1][2];
- c3 = m[2][2];
- d3 = m[3][2];
- a4 = m[0][3];
- b4 = m[1][3];
- c4 = m[2][3];
- d4 = m[3][3];
- return(
- a1 * det3x3(b2, b3, b4, c2, c3, c4, d2, d3, d4)-
- b1 * det3x3(a2, a3, a4, c2, c3, c4, d2, d3, d4)+
- c1 * det3x3(a2, a3, a4, b2, b3, b4, d2, d3, d4)-
- d1 * det3x3(a2, a3, a4, b2, b3, b4, c2, c3, c4)
- );
-}
-
-
-/*!
- * Find the adjoint of a matrix.
- *
- * \ingroup matrix
- */
-void
-lib3ds_matrix_adjoint(Lib3dsMatrix m)
-{
- Lib3dsFloat a1,a2,a3,a4,b1,b2,b3,b4,c1,c2,c3,c4,d1,d2,d3,d4;
-
- a1 = m[0][0];
- b1 = m[1][0];
- c1 = m[2][0];
- d1 = m[3][0];
- a2 = m[0][1];
- b2 = m[1][1];
- c2 = m[2][1];
- d2 = m[3][1];
- a3 = m[0][2];
- b3 = m[1][2];
- c3 = m[2][2];
- d3 = m[3][2];
- a4 = m[0][3];
- b4 = m[1][3];
- c4 = m[2][3];
- d4 = m[3][3];
- m[0][0]= det3x3 (b2, b3, b4, c2, c3, c4, d2, d3, d4);
- m[0][1]= -det3x3 (a2, a3, a4, c2, c3, c4, d2, d3, d4);
- m[0][2]= det3x3 (a2, a3, a4, b2, b3, b4, d2, d3, d4);
- m[0][3]= -det3x3 (a2, a3, a4, b2, b3, b4, c2, c3, c4);
- m[1][0]= -det3x3 (b1, b3, b4, c1, c3, c4, d1, d3, d4);
- m[1][1]= det3x3 (a1, a3, a4, c1, c3, c4, d1, d3, d4);
- m[1][2]= -det3x3 (a1, a3, a4, b1, b3, b4, d1, d3, d4);
- m[1][3]= det3x3 (a1, a3, a4, b1, b3, b4, c1, c3, c4);
- m[2][0]= det3x3 (b1, b2, b4, c1, c2, c4, d1, d2, d4);
- m[2][1]= -det3x3 (a1, a2, a4, c1, c2, c4, d1, d2, d4);
- m[2][2]= det3x3 (a1, a2, a4, b1, b2, b4, d1, d2, d4);
- m[2][3]= -det3x3 (a1, a2, a4, b1, b2, b4, c1, c2, c4);
- m[3][0]= -det3x3 (b1, b2, b3, c1, c2, c3, d1, d2, d3);
- m[3][1]= det3x3 (a1, a2, a3, c1, c2, c3, d1, d2, d3);
- m[3][2]= -det3x3 (a1, a2, a3, b1, b2, b3, d1, d2, d3);
- m[3][3]= det3x3 (a1, a2, a3, b1, b2, b3, c1, c2, c3);
-}
-
-
-/*!
- * Invert a matrix in place.
- *
- * \param m Matrix to invert.
- *
- * \return LIB3DS_TRUE on success, LIB3DS_FALSE on failure.
- * \ingroup matrix
- *
- * GGemsII, K.Wu, Fast Matrix Inversion
- */
-Lib3dsBool
-lib3ds_matrix_inv(Lib3dsMatrix m)
-{
- int i,j,k;
- int pvt_i[4], pvt_j[4]; /* Locations of pivot elements */
- Lib3dsFloat pvt_val; /* Value of current pivot element */
- Lib3dsFloat hold; /* Temporary storage */
- Lib3dsFloat determinat;
-
- determinat = 1.0f;
- for (k=0; k<4; k++) {
- /* Locate k'th pivot element */
- pvt_val=m[k][k]; /* Initialize for search */
- pvt_i[k]=k;
- pvt_j[k]=k;
- for (i=k; i<4; i++) {
- for (j=k; j<4; j++) {
- if (fabs(m[i][j]) > fabs(pvt_val)) {
- pvt_i[k]=i;
- pvt_j[k]=j;
- pvt_val=m[i][j];
- }
- }
- }
-
- /* Product of pivots, gives determinant when finished */
- determinat*=pvt_val;
- if (fabs(determinat)<LIB3DS_EPSILON) {
- return(LIB3DS_FALSE); /* Matrix is singular (zero determinant) */
- }
-
- /* "Interchange" rows (with sign change stuff) */
- i=pvt_i[k];
- if (i!=k) { /* If rows are different */
- for (j=0; j<4; j++) {
- hold=-m[k][j];
- m[k][j]=m[i][j];
- m[i][j]=hold;
- }
- }
-
- /* "Interchange" columns */
- j=pvt_j[k];
- if (j!=k) { /* If columns are different */
- for (i=0; i<4; i++) {
- hold=-m[i][k];
- m[i][k]=m[i][j];
- m[i][j]=hold;
- }
- }
-
- /* Divide column by minus pivot value */
- for (i=0; i<4; i++) {
- if (i!=k) m[i][k]/=( -pvt_val) ;
- }
-
- /* Reduce the matrix */
- for (i=0; i<4; i++) {
- hold = m[i][k];
- for (j=0; j<4; j++) {
- if (i!=k && j!=k) m[i][j]+=hold*m[k][j];
- }
- }
-
- /* Divide row by pivot */
- for (j=0; j<4; j++) {
- if (j!=k) m[k][j]/=pvt_val;
- }
-
- /* Replace pivot by reciprocal (at last we can touch it). */
- m[k][k] = 1.0f/pvt_val;
- }
-
- /* That was most of the work, one final pass of row/column interchange */
- /* to finish */
- for (k=4-2; k>=0; k--) { /* Don't need to work with 1 by 1 corner*/
- i=pvt_j[k]; /* Rows to swap correspond to pivot COLUMN */
- if (i!=k) { /* If rows are different */
- for(j=0; j<4; j++) {
- hold = m[k][j];
- m[k][j]=-m[i][j];
- m[i][j]=hold;
- }
- }
-
- j=pvt_i[k]; /* Columns to swap correspond to pivot ROW */
- if (j!=k) /* If columns are different */
- for (i=0; i<4; i++) {
- hold=m[i][k];
- m[i][k]=-m[i][j];
- m[i][j]=hold;
- }
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * Apply a translation to a matrix.
- *
- * \ingroup matrix
- */
-void
-lib3ds_matrix_translate_xyz(Lib3dsMatrix m, Lib3dsFloat x, Lib3dsFloat y, Lib3dsFloat z)
-{
- int i;
-
- for (i=0; i<3; i++) {
- m[3][i]+= m[0][i]*x + m[1][i]*y + m[2][i]*z;
- }
-}
-
-
-/*!
- * Apply a translation to a matrix.
- *
- * \ingroup matrix
- */
-void
-lib3ds_matrix_translate(Lib3dsMatrix m, Lib3dsVector t)
-{
- int i;
-
- for (i=0; i<3; i++) {
- m[3][i]+= m[0][i]*t[0] + m[1][i]*t[1] + m[2][i]*t[2];
- }
-}
-
-
-/*!
- * Apply scale factors to a matrix.
- *
- * \ingroup matrix
- */
-void
-lib3ds_matrix_scale_xyz(Lib3dsMatrix m, Lib3dsFloat x, Lib3dsFloat y, Lib3dsFloat z)
-{
- int i;
-
- for (i=0; i<4; i++) {
- m[0][i]*=x;
- m[1][i]*=y;
- m[2][i]*=z;
- }
-}
-
-
-/*!
- * Apply scale factors to a matrix.
- *
- * \ingroup matrix
- */
-void
-lib3ds_matrix_scale(Lib3dsMatrix m, Lib3dsVector s)
-{
- int i;
-
- for (i=0; i<4; i++) {
- m[0][i]*=s[0];
- m[1][i]*=s[1];
- m[2][i]*=s[2];
- }
-}
-
-
-/*!
- * Apply a rotation about the x axis to a matrix.
- *
- * \ingroup matrix
- */
-void
-lib3ds_matrix_rotate_x(Lib3dsMatrix m, Lib3dsFloat phi)
-{
- Lib3dsFloat SinPhi,CosPhi;
- Lib3dsFloat a1[4],a2[4];
-
- SinPhi=(Lib3dsFloat)sin(phi);
- CosPhi=(Lib3dsFloat)cos(phi);
- memcpy(a1,m[1],4*sizeof(Lib3dsFloat));
- memcpy(a2,m[2],4*sizeof(Lib3dsFloat));
- m[1][0]=CosPhi*a1[0]+SinPhi*a2[0];
- m[1][1]=CosPhi*a1[1]+SinPhi*a2[1];
- m[1][2]=CosPhi*a1[2]+SinPhi*a2[2];
- m[1][3]=CosPhi*a1[3]+SinPhi*a2[3];
- m[2][0]=-SinPhi*a1[0]+CosPhi*a2[0];
- m[2][1]=-SinPhi*a1[1]+CosPhi*a2[1];
- m[2][2]=-SinPhi*a1[2]+CosPhi*a2[2];
- m[2][3]=-SinPhi*a1[3]+CosPhi*a2[3];
-}
-
-
-/*!
- * Apply a rotation about the y axis to a matrix.
- *
- * \ingroup matrix
- */
-void
-lib3ds_matrix_rotate_y(Lib3dsMatrix m, Lib3dsFloat phi)
-{
- Lib3dsFloat SinPhi,CosPhi;
- Lib3dsFloat a0[4],a2[4];
-
- SinPhi=(Lib3dsFloat)sin(phi);
- CosPhi=(Lib3dsFloat)cos(phi);
- memcpy(a0,m[0],4*sizeof(Lib3dsFloat));
- memcpy(a2,m[2],4*sizeof(Lib3dsFloat));
- m[0][0]=CosPhi*a0[0]-SinPhi*a2[0];
- m[0][1]=CosPhi*a0[1]-SinPhi*a2[1];
- m[0][2]=CosPhi*a0[2]-SinPhi*a2[2];
- m[0][3]=CosPhi*a0[3]-SinPhi*a2[3];
- m[2][0]=SinPhi*a0[0]+CosPhi*a2[0];
- m[2][1]=SinPhi*a0[1]+CosPhi*a2[1];
- m[2][2]=SinPhi*a0[2]+CosPhi*a2[2];
- m[2][3]=SinPhi*a0[3]+CosPhi*a2[3];
-}
-
-
-/*!
- * Apply a rotation about the z axis to a matrix.
- *
- * \ingroup matrix
- */
-void
-lib3ds_matrix_rotate_z(Lib3dsMatrix m, Lib3dsFloat phi)
-{
- Lib3dsFloat SinPhi,CosPhi;
- Lib3dsFloat a0[4],a1[4];
-
- SinPhi=(Lib3dsFloat)sin(phi);
- CosPhi=(Lib3dsFloat)cos(phi);
- memcpy(a0,m[0],4*sizeof(Lib3dsFloat));
- memcpy(a1,m[1],4*sizeof(Lib3dsFloat));
- m[0][0]=CosPhi*a0[0]+SinPhi*a1[0];
- m[0][1]=CosPhi*a0[1]+SinPhi*a1[1];
- m[0][2]=CosPhi*a0[2]+SinPhi*a1[2];
- m[0][3]=CosPhi*a0[3]+SinPhi*a1[3];
- m[1][0]=-SinPhi*a0[0]+CosPhi*a1[0];
- m[1][1]=-SinPhi*a0[1]+CosPhi*a1[1];
- m[1][2]=-SinPhi*a0[2]+CosPhi*a1[2];
- m[1][3]=-SinPhi*a0[3]+CosPhi*a1[3];
-}
-
-
-/*!
- * Apply a rotation about an arbitrary axis to a matrix.
- *
- * \ingroup matrix
- */
-void
-lib3ds_matrix_rotate(Lib3dsMatrix m, Lib3dsQuat q)
-{
- Lib3dsFloat s,xs,ys,zs,wx,wy,wz,xx,xy,xz,yy,yz,zz,l;
- Lib3dsMatrix a,b;
-
- lib3ds_matrix_copy(a, m);
-
- l=q[0]*q[0] + q[1]*q[1] + q[2]*q[2] + q[3]*q[3];
- if (fabs(l)<LIB3DS_EPSILON) {
- s=1.0f;
- }
- else {
- s=2.0f/l;
- }
-
- xs = q[0] * s; ys = q[1] * s; zs = q[2] * s;
- wx = q[3] * xs; wy = q[3] * ys; wz = q[3] * zs;
- xx = q[0] * xs; xy = q[0] * ys; xz = q[0] * zs;
- yy = q[1] * ys; yz = q[1] * zs; zz = q[2] * zs;
-
- b[0][0]=1.0f - (yy +zz);
- b[1][0]=xy - wz;
- b[2][0]=xz + wy;
- b[0][1]=xy + wz;
- b[1][1]=1.0f - (xx +zz);
- b[2][1]=yz - wx;
- b[0][2]=xz - wy;
- b[1][2]=yz + wx;
- b[2][2]=1.0f - (xx + yy);
- b[3][0]=b[3][1]=b[3][2]=b[0][3]=b[1][3]=b[2][3]=0.0f;
- b[3][3]=1.0f;
-
- lib3ds_matrix_mul(m,a,b);
-}
-
-
-/*!
- * Apply a rotation about an arbitrary axis to a matrix.
- *
- * \ingroup matrix
- */
-void
-lib3ds_matrix_rotate_axis(Lib3dsMatrix m, Lib3dsVector axis, Lib3dsFloat angle)
-{
- Lib3dsQuat q;
-
- lib3ds_quat_axis_angle(q,axis,angle);
- lib3ds_matrix_rotate(m,q);
-}
-
-
-/*!
- * Compute a camera matrix based on position, target and roll.
- *
- * Generates a translate/rotate matrix that maps world coordinates
- * to camera coordinates. Resulting matrix does not include perspective
- * transform.
- *
- * \param matrix Destination matrix.
- * \param pos Camera position
- * \param tgt Camera target
- * \param roll Roll angle
- *
- * \ingroup matrix
- */
-void
-lib3ds_matrix_camera(Lib3dsMatrix matrix, Lib3dsVector pos,
- Lib3dsVector tgt, Lib3dsFloat roll)
-{
- Lib3dsMatrix M,R;
- Lib3dsVector x, y, z;
-
- lib3ds_vector_sub(y, tgt, pos);
- lib3ds_vector_normalize(y);
-
- if (y[0] != 0. || y[1] != 0) {
- z[0] = 0;
- z[1] = 0;
- z[2] = 1.0;
- }
- else { /* Special case: looking straight up or down z axis */
- z[0] = -1.0;
- z[1] = 0;
- z[2] = 0;
- }
-
- lib3ds_vector_cross(x, y, z);
- lib3ds_vector_cross(z, x, y);
- lib3ds_vector_normalize(x);
- lib3ds_vector_normalize(z);
-
- lib3ds_matrix_identity(M);
- M[0][0] = x[0];
- M[1][0] = x[1];
- M[2][0] = x[2];
- M[0][1] = y[0];
- M[1][1] = y[1];
- M[2][1] = y[2];
- M[0][2] = z[0];
- M[1][2] = z[1];
- M[2][2] = z[2];
-
- lib3ds_matrix_identity(R);
- lib3ds_matrix_rotate_y(R, roll);
- lib3ds_matrix_mul(matrix, R,M);
- lib3ds_matrix_translate_xyz(matrix, -pos[0],-pos[1],-pos[2]);
-}
-
-
-/*!
- * \ingroup matrix
- */
-void
-lib3ds_matrix_dump(Lib3dsMatrix matrix)
-{
- int i,j;
-
- for (i=0; i<4; ++i) {
- for (j=0; j<4; ++j) {
- printf("%f ", matrix[j][i]);
- }
- printf("\n");
- }
-}
-
-
-
-
-
+++ /dev/null
-/* -*- c -*- */
-#ifndef INCLUDED_LIB3DS_MATRIX_H
-#define INCLUDED_LIB3DS_MATRIX_H
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: matrix.h,v 1.5 2004/12/31 16:17:15 reed Exp $
- */
-
-#ifndef INCLUDED_LIB3DS_TYPES_H
-#include <lib3ds/types.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-extern LIB3DSAPI void lib3ds_matrix_zero(Lib3dsMatrix m);
-extern LIB3DSAPI void lib3ds_matrix_identity(Lib3dsMatrix m);
-extern LIB3DSAPI void lib3ds_matrix_copy(Lib3dsMatrix dest, Lib3dsMatrix src);
-extern LIB3DSAPI void lib3ds_matrix_neg(Lib3dsMatrix m);
-extern LIB3DSAPI void lib3ds_matrix_abs(Lib3dsMatrix m);
-extern LIB3DSAPI void lib3ds_matrix_transpose(Lib3dsMatrix m);
-extern LIB3DSAPI void lib3ds_matrix_add(Lib3dsMatrix m, Lib3dsMatrix a, Lib3dsMatrix b);
-extern LIB3DSAPI void lib3ds_matrix_sub(Lib3dsMatrix m, Lib3dsMatrix a, Lib3dsMatrix b);
-extern LIB3DSAPI void lib3ds_matrix_mul(Lib3dsMatrix m, Lib3dsMatrix a, Lib3dsMatrix b);
-extern LIB3DSAPI void lib3ds_matrix_scalar(Lib3dsMatrix m, Lib3dsFloat k);
-extern LIB3DSAPI Lib3dsFloat lib3ds_matrix_det(Lib3dsMatrix m);
-extern LIB3DSAPI void lib3ds_matrix_adjoint(Lib3dsMatrix m);
-extern LIB3DSAPI Lib3dsBool lib3ds_matrix_inv(Lib3dsMatrix m);
-void lib3ds_matrix_translate_xyz(Lib3dsMatrix m, Lib3dsFloat x,
- Lib3dsFloat y, Lib3dsFloat z);
-extern LIB3DSAPI void lib3ds_matrix_translate(Lib3dsMatrix m, Lib3dsVector t);
-extern LIB3DSAPI void lib3ds_matrix_scale_xyz(Lib3dsMatrix m, Lib3dsFloat x,
- Lib3dsFloat y, Lib3dsFloat z);
-extern LIB3DSAPI void lib3ds_matrix_scale(Lib3dsMatrix m, Lib3dsVector s);
-extern LIB3DSAPI void lib3ds_matrix_rotate_x(Lib3dsMatrix m, Lib3dsFloat phi);
-extern LIB3DSAPI void lib3ds_matrix_rotate_y(Lib3dsMatrix m, Lib3dsFloat phi);
-extern LIB3DSAPI void lib3ds_matrix_rotate_z(Lib3dsMatrix m, Lib3dsFloat phi);
-extern LIB3DSAPI void lib3ds_matrix_rotate(Lib3dsMatrix m, Lib3dsQuat q);
-extern LIB3DSAPI void lib3ds_matrix_rotate_axis(Lib3dsMatrix m,
- Lib3dsVector axis, Lib3dsFloat angle);
-extern LIB3DSAPI void lib3ds_matrix_camera(Lib3dsMatrix matrix, Lib3dsVector pos,
- Lib3dsVector tgt, Lib3dsFloat roll);
-extern LIB3DSAPI void lib3ds_matrix_dump(Lib3dsMatrix matrix);
-
-#ifdef __cplusplus
-}
-#endif
-#endif
-
+++ /dev/null
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: mesh.c,v 1.22 2004/11/20 08:33:56 efalk Exp $
- */
-#define LIB3DS_EXPORT
-#include <lib3ds/mesh.h>
-#include <lib3ds/io.h>
-#include <lib3ds/chunk.h>
-#include <lib3ds/vector.h>
-#include <lib3ds/matrix.h>
-#include <stdlib.h>
-#include <string.h>
-#include <math.h>
-#ifdef WITH_DMALLOC
-#include <dmalloc.h>
-#endif
-
-
-/*!
- * \defgroup mesh Meshes
- *
- * \author J.E. Hoffmann <je-h@gmx.net>
- */
-
-
-static Lib3dsBool
-face_array_read(Lib3dsMesh *mesh, Lib3dsIo *io)
-{
- Lib3dsChunk c;
- Lib3dsWord chunk;
- int i;
- int faces;
-
- if (!lib3ds_chunk_read_start(&c, LIB3DS_FACE_ARRAY, io)) {
- return(LIB3DS_FALSE);
- }
- lib3ds_mesh_free_face_list(mesh);
-
- faces=lib3ds_io_read_word(io);
- if (faces) {
- if (!lib3ds_mesh_new_face_list(mesh, faces)) {
- LIB3DS_ERROR_LOG;
- return(LIB3DS_FALSE);
- }
- for (i=0; i<faces; ++i) {
- strcpy(mesh->faceL[i].material, "");
- mesh->faceL[i].points[0]=lib3ds_io_read_word(io);
- mesh->faceL[i].points[1]=lib3ds_io_read_word(io);
- mesh->faceL[i].points[2]=lib3ds_io_read_word(io);
- mesh->faceL[i].flags=lib3ds_io_read_word(io);
- }
- lib3ds_chunk_read_tell(&c, io);
-
- while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
- switch (chunk) {
- case LIB3DS_SMOOTH_GROUP:
- {
- unsigned i;
-
- for (i=0; i<mesh->faces; ++i) {
- mesh->faceL[i].smoothing=lib3ds_io_read_dword(io);
- }
- }
- break;
- case LIB3DS_MSH_MAT_GROUP:
- {
- char name[64];
- unsigned faces;
- unsigned i;
- unsigned index;
-
- if (!lib3ds_io_read_string(io, name, 64)) {
- return(LIB3DS_FALSE);
- }
- faces=lib3ds_io_read_word(io);
- for (i=0; i<faces; ++i) {
- index=lib3ds_io_read_word(io);
- ASSERT(index<mesh->faces);
- strcpy(mesh->faceL[index].material, name);
- }
- }
- break;
- case LIB3DS_MSH_BOXMAP:
- {
- char name[64];
-
- if (!lib3ds_io_read_string(io, name, 64)) {
- return(LIB3DS_FALSE);
- }
- strcpy(mesh->box_map.front, name);
- if (!lib3ds_io_read_string(io, name, 64)) {
- return(LIB3DS_FALSE);
- }
- strcpy(mesh->box_map.back, name);
- if (!lib3ds_io_read_string(io, name, 64)) {
- return(LIB3DS_FALSE);
- }
- strcpy(mesh->box_map.left, name);
- if (!lib3ds_io_read_string(io, name, 64)) {
- return(LIB3DS_FALSE);
- }
- strcpy(mesh->box_map.right, name);
- if (!lib3ds_io_read_string(io, name, 64)) {
- return(LIB3DS_FALSE);
- }
- strcpy(mesh->box_map.top, name);
- if (!lib3ds_io_read_string(io, name, 64)) {
- return(LIB3DS_FALSE);
- }
- strcpy(mesh->box_map.bottom, name);
- }
- break;
- default:
- lib3ds_chunk_unknown(chunk);
- }
- }
-
- }
- lib3ds_chunk_read_end(&c, io);
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * Create and return a new empty mesh object.
- *
- * Mesh is initialized with the name and an identity matrix; all
- * other fields are zero.
- *
- * See Lib3dsFaceFlag for definitions of per-face flags.
- *
- * \param name Mesh name. Must not be NULL. Must be < 64 characters.
- *
- * \return mesh object or NULL on error.
- *
- * \ingroup mesh
- */
-Lib3dsMesh*
-lib3ds_mesh_new(const char *name)
-{
- Lib3dsMesh *mesh;
-
- ASSERT(name);
- ASSERT(strlen(name)<64);
-
- mesh=(Lib3dsMesh*)calloc(sizeof(Lib3dsMesh), 1);
- if (!mesh) {
- return(0);
- }
- strcpy(mesh->name, name);
- lib3ds_matrix_identity(mesh->matrix);
- mesh->map_data.maptype=LIB3DS_MAP_NONE;
- return(mesh);
-}
-
-
-/*!
- * Free a mesh object and all of its resources.
- *
- * \param mesh Mesh object to be freed.
- *
- * \ingroup mesh
- */
-void
-lib3ds_mesh_free(Lib3dsMesh *mesh)
-{
- lib3ds_mesh_free_point_list(mesh);
- lib3ds_mesh_free_flag_list(mesh);
- lib3ds_mesh_free_texel_list(mesh);
- lib3ds_mesh_free_face_list(mesh);
- memset(mesh, 0, sizeof(Lib3dsMesh));
- free(mesh);
-}
-
-
-/*!
- * Allocate point list in mesh object.
- *
- * This function frees the current point list, if any, and allocates
- * a new one large enough to hold the specified number of points.
- *
- * \param mesh Mesh object for which points are to be allocated.
- * \param points Number of points in the new point list.
- *
- * \return LIB3DS_TRUE on success, LIB3DS_FALSE on failure.
- *
- * \ingroup mesh
- */
-Lib3dsBool
-lib3ds_mesh_new_point_list(Lib3dsMesh *mesh, Lib3dsDword points)
-{
- ASSERT(mesh);
- if (mesh->pointL) {
- ASSERT(mesh->points);
- lib3ds_mesh_free_point_list(mesh);
- }
- ASSERT(!mesh->pointL && !mesh->points);
- mesh->points=0;
- mesh->pointL=calloc(sizeof(Lib3dsPoint)*points,1);
- if (!mesh->pointL) {
- LIB3DS_ERROR_LOG;
- return(LIB3DS_FALSE);
- }
- mesh->points=points;
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * Free point list in mesh object.
- *
- * The current point list is freed and set to NULL. mesh->points is
- * set to zero.
- *
- * \param mesh Mesh object to be modified.
- *
- * \ingroup mesh
- */
-void
-lib3ds_mesh_free_point_list(Lib3dsMesh *mesh)
-{
- ASSERT(mesh);
- if (mesh->pointL) {
- ASSERT(mesh->points);
- free(mesh->pointL);
- mesh->pointL=0;
- mesh->points=0;
- }
- else {
- ASSERT(!mesh->points);
- }
-}
-
-
-/*!
- * Allocate flag list in mesh object.
- *
- * This function frees the current flag list, if any, and allocates
- * a new one large enough to hold the specified number of flags.
- * All flags are initialized to 0
- *
- * \param mesh Mesh object for which points are to be allocated.
- * \param flags Number of flags in the new flag list.
- *
- * \return LIB3DS_TRUE on success, LIB3DS_FALSE on failure.
- *
- * \ingroup mesh
- */
-Lib3dsBool
-lib3ds_mesh_new_flag_list(Lib3dsMesh *mesh, Lib3dsDword flags)
-{
- ASSERT(mesh);
- if (mesh->flagL) {
- ASSERT(mesh->flags);
- lib3ds_mesh_free_flag_list(mesh);
- }
- ASSERT(!mesh->flagL && !mesh->flags);
- mesh->flags=0;
- mesh->flagL=calloc(sizeof(Lib3dsWord)*flags,1);
- if (!mesh->flagL) {
- LIB3DS_ERROR_LOG;
- return(LIB3DS_FALSE);
- }
- mesh->flags=flags;
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * Free flag list in mesh object.
- *
- * The current flag list is freed and set to NULL. mesh->flags is
- * set to zero.
- *
- * \param mesh Mesh object to be modified.
- *
- * \ingroup mesh
- */
-void
-lib3ds_mesh_free_flag_list(Lib3dsMesh *mesh)
-{
- ASSERT(mesh);
- if (mesh->flagL) {
- ASSERT(mesh->flags);
- free(mesh->flagL);
- mesh->flagL=0;
- mesh->flags=0;
- }
- else {
- ASSERT(!mesh->flags);
- }
-}
-
-
-/*!
- * Allocate texel list in mesh object.
- *
- * This function frees the current texel list, if any, and allocates
- * a new one large enough to hold the specified number of texels.
- *
- * \param mesh Mesh object for which points are to be allocated.
- * \param texels Number of texels in the new texel list.
- *
- * \return LIB3DS_TRUE on success, LIB3DS_FALSE on failure.
- *
- * \ingroup mesh
- */
-Lib3dsBool
-lib3ds_mesh_new_texel_list(Lib3dsMesh *mesh, Lib3dsDword texels)
-{
- ASSERT(mesh);
- if (mesh->texelL) {
- ASSERT(mesh->texels);
- lib3ds_mesh_free_texel_list(mesh);
- }
- ASSERT(!mesh->texelL && !mesh->texels);
- mesh->texels=0;
- mesh->texelL=calloc(sizeof(Lib3dsTexel)*texels,1);
- if (!mesh->texelL) {
- LIB3DS_ERROR_LOG;
- return(LIB3DS_FALSE);
- }
- mesh->texels=texels;
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * Free texel list in mesh object.
- *
- * The current texel list is freed and set to NULL. mesh->texels is
- * set to zero.
- *
- * \param mesh Mesh object to be modified.
- *
- * \ingroup mesh
- */
-void
-lib3ds_mesh_free_texel_list(Lib3dsMesh *mesh)
-{
- ASSERT(mesh);
- if (mesh->texelL) {
- ASSERT(mesh->texels);
- free(mesh->texelL);
- mesh->texelL=0;
- mesh->texels=0;
- }
- else {
- ASSERT(!mesh->texels);
- }
-}
-
-
-/*!
- * Allocate face list in mesh object.
- *
- * This function frees the current face list, if any, and allocates
- * a new one large enough to hold the specified number of faces.
- *
- * \param mesh Mesh object for which points are to be allocated.
- * \param faces Number of faces in the new face list.
- *
- * \return LIB3DS_TRUE on success, LIB3DS_FALSE on failure.
- *
- * \ingroup mesh
- */
-Lib3dsBool
-lib3ds_mesh_new_face_list(Lib3dsMesh *mesh, Lib3dsDword faces)
-{
- ASSERT(mesh);
- if (mesh->faceL) {
- ASSERT(mesh->faces);
- lib3ds_mesh_free_face_list(mesh);
- }
- ASSERT(!mesh->faceL && !mesh->faces);
- mesh->faces=0;
- mesh->faceL=calloc(sizeof(Lib3dsFace)*faces,1);
- if (!mesh->faceL) {
- LIB3DS_ERROR_LOG;
- return(LIB3DS_FALSE);
- }
- mesh->faces=faces;
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * Free face list in mesh object.
- *
- * The current face list is freed and set to NULL. mesh->faces is
- * set to zero.
- *
- * \param mesh Mesh object to be modified.
- *
- * \ingroup mesh
- */
-void
-lib3ds_mesh_free_face_list(Lib3dsMesh *mesh)
-{
- ASSERT(mesh);
- if (mesh->faceL) {
- ASSERT(mesh->faces);
- free(mesh->faceL);
- mesh->faceL=0;
- mesh->faces=0;
- }
- else {
- ASSERT(!mesh->faces);
- }
-}
-
-
-typedef struct _Lib3dsFaces Lib3dsFaces;
-
-struct _Lib3dsFaces {
- Lib3dsFaces *next;
- Lib3dsFace *face;
-};
-
-
-
-
-/*!
- * Find the bounding box of a mesh object.
- *
- * \param mesh The mesh object
- * \param min Returned bounding box
- * \param max Returned bounding box
- *
- * \ingroup mesh
- */
-void
-lib3ds_mesh_bounding_box(Lib3dsMesh *mesh, Lib3dsVector min, Lib3dsVector max)
-{
- unsigned i,j;
- Lib3dsFloat v;
-
- if (!mesh->points) {
- lib3ds_vector_zero(min);
- lib3ds_vector_zero(max);
- return;
- }
-
- lib3ds_vector_copy(min, mesh->pointL[0].pos);
- lib3ds_vector_copy(max, mesh->pointL[0].pos);
- for (i=1; i<mesh->points; ++i) {
- for (j=0; j<3; ++j) {
- v=mesh->pointL[i].pos[j];
- if (v<min[j]) {
- min[j]=v;
- }
- if (v>max[j]) {
- max[j]=v;
- }
- }
- };
-}
-
-
-/*!
- * Calculates the vertex normals corresponding to the smoothing group
- * settings for each face of a mesh.
- *
- * \param mesh A pointer to the mesh to calculate the normals for.
- * \param normalL A pointer to a buffer to store the calculated
- * normals. The buffer must have the size:
- * 3*sizeof(Lib3dsVector)*mesh->faces.
- *
- * To allocate the normal buffer do for example the following:
- * \code
- * Lib3dsVector *normalL = malloc(3*sizeof(Lib3dsVector)*mesh->faces);
- * \endcode
- *
- * To access the normal of the i-th vertex of the j-th face do the
- * following:
- * \code
- * normalL[3*j+i]
- * \endcode
- *
- * \ingroup mesh
- */
-void
-lib3ds_mesh_calculate_normals(Lib3dsMesh *mesh, Lib3dsVector *normalL)
-{
- Lib3dsFaces **fl;
- Lib3dsFaces *fa;
- unsigned i,j,k;
-
- if (!mesh->faces) {
- return;
- }
-
- fl=calloc(sizeof(Lib3dsFaces*),mesh->points);
- ASSERT(fl);
- fa=calloc(sizeof(Lib3dsFaces),3*mesh->faces);
- ASSERT(fa);
- k=0;
- for (i=0; i<mesh->faces; ++i) {
- Lib3dsFace *f=&mesh->faceL[i];
- for (j=0; j<3; ++j) {
- Lib3dsFaces* l=&fa[k++];
- ASSERT(f->points[j]<mesh->points);
- l->face=f;
- l->next=fl[f->points[j]];
- fl[f->points[j]]=l;
- }
- }
-
- for (i=0; i<mesh->faces; ++i) {
- Lib3dsFace *f=&mesh->faceL[i];
- for (j=0; j<3; ++j) {
- /* FIXME: static array needs at least check!! */
- Lib3dsVector n,N[128];
- Lib3dsFaces *p;
- int k,l;
- int found;
-
- ASSERT(f->points[j]<mesh->points);
-
- if (f->smoothing) {
- lib3ds_vector_zero(n);
- k=0;
- for (p=fl[f->points[j]]; p; p=p->next) {
- found=0;
- for (l=0; l<k; ++l) {
- if( l >= 128 )
- printf("array N overflow: i=%d, j=%d, k=%d\n", i,j,k);
- if (fabs(lib3ds_vector_dot(N[l], p->face->normal)-1.0)<1e-5) {
- found=1;
- break;
- }
- }
- if (!found) {
- if (f->smoothing & p->face->smoothing) {
- lib3ds_vector_add(n,n, p->face->normal);
- lib3ds_vector_copy(N[k], p->face->normal);
- ++k;
- }
- }
- }
- }
- else {
- lib3ds_vector_copy(n, f->normal);
- }
- lib3ds_vector_normalize(n);
-
- lib3ds_vector_copy(normalL[3*i+j], n);
- }
- }
-
- free(fa);
- free(fl);
-}
-
-
-/*!
- * This function prints data associated with the specified mesh such as
- * vertex and point lists.
- *
- * \param mesh Points to a mesh that you wish to view the data for.
- *
- * \return None
- *
- * \warning WIN32: Should only be used in a console window not in a GUI.
- *
- * \ingroup mesh
- */
-void
-lib3ds_mesh_dump(Lib3dsMesh *mesh)
-{
- unsigned i;
- Lib3dsVector p;
-
- ASSERT(mesh);
- printf(" %s vertices=%ld faces=%ld\n",
- mesh->name,
- mesh->points,
- mesh->faces
- );
- printf(" matrix:\n");
- lib3ds_matrix_dump(mesh->matrix);
- printf(" point list:\n");
- for (i=0; i<mesh->points; ++i) {
- lib3ds_vector_copy(p, mesh->pointL[i].pos);
- printf (" %8f %8f %8f\n", p[0], p[1], p[2]);
- }
- printf(" facelist:\n");
- for (i=0; i<mesh->faces; ++i) {
- printf (" %4d %4d %4d smoothing:%X flags:%X material:\"%s\"\n",
- mesh->faceL[i].points[0],
- mesh->faceL[i].points[1],
- mesh->faceL[i].points[2],
- (unsigned)mesh->faceL[i].smoothing,
- mesh->faceL[i].flags,
- mesh->faceL[i].material
- );
- }
-}
-
-
-/*!
- * \ingroup mesh
- */
-Lib3dsBool
-lib3ds_mesh_read(Lib3dsMesh *mesh, Lib3dsIo *io)
-{
- Lib3dsChunk c;
- Lib3dsWord chunk;
-
- if (!lib3ds_chunk_read_start(&c, LIB3DS_N_TRI_OBJECT, io)) {
- return(LIB3DS_FALSE);
- }
-
- while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
- switch (chunk) {
- case LIB3DS_MESH_MATRIX:
- {
- int i,j;
-
- lib3ds_matrix_identity(mesh->matrix);
- for (i=0; i<4; i++) {
- for (j=0; j<3; j++) {
- mesh->matrix[i][j]=lib3ds_io_read_float(io);
- }
- }
- }
- break;
- case LIB3DS_MESH_COLOR:
- {
- mesh->color=lib3ds_io_read_byte(io);
- }
- break;
- case LIB3DS_POINT_ARRAY:
- {
- unsigned i,j;
- unsigned points;
-
- lib3ds_mesh_free_point_list(mesh);
- points=lib3ds_io_read_word(io);
- if (points) {
- if (!lib3ds_mesh_new_point_list(mesh, points)) {
- LIB3DS_ERROR_LOG;
- return(LIB3DS_FALSE);
- }
- for (i=0; i<mesh->points; ++i) {
- for (j=0; j<3; ++j) {
- mesh->pointL[i].pos[j]=lib3ds_io_read_float(io);
- }
- }
- ASSERT((!mesh->flags) || (mesh->points==mesh->flags));
- ASSERT((!mesh->texels) || (mesh->points==mesh->texels));
- }
- }
- break;
- case LIB3DS_POINT_FLAG_ARRAY:
- {
- unsigned i;
- unsigned flags;
-
- lib3ds_mesh_free_flag_list(mesh);
- flags=lib3ds_io_read_word(io);
- if (flags) {
- if (!lib3ds_mesh_new_flag_list(mesh, flags)) {
- LIB3DS_ERROR_LOG;
- return(LIB3DS_FALSE);
- }
- for (i=0; i<mesh->flags; ++i) {
- mesh->flagL[i]=lib3ds_io_read_word(io);
- }
- ASSERT((!mesh->points) || (mesh->flags==mesh->points));
- ASSERT((!mesh->texels) || (mesh->flags==mesh->texels));
- }
- }
- break;
- case LIB3DS_FACE_ARRAY:
- {
- lib3ds_chunk_read_reset(&c, io);
- if (!face_array_read(mesh, io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_MESH_TEXTURE_INFO:
- {
- int i,j;
-
- for (i=0; i<2; ++i) {
- mesh->map_data.tile[i]=lib3ds_io_read_float(io);
- }
- for (i=0; i<3; ++i) {
- mesh->map_data.pos[i]=lib3ds_io_read_float(io);
- }
- mesh->map_data.scale=lib3ds_io_read_float(io);
-
- lib3ds_matrix_identity(mesh->map_data.matrix);
- for (i=0; i<4; i++) {
- for (j=0; j<3; j++) {
- mesh->map_data.matrix[i][j]=lib3ds_io_read_float(io);
- }
- }
- for (i=0; i<2; ++i) {
- mesh->map_data.planar_size[i]=lib3ds_io_read_float(io);
- }
- mesh->map_data.cylinder_height=lib3ds_io_read_float(io);
- }
- break;
- case LIB3DS_TEX_VERTS:
- {
- unsigned i;
- unsigned texels;
-
- lib3ds_mesh_free_texel_list(mesh);
- texels=lib3ds_io_read_word(io);
- if (texels) {
- if (!lib3ds_mesh_new_texel_list(mesh, texels)) {
- LIB3DS_ERROR_LOG;
- return(LIB3DS_FALSE);
- }
- for (i=0; i<mesh->texels; ++i) {
- mesh->texelL[i][0]=lib3ds_io_read_float(io);
- mesh->texelL[i][1]=lib3ds_io_read_float(io);
- }
- ASSERT((!mesh->points) || (mesh->texels==mesh->points));
- ASSERT((!mesh->flags) || (mesh->texels==mesh->flags));
- }
- }
- break;
- default:
- lib3ds_chunk_unknown(chunk);
- }
- }
- {
- unsigned j;
-
- for (j=0; j<mesh->faces; ++j) {
- ASSERT(mesh->faceL[j].points[0]<mesh->points);
- ASSERT(mesh->faceL[j].points[1]<mesh->points);
- ASSERT(mesh->faceL[j].points[2]<mesh->points);
- lib3ds_vector_normal(
- mesh->faceL[j].normal,
- mesh->pointL[mesh->faceL[j].points[0]].pos,
- mesh->pointL[mesh->faceL[j].points[1]].pos,
- mesh->pointL[mesh->faceL[j].points[2]].pos
- );
- }
- }
-
- lib3ds_chunk_read_end(&c, io);
- return(LIB3DS_TRUE);
-}
-
-
-static Lib3dsBool
-point_array_write(Lib3dsMesh *mesh, Lib3dsIo *io)
-{
- Lib3dsChunk c;
- unsigned i;
-
- if (!mesh->points || !mesh->pointL) {
- return(LIB3DS_TRUE);
- }
- ASSERT(mesh->points<0x10000);
- c.chunk=LIB3DS_POINT_ARRAY;
- c.size=8+12*mesh->points;
- lib3ds_chunk_write(&c, io);
-
- lib3ds_io_write_word(io, (Lib3dsWord)mesh->points);
- for (i=0; i<mesh->points; ++i) {
- lib3ds_io_write_vector(io, mesh->pointL[i].pos);
- }
- return(LIB3DS_TRUE);
-}
-
-
-static Lib3dsBool
-flag_array_write(Lib3dsMesh *mesh, Lib3dsIo *io)
-{
- Lib3dsChunk c;
- unsigned i;
-
- if (!mesh->flags || !mesh->flagL) {
- return(LIB3DS_TRUE);
- }
- ASSERT(mesh->flags<0x10000);
- c.chunk=LIB3DS_POINT_FLAG_ARRAY;
- c.size=8+2*mesh->flags;
- lib3ds_chunk_write(&c, io);
-
- lib3ds_io_write_word(io, (Lib3dsWord)mesh->flags);
- for (i=0; i<mesh->flags; ++i) {
- lib3ds_io_write_word(io, mesh->flagL[i]);
- }
- return(LIB3DS_TRUE);
-}
-
-
-static Lib3dsBool
-face_array_write(Lib3dsMesh *mesh, Lib3dsIo *io)
-{
- Lib3dsChunk c;
-
- if (!mesh->faces || !mesh->faceL) {
- return(LIB3DS_TRUE);
- }
- ASSERT(mesh->faces<0x10000);
- c.chunk=LIB3DS_FACE_ARRAY;
- if (!lib3ds_chunk_write_start(&c, io)) {
- return(LIB3DS_FALSE);
- }
- {
- unsigned i;
-
- lib3ds_io_write_word(io, (Lib3dsWord)mesh->faces);
- for (i=0; i<mesh->faces; ++i) {
- lib3ds_io_write_word(io, mesh->faceL[i].points[0]);
- lib3ds_io_write_word(io, mesh->faceL[i].points[1]);
- lib3ds_io_write_word(io, mesh->faceL[i].points[2]);
- lib3ds_io_write_word(io, mesh->faceL[i].flags);
- }
- }
-
- { /*---- MSH_MAT_GROUP ----*/
- Lib3dsChunk c;
- unsigned i,j;
- Lib3dsWord num;
- char *matf=calloc(sizeof(char), mesh->faces);
- if (!matf) {
- return(LIB3DS_FALSE);
- }
-
- for (i=0; i<mesh->faces; ++i) {
- if (!matf[i] && strlen(mesh->faceL[i].material)) {
- matf[i]=1;
- num=1;
-
- for (j=i+1; j<mesh->faces; ++j) {
- if (strcmp(mesh->faceL[i].material, mesh->faceL[j].material)==0) ++num;
- }
-
- c.chunk=LIB3DS_MSH_MAT_GROUP;
- c.size=6+ strlen(mesh->faceL[i].material)+1 +2+2*num;
- lib3ds_chunk_write(&c, io);
- lib3ds_io_write_string(io, mesh->faceL[i].material);
- lib3ds_io_write_word(io, num);
- lib3ds_io_write_word(io, (Lib3dsWord)i);
-
- for (j=i+1; j<mesh->faces; ++j) {
- if (strcmp(mesh->faceL[i].material, mesh->faceL[j].material)==0) {
- lib3ds_io_write_word(io, (Lib3dsWord)j);
- matf[j]=1;
- }
- }
- }
- }
- free(matf);
- }
-
- { /*---- SMOOTH_GROUP ----*/
- Lib3dsChunk c;
- unsigned i;
-
- c.chunk=LIB3DS_SMOOTH_GROUP;
- c.size=6+4*mesh->faces;
- lib3ds_chunk_write(&c, io);
-
- for (i=0; i<mesh->faces; ++i) {
- lib3ds_io_write_dword(io, mesh->faceL[i].smoothing);
- }
- }
-
- { /*---- MSH_BOXMAP ----*/
- Lib3dsChunk c;
-
- if (strlen(mesh->box_map.front) ||
- strlen(mesh->box_map.back) ||
- strlen(mesh->box_map.left) ||
- strlen(mesh->box_map.right) ||
- strlen(mesh->box_map.top) ||
- strlen(mesh->box_map.bottom)) {
-
- c.chunk=LIB3DS_MSH_BOXMAP;
- if (!lib3ds_chunk_write_start(&c, io)) {
- return(LIB3DS_FALSE);
- }
-
- lib3ds_io_write_string(io, mesh->box_map.front);
- lib3ds_io_write_string(io, mesh->box_map.back);
- lib3ds_io_write_string(io, mesh->box_map.left);
- lib3ds_io_write_string(io, mesh->box_map.right);
- lib3ds_io_write_string(io, mesh->box_map.top);
- lib3ds_io_write_string(io, mesh->box_map.bottom);
-
- if (!lib3ds_chunk_write_end(&c, io)) {
- return(LIB3DS_FALSE);
- }
- }
- }
-
- if (!lib3ds_chunk_write_end(&c, io)) {
- return(LIB3DS_FALSE);
- }
- return(LIB3DS_TRUE);
-}
-
-
-static Lib3dsBool
-texel_array_write(Lib3dsMesh *mesh, Lib3dsIo *io)
-{
- Lib3dsChunk c;
- unsigned i;
-
- if (!mesh->texels || !mesh->texelL) {
- return(LIB3DS_TRUE);
- }
- ASSERT(mesh->texels<0x10000);
- c.chunk=LIB3DS_TEX_VERTS;
- c.size=8+8*mesh->texels;
- lib3ds_chunk_write(&c, io);
-
- lib3ds_io_write_word(io, (Lib3dsWord)mesh->texels);
- for (i=0; i<mesh->texels; ++i) {
- lib3ds_io_write_float(io, mesh->texelL[i][0]);
- lib3ds_io_write_float(io, mesh->texelL[i][1]);
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup mesh
- */
-Lib3dsBool
-lib3ds_mesh_write(Lib3dsMesh *mesh, Lib3dsIo *io)
-{
- Lib3dsChunk c;
-
- c.chunk=LIB3DS_N_TRI_OBJECT;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
- if (!point_array_write(mesh, io)) {
- return(LIB3DS_FALSE);
- }
- if (!texel_array_write(mesh, io)) {
- return(LIB3DS_FALSE);
- }
-
- if (mesh->map_data.maptype!=LIB3DS_MAP_NONE) { /*---- LIB3DS_MESH_TEXTURE_INFO ----*/
- Lib3dsChunk c;
- int i,j;
-
- c.chunk=LIB3DS_MESH_TEXTURE_INFO;
- c.size=92;
- if (!lib3ds_chunk_write(&c,io)) {
- return(LIB3DS_FALSE);
- }
-
- lib3ds_io_write_word(io, mesh->map_data.maptype);
-
- for (i=0; i<2; ++i) {
- lib3ds_io_write_float(io, mesh->map_data.tile[i]);
- }
- for (i=0; i<3; ++i) {
- lib3ds_io_write_float(io, mesh->map_data.pos[i]);
- }
- lib3ds_io_write_float(io, mesh->map_data.scale);
-
- for (i=0; i<4; i++) {
- for (j=0; j<3; j++) {
- lib3ds_io_write_float(io, mesh->map_data.matrix[i][j]);
- }
- }
- for (i=0; i<2; ++i) {
- lib3ds_io_write_float(io, mesh->map_data.planar_size[i]);
- }
- lib3ds_io_write_float(io, mesh->map_data.cylinder_height);
- }
-
- if (!flag_array_write(mesh, io)) {
- return(LIB3DS_FALSE);
- }
- { /*---- LIB3DS_MESH_MATRIX ----*/
- Lib3dsChunk c;
- int i,j;
-
- c.chunk=LIB3DS_MESH_MATRIX;
- c.size=54;
- if (!lib3ds_chunk_write(&c,io)) {
- return(LIB3DS_FALSE);
- }
- for (i=0; i<4; i++) {
- for (j=0; j<3; j++) {
- lib3ds_io_write_float(io, mesh->matrix[i][j]);
- }
- }
- }
-
- if (mesh->color) { /*---- LIB3DS_MESH_COLOR ----*/
- Lib3dsChunk c;
-
- c.chunk=LIB3DS_MESH_COLOR;
- c.size=7;
- if (!lib3ds_chunk_write(&c,io)) {
- return(LIB3DS_FALSE);
- }
- lib3ds_io_write_byte(io, mesh->color);
- }
- if (!face_array_write(mesh, io)) {
- return(LIB3DS_FALSE);
- }
-
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
-
-\typedef Lib3dsFace
- \ingroup mesh
- \sa _Lib3dsFace
-
-*/
-/*!
-
-\typedef Lib3dsBoxMap
- \ingroup mesh
- \sa _Lib3dsBoxMap
-
-*/
-/*!
-
-\typedef Lib3dsMapData
- \ingroup mesh
- \sa _Lib3dsMapData
-
-*/
-/*!
-
-\typedef Lib3dsMesh
- \ingroup mesh
- \sa _Lib3dsMesh
-
-*/
+++ /dev/null
-/* -*- c -*- */
-#ifndef INCLUDED_LIB3DS_MESH_H
-#define INCLUDED_LIB3DS_MESH_H
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: mesh.h,v 1.16 2004/12/31 16:17:15 reed Exp $
- */
-
-#ifndef INCLUDED_LIB3DS_TYPES_H
-#include <lib3ds/types.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*!
- * Triangular mesh point
- * \ingroup mesh
- */
-typedef struct _Lib3dsPoint {
- Lib3dsVector pos;
-} Lib3dsPoint;
-
-/*!
- * Triangular mesh face
- * \ingroup mesh
- * \sa Lib3dsFaceFlag
- */
-struct _Lib3dsFace {
- Lib3dsUserData user; /*! Arbitrary user data */
- char material[64]; /*! Material name */
- Lib3dsWord points[3]; /*! Indices into mesh points list */
- Lib3dsWord flags; /*! See Lib3dsFaceFlag, below */
- Lib3dsDword smoothing; /*! Bitmask; each bit identifies a group */
- Lib3dsVector normal;
-};
-
-
-/*! Meaning of _Lib3dsFace::flags. ABC are points of the current face (A: is
-1st vertex, B is 2nd vertex, C is 3rd vertex */
-typedef enum {
- LIB3DS_FACE_FLAG_VIS_AC = 0x1, /*!< Bit 0: Edge visibility AC */
- LIB3DS_FACE_FLAG_VIS_BC = 0x2, /*!< Bit 1: Edge visibility BC */
- LIB3DS_FACE_FLAG_VIS_AB = 0x4, /*!< Bit 2: Edge visibility AB */
- LIB3DS_FACE_FLAG_WRAP_U = 0x8, /*!< Bit 3: Face is at tex U wrap seam */
- LIB3DS_FACE_FLAG_WRAP_V = 0x10, /*!< Bit 4: Face is at tex V wrap seam */
- LIB3DS_FACE_FLAG_UNK7 = 0x80, /* Bit 5-8: Unused ? */
- LIB3DS_FACE_FLAG_UNK10 = 0x400, /* Bit 9-10: Random ? */
- /* Bit 11-12: Unused ? */
- LIB3DS_FACE_FLAG_SELECT_3 = (1<<13), /*!< Bit 13: Selection of the face in selection 3*/
- LIB3DS_FACE_FLAG_SELECT_2 = (1<<14), /*!< Bit 14: Selection of the face in selection 2*/
- LIB3DS_FACE_FLAG_SELECT_1 = (1<<15) /*!< Bit 15: Selection of the face in selection 1*/
-} Lib3dsFaceFlag;
-
-/*!
- * Triangular mesh box mapping settings
- * \ingroup mesh
- */
-struct _Lib3dsBoxMap {
- char front[64];
- char back[64];
- char left[64];
- char right[64];
- char top[64];
- char bottom[64];
-};
-
-/*!
- * Lib3dsMapData maptype
- * \ingroup tracks
- */
-typedef enum {
- LIB3DS_MAP_NONE =0xFFFF,
- LIB3DS_MAP_PLANAR =0,
- LIB3DS_MAP_CYLINDRICAL =1,
- LIB3DS_MAP_SPHERICAL =2
-} Lib3dsMapType;
-
-/*!
- * Triangular mesh texture mapping data
- * \ingroup mesh
- */
-struct _Lib3dsMapData {
- Lib3dsWord maptype;
- Lib3dsVector pos;
- Lib3dsMatrix matrix;
- Lib3dsFloat scale;
- Lib3dsFloat tile[2];
- Lib3dsFloat planar_size[2];
- Lib3dsFloat cylinder_height;
-};
-
-/*!
- * Triangular mesh object
- * \ingroup mesh
- */
-struct _Lib3dsMesh {
- Lib3dsUserData user; /*! Arbitrary user data */
- Lib3dsMesh *next;
- char name[64]; /*! Mesh name */
- Lib3dsByte color;
- Lib3dsMatrix matrix; /*! Transformation matrix for mesh data */
- Lib3dsDword points; /*! Number of points in point list */
- Lib3dsPoint *pointL; /*! Point list */
- Lib3dsDword flags; /*! Number of flags in per-point flags list */
- Lib3dsWord *flagL; /*! Per-point flags list */
- Lib3dsDword texels; /*! Number of U-V texel coordinates */
- Lib3dsTexel *texelL; /*! U-V texel coordinates */
- Lib3dsDword faces; /*! Number of faces in face list */
- Lib3dsFace *faceL; /*! Face list */
- Lib3dsBoxMap box_map;
- Lib3dsMapData map_data;
-};
-
-extern LIB3DSAPI Lib3dsMesh* lib3ds_mesh_new(const char *name);
-extern LIB3DSAPI void lib3ds_mesh_free(Lib3dsMesh *mesh);
-extern LIB3DSAPI Lib3dsBool lib3ds_mesh_new_point_list(Lib3dsMesh *mesh, Lib3dsDword points);
-extern LIB3DSAPI void lib3ds_mesh_free_point_list(Lib3dsMesh *mesh);
-extern LIB3DSAPI Lib3dsBool lib3ds_mesh_new_flag_list(Lib3dsMesh *mesh, Lib3dsDword flags);
-extern LIB3DSAPI void lib3ds_mesh_free_flag_list(Lib3dsMesh *mesh);
-extern LIB3DSAPI Lib3dsBool lib3ds_mesh_new_texel_list(Lib3dsMesh *mesh, Lib3dsDword texels);
-extern LIB3DSAPI void lib3ds_mesh_free_texel_list(Lib3dsMesh *mesh);
-extern LIB3DSAPI Lib3dsBool lib3ds_mesh_new_face_list(Lib3dsMesh *mesh, Lib3dsDword flags);
-extern LIB3DSAPI void lib3ds_mesh_free_face_list(Lib3dsMesh *mesh);
-extern LIB3DSAPI void lib3ds_mesh_bounding_box(Lib3dsMesh *mesh, Lib3dsVector min, Lib3dsVector max);
-extern LIB3DSAPI void lib3ds_mesh_calculate_normals(Lib3dsMesh *mesh, Lib3dsVector *normalL);
-extern LIB3DSAPI void lib3ds_mesh_dump(Lib3dsMesh *mesh);
-extern LIB3DSAPI Lib3dsBool lib3ds_mesh_read(Lib3dsMesh *mesh, Lib3dsIo *io);
-extern LIB3DSAPI Lib3dsBool lib3ds_mesh_write(Lib3dsMesh *mesh, Lib3dsIo *io);
-
-#ifdef __cplusplus
-}
-#endif
-#endif
-
+++ /dev/null
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: node.c,v 1.13 2004/11/16 07:41:44 efalk Exp $
- */
-#define LIB3DS_EXPORT
-#include <lib3ds/node.h>
-#include <lib3ds/file.h>
-#include <lib3ds/io.h>
-#include <lib3ds/chunk.h>
-#include <lib3ds/matrix.h>
-#include <stdlib.h>
-#include <string.h>
-#include <math.h>
-#ifdef WITH_DMALLOC
-#include <dmalloc.h>
-#endif
-
-
-/*!
- * \defgroup node Animation Nodes
- *
- * \author J.E. Hoffmann <je-h@gmx.net>
- */
-
-
-/*!
- * Create and return a new ambient node.
- *
- * The node is returned with an identity matrix. All other fields
- * are zero.
- *
- * \return Lib3dsNode
- *
- * \ingroup node
- */
-Lib3dsNode*
-lib3ds_node_new_ambient()
-{
- Lib3dsNode *node=(Lib3dsNode*)calloc(sizeof(Lib3dsNode), 1);
- node->type=LIB3DS_AMBIENT_NODE;
- lib3ds_matrix_identity(node->matrix);
- return(node);
-}
-
-
-/*!
- * Create and return a new object node.
- *
- * The node is returned with an identity matrix. All other fields
- * are zero.
- *
- * \return Lib3dsNode
- *
- * \ingroup node
- */
-Lib3dsNode*
-lib3ds_node_new_object()
-{
- Lib3dsNode *node=(Lib3dsNode*)calloc(sizeof(Lib3dsNode), 1);
- node->type=LIB3DS_OBJECT_NODE;
- lib3ds_matrix_identity(node->matrix);
- return(node);
-}
-
-
-/*!
- * Create and return a new camera node.
- *
- * The node is returned with an identity matrix. All other fields
- * are zero.
- *
- * \return Lib3dsNode
- *
- * \ingroup node
- */
-Lib3dsNode*
-lib3ds_node_new_camera()
-{
- Lib3dsNode *node=(Lib3dsNode*)calloc(sizeof(Lib3dsNode), 1);
- node->type=LIB3DS_CAMERA_NODE;
- lib3ds_matrix_identity(node->matrix);
- return(node);
-}
-
-
-/*!
- * Create and return a new target node.
- *
- * The node is returned with an identity matrix. All other fields
- * are zero.
- *
- * \return Lib3dsNode
- *
- * \ingroup node
- */
-Lib3dsNode*
-lib3ds_node_new_target()
-{
- Lib3dsNode *node=(Lib3dsNode*)calloc(sizeof(Lib3dsNode), 1);
- node->type=LIB3DS_TARGET_NODE;
- lib3ds_matrix_identity(node->matrix);
- return(node);
-}
-
-
-/*!
- * Create and return a new light node.
- *
- * The node is returned with an identity matrix. All other fields
- * are zero.
- *
- * \return Lib3dsNode
- *
- * \ingroup node
- */
-Lib3dsNode*
-lib3ds_node_new_light()
-{
- Lib3dsNode *node=(Lib3dsNode*)calloc(sizeof(Lib3dsNode), 1);
- node->type=LIB3DS_LIGHT_NODE;
- lib3ds_matrix_identity(node->matrix);
- return(node);
-}
-
-
-/*!
- * Create and return a new spot node.
- *
- * The node is returned with an identity matrix. All other fields
- * are zero.
- *
- * \return Lib3dsNode
- *
- * \ingroup node
- */
-Lib3dsNode*
-lib3ds_node_new_spot()
-{
- Lib3dsNode *node=(Lib3dsNode*)calloc(sizeof(Lib3dsNode), 1);
- node->type=LIB3DS_SPOT_NODE;
- lib3ds_matrix_identity(node->matrix);
- return(node);
-}
-
-
-static void
-free_node_and_childs(Lib3dsNode *node)
-{
- ASSERT(node);
- switch (node->type) {
- case LIB3DS_UNKNOWN_NODE:
- break;
- case LIB3DS_AMBIENT_NODE:
- {
- Lib3dsAmbientData *n=&node->data.ambient;
- lib3ds_lin3_track_free_keys(&n->col_track);
- }
- break;
- case LIB3DS_OBJECT_NODE:
- {
- Lib3dsObjectData *n=&node->data.object;
-
- lib3ds_lin3_track_free_keys(&n->pos_track);
- lib3ds_quat_track_free_keys(&n->rot_track);
- lib3ds_lin3_track_free_keys(&n->scl_track);
- lib3ds_bool_track_free_keys(&n->hide_track);
- lib3ds_morph_track_free_keys(&n->morph_track);
- }
- break;
- case LIB3DS_CAMERA_NODE:
- {
- Lib3dsCameraData *n=&node->data.camera;
- lib3ds_lin3_track_free_keys(&n->pos_track);
- lib3ds_lin1_track_free_keys(&n->fov_track);
- lib3ds_lin1_track_free_keys(&n->roll_track);
- }
- break;
- case LIB3DS_TARGET_NODE:
- {
- Lib3dsTargetData *n=&node->data.target;
- lib3ds_lin3_track_free_keys(&n->pos_track);
- }
- break;
- case LIB3DS_LIGHT_NODE:
- {
- Lib3dsLightData *n=&node->data.light;
- lib3ds_lin3_track_free_keys(&n->pos_track);
- lib3ds_lin3_track_free_keys(&n->col_track);
- lib3ds_lin1_track_free_keys(&n->hotspot_track);
- lib3ds_lin1_track_free_keys(&n->falloff_track);
- lib3ds_lin1_track_free_keys(&n->roll_track);
- }
- break;
- case LIB3DS_SPOT_NODE:
- {
- Lib3dsSpotData *n=&node->data.spot;
- lib3ds_lin3_track_free_keys(&n->pos_track);
- }
- break;
- }
- {
- Lib3dsNode *p,*q;
- for (p=node->childs; p; p=q) {
- q=p->next;
- free_node_and_childs(p);
- }
- }
- node->type=LIB3DS_UNKNOWN_NODE;
- free(node);
-}
-
-
-/*!
- * Free a node and all of its resources.
- *
- * \param node Lib3dsNode object to be freed.
- *
- * \ingroup node
- */
-void
-lib3ds_node_free(Lib3dsNode *node)
-{
- ASSERT(node);
- free_node_and_childs(node);
-}
-
-
-/*!
- * Evaluate an animation node.
- *
- * Recursively sets node and its children to their appropriate values
- * for this point in the animation.
- *
- * \param node Node to be evaluated.
- * \param t time value, between 0. and file->frames
- *
- * \ingroup node
- */
-void
-lib3ds_node_eval(Lib3dsNode *node, Lib3dsFloat t)
-{
- ASSERT(node);
- switch (node->type) {
- case LIB3DS_UNKNOWN_NODE:
- {
- ASSERT(LIB3DS_FALSE);
- }
- break;
- case LIB3DS_AMBIENT_NODE:
- {
- Lib3dsAmbientData *n=&node->data.ambient;
- if (node->parent) {
- lib3ds_matrix_copy(node->matrix, node->parent->matrix);
- }
- else {
- lib3ds_matrix_identity(node->matrix);
- }
- lib3ds_lin3_track_eval(&n->col_track, n->col, t);
- }
- break;
- case LIB3DS_OBJECT_NODE:
- {
- Lib3dsMatrix M;
- Lib3dsObjectData *n=&node->data.object;
-
- lib3ds_lin3_track_eval(&n->pos_track, n->pos, t);
- lib3ds_quat_track_eval(&n->rot_track, n->rot, t);
- lib3ds_lin3_track_eval(&n->scl_track, n->scl, t);
- lib3ds_bool_track_eval(&n->hide_track, &n->hide, t);
- lib3ds_morph_track_eval(&n->morph_track, n->morph, t);
-
- lib3ds_matrix_identity(M);
- lib3ds_matrix_translate(M, n->pos);
- lib3ds_matrix_rotate(M, n->rot);
- lib3ds_matrix_scale(M, n->scl);
-
- if (node->parent) {
- lib3ds_matrix_mul(node->matrix, node->parent->matrix, M);
- }
- else {
- lib3ds_matrix_copy(node->matrix, M);
- }
- }
- break;
- case LIB3DS_CAMERA_NODE:
- {
- Lib3dsCameraData *n=&node->data.camera;
- lib3ds_lin3_track_eval(&n->pos_track, n->pos, t);
- lib3ds_lin1_track_eval(&n->fov_track, &n->fov, t);
- lib3ds_lin1_track_eval(&n->roll_track, &n->roll, t);
- if (node->parent) {
- lib3ds_matrix_copy(node->matrix, node->parent->matrix);
- }
- else {
- lib3ds_matrix_identity(node->matrix);
- }
- lib3ds_matrix_translate(node->matrix, n->pos);
- }
- break;
- case LIB3DS_TARGET_NODE:
- {
- Lib3dsTargetData *n=&node->data.target;
- lib3ds_lin3_track_eval(&n->pos_track, n->pos, t);
- if (node->parent) {
- lib3ds_matrix_copy(node->matrix, node->parent->matrix);
- }
- else {
- lib3ds_matrix_identity(node->matrix);
- }
- lib3ds_matrix_translate(node->matrix, n->pos);
- }
- break;
- case LIB3DS_LIGHT_NODE:
- {
- Lib3dsLightData *n=&node->data.light;
- lib3ds_lin3_track_eval(&n->pos_track, n->pos, t);
- lib3ds_lin3_track_eval(&n->col_track, n->col, t);
- lib3ds_lin1_track_eval(&n->hotspot_track, &n->hotspot, t);
- lib3ds_lin1_track_eval(&n->falloff_track, &n->falloff, t);
- lib3ds_lin1_track_eval(&n->roll_track, &n->roll, t);
- if (node->parent) {
- lib3ds_matrix_copy(node->matrix, node->parent->matrix);
- }
- else {
- lib3ds_matrix_identity(node->matrix);
- }
- lib3ds_matrix_translate(node->matrix, n->pos);
- }
- break;
- case LIB3DS_SPOT_NODE:
- {
- Lib3dsSpotData *n=&node->data.spot;
- lib3ds_lin3_track_eval(&n->pos_track, n->pos, t);
- if (node->parent) {
- lib3ds_matrix_copy(node->matrix, node->parent->matrix);
- }
- else {
- lib3ds_matrix_identity(node->matrix);
- }
- lib3ds_matrix_translate(node->matrix, n->pos);
- }
- break;
- }
- {
- Lib3dsNode *p;
-
- for (p=node->childs; p!=0; p=p->next) {
- lib3ds_node_eval(p, t);
- }
- }
-}
-
-
-/*!
- * Return a node object by name and type.
- *
- * This function performs a recursive search for the specified node.
- * Both name and type must match.
- *
- * \param node The parent node for the search
- * \param name The target node name.
- * \param type The target node type
- *
- * \return A pointer to the first matching node, or NULL if not found.
- *
- * \ingroup node
- */
-Lib3dsNode*
-lib3ds_node_by_name(Lib3dsNode *node, const char* name, Lib3dsNodeTypes type)
-{
- Lib3dsNode *p,*q;
-
- for (p=node->childs; p!=0; p=p->next) {
- if ((p->type==type) && (strcmp(p->name, name)==0)) {
- return(p);
- }
- q=lib3ds_node_by_name(p, name, type);
- if (q) {
- return(q);
- }
- }
- return(0);
-}
-
-
-/*!
- * Return a node object by id.
- *
- * This function performs a recursive search for the specified node.
- *
- * \param node The parent node for the search
- * \param node_id The target node id.
- *
- * \return A pointer to the first matching node, or NULL if not found.
- *
- * \ingroup node
- */
-Lib3dsNode*
-lib3ds_node_by_id(Lib3dsNode *node, Lib3dsWord node_id)
-{
- Lib3dsNode *p,*q;
-
- for (p=node->childs; p!=0; p=p->next) {
- if (p->node_id==node_id) {
- return(p);
- }
- q=lib3ds_node_by_id(p, node_id);
- if (q) {
- return(q);
- }
- }
- return(0);
-}
-
-
-static const char* node_names_table[]= {
- "***Unknown***",
- "Ambient",
- "Object",
- "Camera",
- "Target",
- "Light",
- "Spot"
-};
-
-
-/*!
- * Dump node and all descendants recursively.
- *
- * \param node The top-level node to be dumped.
- * \param level current recursion depth
- *
- * \ingroup node
- */
-void
-lib3ds_node_dump(Lib3dsNode *node, Lib3dsIntd level)
-{
- Lib3dsNode *p;
- char l[128];
-
- ASSERT(node);
- memset(l, ' ', 2*level);
- l[2*level]=0;
-
- if (node->type==LIB3DS_OBJECT_NODE) {
- printf("%s%s [%s] (%s)\n",
- l,
- node->name,
- node->data.object.instance,
- node_names_table[node->type]
- );
- }
- else {
- printf("%s%s (%s)\n",
- l,
- node->name,
- node_names_table[node->type]
- );
- }
-
- for (p=node->childs; p!=0; p=p->next) {
- lib3ds_node_dump(p, level+1);
- }
-}
-
-
-/*!
- * \ingroup node
- */
-Lib3dsBool
-lib3ds_node_read(Lib3dsNode *node, Lib3dsFile *file, Lib3dsIo *io)
-{
- Lib3dsChunk c;
- Lib3dsWord chunk;
-
- ASSERT(node);
- if (!lib3ds_chunk_read_start(&c, 0, io)) {
- return(LIB3DS_FALSE);
- }
- switch (c.chunk) {
- case LIB3DS_AMBIENT_NODE_TAG:
- case LIB3DS_OBJECT_NODE_TAG:
- case LIB3DS_CAMERA_NODE_TAG:
- case LIB3DS_TARGET_NODE_TAG:
- case LIB3DS_LIGHT_NODE_TAG:
- case LIB3DS_SPOTLIGHT_NODE_TAG:
- case LIB3DS_L_TARGET_NODE_TAG:
- break;
- default:
- return(LIB3DS_FALSE);
- }
-
- while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
- switch (chunk) {
- case LIB3DS_NODE_ID:
- {
- node->node_id=lib3ds_io_read_word(io);
- lib3ds_chunk_dump_info(" ID = %d", (short)node->node_id);
- }
- break;
- case LIB3DS_NODE_HDR:
- {
- if (!lib3ds_io_read_string(io, node->name, 64)) {
- return(LIB3DS_FALSE);
- }
- node->flags1=lib3ds_io_read_word(io);
- node->flags2=lib3ds_io_read_word(io);
- node->parent_id=lib3ds_io_read_word(io);
- lib3ds_chunk_dump_info(" NAME =%s", node->name);
- lib3ds_chunk_dump_info(" PARENT=%d", (short)node->parent_id);
- }
- break;
- case LIB3DS_PIVOT:
- {
- if (node->type==LIB3DS_OBJECT_NODE) {
- int i;
- for (i=0; i<3; ++i) {
- node->data.object.pivot[i]=lib3ds_io_read_float(io);
- }
- }
- else {
- lib3ds_chunk_unknown(chunk);
- }
- }
- break;
- case LIB3DS_INSTANCE_NAME:
- {
- if (node->type==LIB3DS_OBJECT_NODE) {
- if (!lib3ds_io_read_string(io, node->data.object.instance, 64)) {
- return(LIB3DS_FALSE);
- }
- }
- else {
- lib3ds_chunk_unknown(chunk);
- }
- }
- break;
- case LIB3DS_BOUNDBOX:
- {
- if (node->type==LIB3DS_OBJECT_NODE) {
- int i;
- for (i=0; i<3; ++i) {
- node->data.object.bbox_min[i]=lib3ds_io_read_float(io);
- }
- for (i=0; i<3; ++i) {
- node->data.object.bbox_max[i]=lib3ds_io_read_float(io);
- }
- }
- else {
- lib3ds_chunk_unknown(chunk);
- }
- }
- break;
- case LIB3DS_COL_TRACK_TAG:
- {
- Lib3dsBool result=LIB3DS_TRUE;
-
- switch (node->type) {
- case LIB3DS_AMBIENT_NODE:
- result=lib3ds_lin3_track_read(&node->data.ambient.col_track, io);
- break;
- case LIB3DS_LIGHT_NODE:
- result=lib3ds_lin3_track_read(&node->data.light.col_track, io);
- break;
- default:
- lib3ds_chunk_unknown(chunk);
- }
- if (!result) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_POS_TRACK_TAG:
- {
- Lib3dsBool result=LIB3DS_TRUE;
-
- switch (node->type) {
- case LIB3DS_OBJECT_NODE:
- result=lib3ds_lin3_track_read(&node->data.object.pos_track, io);
- break;
- case LIB3DS_CAMERA_NODE:
- result=lib3ds_lin3_track_read(&node->data.camera.pos_track, io);
- break;
- case LIB3DS_TARGET_NODE:
- result=lib3ds_lin3_track_read(&node->data.target.pos_track, io);
- break;
- case LIB3DS_LIGHT_NODE:
- result=lib3ds_lin3_track_read(&node->data.light.pos_track, io);
- break;
- case LIB3DS_SPOT_NODE:
- result=lib3ds_lin3_track_read(&node->data.spot.pos_track, io);
- break;
- default:
- lib3ds_chunk_unknown(chunk);
- }
- if (!result) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_ROT_TRACK_TAG:
- {
- if (node->type==LIB3DS_OBJECT_NODE) {
- if (!lib3ds_quat_track_read(&node->data.object.rot_track, io)) {
- return(LIB3DS_FALSE);
- }
- }
- else {
- lib3ds_chunk_unknown(chunk);
- }
- }
- break;
- case LIB3DS_SCL_TRACK_TAG:
- {
- if (node->type==LIB3DS_OBJECT_NODE) {
- if (!lib3ds_lin3_track_read(&node->data.object.scl_track, io)) {
- return(LIB3DS_FALSE);
- }
- }
- else {
- lib3ds_chunk_unknown(chunk);
- }
- }
- break;
- case LIB3DS_FOV_TRACK_TAG:
- {
- if (node->type==LIB3DS_CAMERA_NODE) {
- if (!lib3ds_lin1_track_read(&node->data.camera.fov_track, io)) {
- return(LIB3DS_FALSE);
- }
- }
- else {
- lib3ds_chunk_unknown(chunk);
- }
- }
- break;
- case LIB3DS_HOT_TRACK_TAG:
- {
- if (node->type==LIB3DS_LIGHT_NODE) {
- if (!lib3ds_lin1_track_read(&node->data.light.hotspot_track, io)) {
- return(LIB3DS_FALSE);
- }
- }
- else {
- lib3ds_chunk_unknown(chunk);
- }
- }
- break;
- case LIB3DS_FALL_TRACK_TAG:
- {
- if (node->type==LIB3DS_LIGHT_NODE) {
- if (!lib3ds_lin1_track_read(&node->data.light.falloff_track, io)) {
- return(LIB3DS_FALSE);
- }
- }
- else {
- lib3ds_chunk_unknown(chunk);
- }
- }
- break;
- case LIB3DS_ROLL_TRACK_TAG:
- {
- Lib3dsBool result=LIB3DS_TRUE;
-
- switch (node->type) {
- case LIB3DS_CAMERA_NODE:
- result=lib3ds_lin1_track_read(&node->data.camera.roll_track, io);
- break;
- case LIB3DS_LIGHT_NODE:
- result=lib3ds_lin1_track_read(&node->data.light.roll_track, io);
- break;
- default:
- lib3ds_chunk_unknown(chunk);
- }
- if (!result) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_HIDE_TRACK_TAG:
- {
- if (node->type==LIB3DS_OBJECT_NODE) {
- if (!lib3ds_bool_track_read(&node->data.object.hide_track, io)) {
- return(LIB3DS_FALSE);
- }
- }
- else {
- lib3ds_chunk_unknown(chunk);
- }
- }
- break;
- case LIB3DS_MORPH_SMOOTH:
- {
- if (node->type==LIB3DS_OBJECT_NODE) {
- node->data.object.morph_smooth=lib3ds_io_read_float(io);
- }
- else {
- lib3ds_chunk_unknown(chunk);
- }
- }
- break;
- case LIB3DS_MORPH_TRACK_TAG:
- {
- if (node->type==LIB3DS_OBJECT_NODE) {
- if (!lib3ds_morph_track_read(&node->data.object.morph_track, io)) {
- return(LIB3DS_FALSE);
- }
- }
- else {
- lib3ds_chunk_unknown(chunk);
- }
- }
- break;
- default:
- lib3ds_chunk_unknown(chunk);
- }
- }
-
- lib3ds_chunk_read_end(&c, io);
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup node
- */
-Lib3dsBool
-lib3ds_node_write(Lib3dsNode *node, Lib3dsFile *file, Lib3dsIo *io)
-{
- Lib3dsChunk c;
-
- switch (node->type) {
- case LIB3DS_AMBIENT_NODE:
- c.chunk=LIB3DS_AMBIENT_NODE_TAG;
- break;
- case LIB3DS_OBJECT_NODE:
- c.chunk=LIB3DS_OBJECT_NODE_TAG;
- break;
- case LIB3DS_CAMERA_NODE:
- c.chunk=LIB3DS_CAMERA_NODE_TAG;
- break;
- case LIB3DS_TARGET_NODE:
- c.chunk=LIB3DS_TARGET_NODE_TAG;
- break;
- case LIB3DS_LIGHT_NODE:
- if (lib3ds_file_node_by_name(file, node->name, LIB3DS_SPOT_NODE)) {
- c.chunk=LIB3DS_SPOTLIGHT_NODE_TAG;
- }
- else {
- c.chunk=LIB3DS_LIGHT_NODE_TAG;
- }
- break;
- case LIB3DS_SPOT_NODE:
- c.chunk=LIB3DS_L_TARGET_NODE_TAG;
- break;
- default:
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
-
- { /*---- LIB3DS_NODE_ID ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_NODE_ID;
- c.size=8;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_intw(io, node->node_id);
- }
-
- { /*---- LIB3DS_NODE_HDR ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_NODE_HDR;
- c.size=6+ 1+strlen(node->name) +2+2+2;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_string(io, node->name);
- lib3ds_io_write_word(io, node->flags1);
- lib3ds_io_write_word(io, node->flags2);
- lib3ds_io_write_word(io, node->parent_id);
- }
-
- switch (c.chunk) {
- case LIB3DS_AMBIENT_NODE_TAG:
- { /*---- LIB3DS_COL_TRACK_TAG ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_COL_TRACK_TAG;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_lin3_track_write(&node->data.ambient.col_track,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_OBJECT_NODE_TAG:
- { /*---- LIB3DS_PIVOT ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_PIVOT;
- c.size=18;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_vector(io, node->data.object.pivot);
- }
- { /*---- LIB3DS_INSTANCE_NAME ----*/
- Lib3dsChunk c;
- const char *name;
- if (strlen(node->data.object.instance)) {
- name=node->data.object.instance;
-
- c.chunk=LIB3DS_INSTANCE_NAME;
- c.size=6+1+strlen(name);
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_string(io, name);
- }
- }
- {
- int i;
- for (i=0; i<3; ++i) {
- if ((fabs(node->data.object.bbox_min[i])>LIB3DS_EPSILON) ||
- (fabs(node->data.object.bbox_max[i])>LIB3DS_EPSILON)) {
- break;
- }
- }
-
- if (i<3) { /*---- LIB3DS_BOUNDBOX ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_BOUNDBOX;
- c.size=30;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_vector(io, node->data.object.bbox_min);
- lib3ds_io_write_vector(io, node->data.object.bbox_max);
- }
- }
- { /*---- LIB3DS_POS_TRACK_TAG ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_POS_TRACK_TAG;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_lin3_track_write(&node->data.object.pos_track,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- }
- { /*---- LIB3DS_ROT_TRACK_TAG ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_ROT_TRACK_TAG;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_quat_track_write(&node->data.object.rot_track,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- }
- { /*---- LIB3DS_SCL_TRACK_TAG ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_SCL_TRACK_TAG;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_lin3_track_write(&node->data.object.scl_track,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- }
- if (node->data.object.hide_track.keyL) { /*---- LIB3DS_HIDE_TRACK_TAG ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_HIDE_TRACK_TAG;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_bool_track_write(&node->data.object.hide_track,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- }
- if (fabs(node->data.object.morph_smooth)>LIB3DS_EPSILON){ /*---- LIB3DS_MORPH_SMOOTH ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_MORPH_SMOOTH;
- c.size=10;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_float(io, node->data.object.morph_smooth);
- }
- break;
- case LIB3DS_CAMERA_NODE_TAG:
- { /*---- LIB3DS_POS_TRACK_TAG ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_POS_TRACK_TAG;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_lin3_track_write(&node->data.camera.pos_track,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- }
- { /*---- LIB3DS_FOV_TRACK_TAG ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_FOV_TRACK_TAG;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_lin1_track_write(&node->data.camera.fov_track,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- }
- { /*---- LIB3DS_ROLL_TRACK_TAG ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_ROLL_TRACK_TAG;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_lin1_track_write(&node->data.camera.roll_track,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_TARGET_NODE_TAG:
- { /*---- LIB3DS_POS_TRACK_TAG ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_POS_TRACK_TAG;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_lin3_track_write(&node->data.target.pos_track,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_LIGHT_NODE_TAG:
- { /*---- LIB3DS_POS_TRACK_TAG ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_POS_TRACK_TAG;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_lin3_track_write(&node->data.light.pos_track,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- }
- { /*---- LIB3DS_COL_TRACK_TAG ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_COL_TRACK_TAG;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_lin3_track_write(&node->data.light.col_track,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_SPOTLIGHT_NODE_TAG:
- { /*---- LIB3DS_POS_TRACK_TAG ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_POS_TRACK_TAG;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_lin3_track_write(&node->data.light.pos_track,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- }
- { /*---- LIB3DS_COL_TRACK_TAG ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_COL_TRACK_TAG;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_lin3_track_write(&node->data.light.col_track,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- }
- { /*---- LIB3DS_HOT_TRACK_TAG ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_HOT_TRACK_TAG;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_lin1_track_write(&node->data.light.hotspot_track,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- }
- { /*---- LIB3DS_FALL_TRACK_TAG ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_FALL_TRACK_TAG;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_lin1_track_write(&node->data.light.falloff_track,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- }
- { /*---- LIB3DS_ROLL_TRACK_TAG ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_ROLL_TRACK_TAG;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_lin1_track_write(&node->data.light.roll_track,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- case LIB3DS_L_TARGET_NODE_TAG:
- { /*---- LIB3DS_POS_TRACK_TAG ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_POS_TRACK_TAG;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_lin3_track_write(&node->data.spot.pos_track,io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- }
- break;
- default:
- return(LIB3DS_FALSE);
- }
-
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
-
-\typedef Lib3dsNodeTypes
- \ingroup node
-
-*/
-/*!
-
-\enum _Lib3dsNodeTypes
- \ingroup node
-
-*/
-/*!
-
-\typedef Lib3dsBoolKey
- \ingroup node
- \sa _Lib3dsBoolKey
-
-*/
-/*!
-
-\typedef Lib3dsBoolTrack
- \ingroup node
- \sa _Lib3dsBoolTrack
-
-*/
-/*!
-
-\typedef Lib3dsLin1Key
- \ingroup node
- \sa _Lib3dsLin1Key
-
-*/
-/*!
-
-\typedef Lib3dsLin1Track
- \ingroup node
- \sa _Lib3dsLin1Track
-
-*/
-/*!
-
-\typedef Lib3dsLin3Key
- \ingroup node
- \sa _Lib3dsLin3Key
-
-*/
-/*!
-
-\typedef Lib3dsLin3Track
- \ingroup node
- \sa _Lib3dsLin3Track
-
-*/
-/*!
-
-\typedef Lib3dsQuatKey
- \ingroup node
- \sa _Lib3dsQuatKey
-
-*/
-/*!
-
-\typedef Lib3dsQuatTrack
- \ingroup node
- \sa _Lib3dsLin3Key
-
-*/
-/*!
-
-\typedef Lib3dsMorphKey
- \ingroup node
- \sa _Lib3dsMorphKey
-
-*/
-/*!
-
-\typedef Lib3dsMorphTrack
- \ingroup node
- \sa _Lib3dsMorphTrack
-
-*/
-
-
+++ /dev/null
-/* -*- c -*- */
-#ifndef INCLUDED_LIB3DS_NODE_H
-#define INCLUDED_LIB3DS_NODE_H
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: node.h,v 1.9 2004/12/31 16:17:15 reed Exp $
- */
-
-#ifndef INCLUDED_LIB3DS_TRACKS_H
-#include <lib3ds/tracks.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*!
- * Scene graph ambient color node data
- * \ingroup node
- */
-typedef struct _Lib3dsAmbientData {
- Lib3dsRgb col;
- Lib3dsLin3Track col_track;
-} Lib3dsAmbientData;
-
-/*!
- * Scene graph object instance node data
- * \ingroup node
- */
-typedef struct _Lib3dsObjectData {
- Lib3dsVector pivot;
- char instance[64];
- Lib3dsVector bbox_min;
- Lib3dsVector bbox_max;
- Lib3dsVector pos;
- Lib3dsLin3Track pos_track;
- Lib3dsQuat rot;
- Lib3dsQuatTrack rot_track;
- Lib3dsVector scl;
- Lib3dsLin3Track scl_track;
- Lib3dsFloat morph_smooth;
- char morph[64];
- Lib3dsMorphTrack morph_track;
- Lib3dsBool hide;
- Lib3dsBoolTrack hide_track;
-} Lib3dsObjectData;
-
-/*!
- * Scene graph camera node data
- * \ingroup node
- */
-typedef struct _Lib3dsCameraData {
- Lib3dsVector pos;
- Lib3dsLin3Track pos_track;
- Lib3dsFloat fov;
- Lib3dsLin1Track fov_track;
- Lib3dsFloat roll;
- Lib3dsLin1Track roll_track;
-} Lib3dsCameraData;
-
-/*!
- * Scene graph camera target node data
- * \ingroup node
- */
-typedef struct _Lib3dsTargetData {
- Lib3dsVector pos;
- Lib3dsLin3Track pos_track;
-} Lib3dsTargetData;
-
-/*!
- * Scene graph light node data
- * \ingroup node
- */
-typedef struct _Lib3dsLightData {
- Lib3dsVector pos;
- Lib3dsLin3Track pos_track;
- Lib3dsRgb col;
- Lib3dsLin3Track col_track;
- Lib3dsFloat hotspot;
- Lib3dsLin1Track hotspot_track;
- Lib3dsFloat falloff;
- Lib3dsLin1Track falloff_track;
- Lib3dsFloat roll;
- Lib3dsLin1Track roll_track;
-} Lib3dsLightData;
-
-/*!
- * Scene graph spotlight target node data
- * \ingroup node
- */
-typedef struct _Lib3dsSpotData {
- Lib3dsVector pos;
- Lib3dsLin3Track pos_track;
-} Lib3dsSpotData;
-
-/*!
- * Scene graph node data union
- * \ingroup node
- */
-typedef union _Lib3dsNodeData {
- Lib3dsAmbientData ambient;
- Lib3dsObjectData object;
- Lib3dsCameraData camera;
- Lib3dsTargetData target;
- Lib3dsLightData light;
- Lib3dsSpotData spot;
-} Lib3dsNodeData;
-
-/*!
- * \ingroup node
- */
-#define LIB3DS_NO_PARENT 65535
-
-/*!
- * Scene graph node
- * \ingroup node
- */
-struct _Lib3dsNode {
- Lib3dsUserData user;
- Lib3dsNode *next;\
- Lib3dsNode *childs;\
- Lib3dsNode *parent;\
- Lib3dsNodeTypes type;\
- Lib3dsWord node_id;\
- char name[64];\
- Lib3dsWord flags1;\
- Lib3dsWord flags2;\
- Lib3dsWord parent_id;
- Lib3dsMatrix matrix;
- Lib3dsNodeData data;
-};
-
-/*!
- * Node flags
- * \ingroup node
- */
-typedef enum {
- LIB3DS_HIDDEN = 0x800
-} Lib3dsNodeFlags1;
-
-/*!
- * Node flags
- * \ingroup node
- */
-typedef enum {
- LIB3DS_SHOW_PATH = 0x1,
- LIB3DS_SMOOTHING = 0x2,
- LIB3DS_MOTION_BLUR = 0x10,
- LIB3DS_MORPH_MATERIALS = 0x40
-} Lib3dsNodeFlags2;
-
-extern LIB3DSAPI Lib3dsNode* lib3ds_node_new_ambient();
-extern LIB3DSAPI Lib3dsNode* lib3ds_node_new_object();
-extern LIB3DSAPI Lib3dsNode* lib3ds_node_new_camera();
-extern LIB3DSAPI Lib3dsNode* lib3ds_node_new_target();
-extern LIB3DSAPI Lib3dsNode* lib3ds_node_new_light();
-extern LIB3DSAPI Lib3dsNode* lib3ds_node_new_spot();
-extern LIB3DSAPI void lib3ds_node_free(Lib3dsNode *node);
-extern LIB3DSAPI void lib3ds_node_eval(Lib3dsNode *node, Lib3dsFloat t);
-extern LIB3DSAPI Lib3dsNode* lib3ds_node_by_name(Lib3dsNode *node, const char* name,
- Lib3dsNodeTypes type);
-extern LIB3DSAPI Lib3dsNode* lib3ds_node_by_id(Lib3dsNode *node, Lib3dsWord node_id);
-extern LIB3DSAPI void lib3ds_node_dump(Lib3dsNode *node, Lib3dsIntd level);
-extern LIB3DSAPI Lib3dsBool lib3ds_node_read(Lib3dsNode *node, Lib3dsFile *file, Lib3dsIo *io);
-extern LIB3DSAPI Lib3dsBool lib3ds_node_write(Lib3dsNode *node, Lib3dsFile *file, Lib3dsIo *io);
-
-#ifdef __cplusplus
-}
-#endif
-#endif
-
+++ /dev/null
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: quat.c,v 1.6 2004/11/20 08:31:31 efalk Exp $
- */
-#define LIB3DS_EXPORT
-#include <lib3ds/quat.h>
-#include <math.h>
-
-
-/*!
- * \defgroup quat Quaternion Mathematics
- *
- * \author J.E. Hoffmann <je-h@gmx.net>
- */
-/*!
- * \typedef Lib3dsQuat
- * \ingroup quat
- */
-
-
-/*!
- * Clear a quaternion.
- * \ingroup quat
- */
-void
-lib3ds_quat_zero(Lib3dsQuat c)
-{
- c[0]=c[1]=c[2]=c[3]=0.0f;
-}
-
-
-/*!
- * Set a quaternion to Identity
- * \ingroup quat
- */
-void
-lib3ds_quat_identity(Lib3dsQuat c)
-{
- c[0]=c[1]=c[2]=0.0f;
- c[3]=1.0f;
-}
-
-
-/*!
- * Copy a quaternion.
- * \ingroup quat
- */
-void
-lib3ds_quat_copy(Lib3dsQuat dest, Lib3dsQuat src)
-{
- int i;
- for (i=0; i<4; ++i) {
- dest[i]=src[i];
- }
-}
-
-
-/*!
- * Compute a quaternion from axis and angle.
- *
- * \param c Computed quaternion
- * \param axis Rotation axis
- * \param angle Angle of rotation, radians.
- *
- * \ingroup quat
- */
-void
-lib3ds_quat_axis_angle(Lib3dsQuat c, Lib3dsVector axis, Lib3dsFloat angle)
-{
- Lib3dsDouble omega,s;
- Lib3dsDouble l;
-
- l=sqrt(axis[0]*axis[0] + axis[1]*axis[1] + axis[2]*axis[2]);
- if (l<LIB3DS_EPSILON) {
- c[0]=c[1]=c[2]=0.0f;
- c[3]=1.0f;
- }
- else {
- omega=-0.5*angle;
- s=sin(omega)/l;
- c[0]=(Lib3dsFloat)s*axis[0];
- c[1]=(Lib3dsFloat)s*axis[1];
- c[2]=(Lib3dsFloat)s*axis[2];
- c[3]=(Lib3dsFloat)cos(omega);
- }
-}
-
-
-/*!
- * Negate a quaternion
- *
- * \ingroup quat
- */
-void
-lib3ds_quat_neg(Lib3dsQuat c)
-{
- int i;
- for (i=0; i<4; ++i) {
- c[i]=-c[i];
- }
-}
-
-
-/*!
- * Compute the absolute value of a quaternion
- *
- * \ingroup quat
- */
-void
-lib3ds_quat_abs(Lib3dsQuat c)
-{
- int i;
- for (i=0; i<4; ++i) {
- c[i]=(Lib3dsFloat)fabs(c[i]);
- }
-}
-
-
-/*!
- * Compute the conjugate of a quaternion
- *
- * \ingroup quat
- */
-void
-lib3ds_quat_cnj(Lib3dsQuat c)
-{
- int i;
- for (i=0; i<3; ++i) {
- c[i]=-c[i];
- }
-}
-
-
-/*!
- * Multiply two quaternions.
- *
- * \param c Result
- * \param a,b Inputs
- * \ingroup quat
- */
-void
-lib3ds_quat_mul(Lib3dsQuat c, Lib3dsQuat a, Lib3dsQuat b)
-{
- c[0]=a[3]*b[0] + a[0]*b[3] + a[1]*b[2] - a[2]*b[1];
- c[1]=a[3]*b[1] + a[1]*b[3] + a[2]*b[0] - a[0]*b[2];
- c[2]=a[3]*b[2] + a[2]*b[3] + a[0]*b[1] - a[1]*b[0];
- c[3]=a[3]*b[3] - a[0]*b[0] - a[1]*b[1] - a[2]*b[2];
-}
-
-
-/*!
- * Multiply a quaternion by a scalar.
- *
- * \ingroup quat
- */
-void
-lib3ds_quat_scalar(Lib3dsQuat c, Lib3dsFloat k)
-{
- int i;
- for (i=0; i<4; ++i) {
- c[i]*=k;
- }
-}
-
-
-/*!
- * Normalize a quaternion.
- *
- * \ingroup quat
- */
-void
-lib3ds_quat_normalize(Lib3dsQuat c)
-{
- Lib3dsDouble l,m;
-
- l=sqrt(c[0]*c[0] + c[1]*c[1] + c[2]*c[2] + c[3]*c[3]);
- if (fabs(l)<LIB3DS_EPSILON) {
- c[0]=c[1]=c[2]=0.0f;
- c[3]=1.0f;
- }
- else {
- int i;
- m=1.0f/l;
- for (i=0; i<4; ++i) {
- c[i]=(Lib3dsFloat)(c[i]*m);
- }
- }
-}
-
-
-/*!
- * Compute the inverse of a quaternion.
- *
- * \ingroup quat
- */
-void
-lib3ds_quat_inv(Lib3dsQuat c)
-{
- Lib3dsDouble l,m;
-
- l=sqrt(c[0]*c[0] + c[1]*c[1] + c[2]*c[2] + c[3]*c[3]);
- if (fabs(l)<LIB3DS_EPSILON) {
- c[0]=c[1]=c[2]=0.0f;
- c[3]=1.0f;
- }
- else {
- m=1.0f/l;
- c[0]=(Lib3dsFloat)(-c[0]*m);
- c[1]=(Lib3dsFloat)(-c[1]*m);
- c[2]=(Lib3dsFloat)(-c[2]*m);
- c[3]=(Lib3dsFloat)(c[3]*m);
- }
-}
-
-
-/*!
- * Compute the dot-product of a quaternion.
- *
- * \ingroup quat
- */
-Lib3dsFloat
-lib3ds_quat_dot(Lib3dsQuat a, Lib3dsQuat b)
-{
- return(a[0]*b[0] + a[1]*b[1] + a[2]*b[2] + a[3]*b[3]);
-}
-
-
-/*!
- * \ingroup quat
- */
-Lib3dsFloat
-lib3ds_quat_squared(Lib3dsQuat c)
-{
- return(c[0]*c[0] + c[1]*c[1] + c[2]*c[2] + c[3]*c[3]);
-}
-
-
-/*!
- * \ingroup quat
- */
-Lib3dsFloat
-lib3ds_quat_length(Lib3dsQuat c)
-{
- return((Lib3dsFloat)sqrt(c[0]*c[0] + c[1]*c[1] + c[2]*c[2] + c[3]*c[3]));
-}
-
-
-/*!
- * \ingroup quat
- */
-void
-lib3ds_quat_ln(Lib3dsQuat c)
-{
- Lib3dsDouble om,s,t;
-
- s=sqrt(c[0]*c[0] + c[1]*c[1] + c[2]*c[2]);
- om=atan2(s,c[3]);
- if (fabs(s)<LIB3DS_EPSILON) {
- t=0.0f;
- }
- else {
- t=om/s;
- }
- {
- int i;
- for (i=0; i<3; ++i) {
- c[i]=(Lib3dsFloat)(c[i]*t);
- }
- c[3]=0.0f;
- }
-}
-
-
-/*!
- * \ingroup quat
- */
-void
-lib3ds_quat_ln_dif(Lib3dsQuat c, Lib3dsQuat a, Lib3dsQuat b)
-{
- Lib3dsQuat invp;
-
- lib3ds_quat_copy(invp, a);
- lib3ds_quat_inv(invp);
- lib3ds_quat_mul(c, invp, b);
- lib3ds_quat_ln(c);
-}
-
-
-/*!
- * \ingroup quat
- */
-void
-lib3ds_quat_exp(Lib3dsQuat c)
-{
- Lib3dsDouble om,sinom;
-
- om=sqrt(c[0]*c[0] + c[1]*c[1] + c[2]*c[2]);
- if (fabs(om)<LIB3DS_EPSILON) {
- sinom=1.0f;
- }
- else {
- sinom=sin(om)/om;
- }
- {
- int i;
- for (i=0; i<3; ++i) {
- c[i]=(Lib3dsFloat)(c[i]*sinom);
- }
- c[3]=(Lib3dsFloat)cos(om);
- }
-}
-
-
-/*!
- * \ingroup quat
- */
-void
-lib3ds_quat_slerp(Lib3dsQuat c, Lib3dsQuat a, Lib3dsQuat b, Lib3dsFloat t)
-{
- Lib3dsDouble l;
- Lib3dsDouble om,sinom;
- Lib3dsDouble sp,sq;
- Lib3dsQuat q;
-
- l=a[0]*b[0] + a[1]*b[1] + a[2]*b[2] + a[3]*b[3];
- if ((1.0+l)>LIB3DS_EPSILON) {
- if (fabs(l)>1.0f) l/=fabs(l);
- om=acos(l);
- sinom=sin(om);
- if (fabs(sinom)>LIB3DS_EPSILON) {
- sp=sin((1.0f-t)*om)/sinom;
- sq=sin(t*om)/sinom;
- }
- else {
- sp=1.0f-t;
- sq=t;
- }
- c[0]=(Lib3dsFloat)(sp*a[0] + sq*b[0]);
- c[1]=(Lib3dsFloat)(sp*a[1] + sq*b[1]);
- c[2]=(Lib3dsFloat)(sp*a[2] + sq*b[2]);
- c[3]=(Lib3dsFloat)(sp*a[3] + sq*b[3]);
- }
- else {
- q[0]=-a[1];
- q[1]=a[0];
- q[2]=-a[3];
- q[3]=a[2];
- sp=sin((1.0-t)*LIB3DS_HALFPI);
- sq=sin(t*LIB3DS_HALFPI);
- c[0]=(Lib3dsFloat)(sp*a[0] + sq*q[0]);
- c[1]=(Lib3dsFloat)(sp*a[1] + sq*q[1]);
- c[2]=(Lib3dsFloat)(sp*a[2] + sq*q[2]);
- c[3]=(Lib3dsFloat)(sp*a[3] + sq*q[3]);
- }
-}
-
-
-/*!
- * \ingroup quat
- */
-void
-lib3ds_quat_squad(Lib3dsQuat c, Lib3dsQuat a, Lib3dsQuat p, Lib3dsQuat q,
- Lib3dsQuat b, Lib3dsFloat t)
-{
- Lib3dsQuat ab;
- Lib3dsQuat pq;
-
- lib3ds_quat_slerp(ab,a,b,t);
- lib3ds_quat_slerp(pq,p,q,t);
- lib3ds_quat_slerp(c,ab,pq,2*t*(1-t));
-}
-
-
-/*!
- * \ingroup quat
- */
-void
-lib3ds_quat_tangent(Lib3dsQuat c, Lib3dsQuat p, Lib3dsQuat q, Lib3dsQuat n)
-{
- Lib3dsQuat dn,dp,x;
- int i;
-
- lib3ds_quat_ln_dif(dn, q, n);
- lib3ds_quat_ln_dif(dp, q, p);
-
- for (i=0; i<4; i++) {
- x[i]=-1.0f/4.0f*(dn[i]+dp[i]);
- }
- lib3ds_quat_exp(x);
- lib3ds_quat_mul(c,q,x);
-}
-
-
-/*!
- * \ingroup quat
- */
-void
-lib3ds_quat_dump(Lib3dsQuat q)
-{
- printf("%f %f %f %f\n", q[0], q[1], q[2], q[3]);
-}
-
+++ /dev/null
-/* -*- c -*- */
-#ifndef INCLUDED_LIB3DS_QUAT_H
-#define INCLUDED_LIB3DS_QUAT_H
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: quat.h,v 1.6 2004/12/31 16:17:15 reed Exp $
- */
-
-#ifndef INCLUDED_LIB3DS_TYPES_H
-#include <lib3ds/types.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-extern LIB3DSAPI void lib3ds_quat_zero(Lib3dsQuat c);
-extern LIB3DSAPI void lib3ds_quat_identity(Lib3dsQuat c);
-extern LIB3DSAPI void lib3ds_quat_copy(Lib3dsQuat dest, Lib3dsQuat src);
-extern LIB3DSAPI void lib3ds_quat_axis_angle(Lib3dsQuat c, Lib3dsVector axis, Lib3dsFloat angle);
-extern LIB3DSAPI void lib3ds_quat_neg(Lib3dsQuat c);
-extern LIB3DSAPI void lib3ds_quat_abs(Lib3dsQuat c);
-extern LIB3DSAPI void lib3ds_quat_cnj(Lib3dsQuat c);
-extern LIB3DSAPI void lib3ds_quat_mul(Lib3dsQuat c, Lib3dsQuat a, Lib3dsQuat b);
-extern LIB3DSAPI void lib3ds_quat_scalar(Lib3dsQuat c, Lib3dsFloat k);
-extern LIB3DSAPI void lib3ds_quat_normalize(Lib3dsQuat c);
-extern LIB3DSAPI void lib3ds_quat_inv(Lib3dsQuat c);
-extern LIB3DSAPI Lib3dsFloat lib3ds_quat_dot(Lib3dsQuat a, Lib3dsQuat b);
-extern LIB3DSAPI Lib3dsFloat lib3ds_quat_squared(Lib3dsQuat c);
-extern LIB3DSAPI Lib3dsFloat lib3ds_quat_length(Lib3dsQuat c);
-extern LIB3DSAPI void lib3ds_quat_ln(Lib3dsQuat c);
-extern LIB3DSAPI void lib3ds_quat_ln_dif(Lib3dsQuat c, Lib3dsQuat a, Lib3dsQuat b);
-extern LIB3DSAPI void lib3ds_quat_exp(Lib3dsQuat c);
-extern LIB3DSAPI void lib3ds_quat_slerp(Lib3dsQuat c, Lib3dsQuat a, Lib3dsQuat b, Lib3dsFloat t);
-extern LIB3DSAPI void lib3ds_quat_squad(Lib3dsQuat c, Lib3dsQuat a, Lib3dsQuat p, Lib3dsQuat q,
- Lib3dsQuat b, Lib3dsFloat t);
-extern LIB3DSAPI void lib3ds_quat_tangent(Lib3dsQuat c, Lib3dsQuat p, Lib3dsQuat q, Lib3dsQuat n);
-extern LIB3DSAPI void lib3ds_quat_dump(Lib3dsQuat q);
-
-#ifdef __cplusplus
-}
-#endif
-#endif
-
+++ /dev/null
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: shadow.c,v 1.8 2001/07/07 19:05:30 jeh Exp $
- */
-#define LIB3DS_EXPORT
-#include <lib3ds/shadow.h>
-#include <lib3ds/chunk.h>
-#include <lib3ds/io.h>
-#include <math.h>
-
-
-/*!
- * \defgroup shadow Shadow Map Settings
- *
- * \author J.E. Hoffmann <je-h@gmx.net>
- */
-
-
-/*!
- * \ingroup shadow
- */
-Lib3dsBool
-lib3ds_shadow_read(Lib3dsShadow *shadow, Lib3dsIo *io)
-{
- Lib3dsChunk c;
-
- if (!lib3ds_chunk_read(&c, io)) {
- return(LIB3DS_FALSE);
- }
-
- switch (c.chunk) {
- case LIB3DS_SHADOW_MAP_SIZE:
- {
- shadow->map_size=lib3ds_io_read_intw(io);
- }
- break;
- case LIB3DS_LO_SHADOW_BIAS:
- {
- shadow->lo_bias=lib3ds_io_read_float(io);
- }
- break;
- case LIB3DS_HI_SHADOW_BIAS:
- {
- shadow->hi_bias=lib3ds_io_read_float(io);
- }
- break;
- case LIB3DS_SHADOW_SAMPLES:
- {
- shadow->samples=lib3ds_io_read_intw(io);
- }
- break;
- case LIB3DS_SHADOW_RANGE:
- {
- shadow->range=lib3ds_io_read_intd(io);
- }
- break;
- case LIB3DS_SHADOW_FILTER:
- {
- shadow->filter=lib3ds_io_read_float(io);
- }
- break;
- case LIB3DS_RAY_BIAS:
- {
- shadow->ray_bias=lib3ds_io_read_float(io);
- }
- break;
- }
-
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup shadow
- */
-Lib3dsBool
-lib3ds_shadow_write(Lib3dsShadow *shadow, Lib3dsIo *io)
-{
- if (fabs(shadow->lo_bias)>LIB3DS_EPSILON) { /*---- LIB3DS_LO_SHADOW_BIAS ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_LO_SHADOW_BIAS;
- c.size=10;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_float(io, shadow->lo_bias);
- }
-
- if (fabs(shadow->hi_bias)>LIB3DS_EPSILON) { /*---- LIB3DS_HI_SHADOW_BIAS ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_HI_SHADOW_BIAS;
- c.size=10;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_float(io, shadow->hi_bias);
- }
-
- if (shadow->map_size) { /*---- LIB3DS_SHADOW_MAP_SIZE ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_SHADOW_MAP_SIZE;
- c.size=8;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_intw(io, shadow->map_size);
- }
-
- if (shadow->samples) { /*---- LIB3DS_SHADOW_SAMPLES ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_SHADOW_SAMPLES;
- c.size=8;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_intw(io, shadow->samples);
- }
-
- if (shadow->range) { /*---- LIB3DS_SHADOW_RANGE ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_SHADOW_RANGE;
- c.size=10;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_intd(io, shadow->range);
- }
-
- if (fabs(shadow->filter)>LIB3DS_EPSILON) { /*---- LIB3DS_SHADOW_FILTER ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_SHADOW_FILTER;
- c.size=10;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_float(io, shadow->filter);
- }
- if (fabs(shadow->ray_bias)>LIB3DS_EPSILON) { /*---- LIB3DS_RAY_BIAS ----*/
- Lib3dsChunk c;
- c.chunk=LIB3DS_RAY_BIAS;
- c.size=10;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_float(io, shadow->ray_bias);
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
-
-\typedef Lib3dsShadow
- \ingroup shadow
- \sa _Lib3dsShadow
-
-*/
+++ /dev/null
-/* -*- c -*- */
-#ifndef INCLUDED_LIB3DS_SHADOW_H
-#define INCLUDED_LIB3DS_SHADOW_H
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: shadow.h,v 1.9 2004/12/31 16:17:15 reed Exp $
- */
-
-#ifndef INCLUDED_LIB3DS_TYPES_H
-#include <lib3ds/types.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*!
- * Shadow map settings
- * \ingroup shadow
- */
-struct _Lib3dsShadow {
- Lib3dsIntw map_size;
- Lib3dsFloat lo_bias;
- Lib3dsFloat hi_bias;
- Lib3dsIntw samples;
- Lib3dsIntd range;
- Lib3dsFloat filter;
- Lib3dsFloat ray_bias;
-};
-
-extern LIB3DSAPI Lib3dsBool lib3ds_shadow_read(Lib3dsShadow *shadow, Lib3dsIo *io);
-extern LIB3DSAPI Lib3dsBool lib3ds_shadow_write(Lib3dsShadow *shadow, Lib3dsIo *io);
-
-#ifdef __cplusplus
-}
-#endif
-#endif
-
-
-
-
-
+++ /dev/null
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: tcb.c,v 1.9 2001/07/07 19:05:30 jeh Exp $
- */
-#define LIB3DS_EXPORT
-#include <lib3ds/tcb.h>
-#include <lib3ds/io.h>
-#include <math.h>
-
-
-/*!
- * \defgroup tcb Tension/Continuity/Bias Splines
- *
- * \author J.E. Hoffmann <je-h@gmx.net>
- */
-
-
-/*!
- * \ingroup tcb
- */
-void
-lib3ds_tcb(Lib3dsTcb *p, Lib3dsTcb *pc, Lib3dsTcb *c, Lib3dsTcb *nc, Lib3dsTcb *n,
- Lib3dsFloat *ksm, Lib3dsFloat *ksp, Lib3dsFloat *kdm, Lib3dsFloat *kdp)
-{
- Lib3dsFloat tm,cm,cp,bm,bp,tmcm,tmcp,cc;
- Lib3dsFloat dt,fp,fn;
-
- if (!pc) {
- pc=c;
- }
- if (!nc) {
- nc=c;
- }
-
- fp=fn=1.0f;
- if (p&&n) {
- dt=0.5f*(Lib3dsFloat)(pc->frame-p->frame+n->frame-nc->frame);
- fp=((Lib3dsFloat)(pc->frame-p->frame))/dt;
- fn=((Lib3dsFloat)(n->frame-nc->frame))/dt;
- cc=(Lib3dsFloat)fabs(c->cont);
- fp=fp+cc-cc*fp;
- fn=fn+cc-cc*fn;
- }
-
- cm=1.0f-c->cont;
- tm=0.5f*(1.0f-c->tens);
- cp=2.0f-cm;
- bm=1.0f-c->bias;
- bp=2.0f-bm;
- tmcm=tm*cm;
- tmcp=tm*cp;
- *ksm=tmcm*bp*fp;
- *ksp=tmcp*bm*fp;
- *kdm=tmcp*bp*fn;
- *kdp=tmcm*bm*fn;
-}
-
-
-/*!
- * \ingroup tcb
- */
-Lib3dsBool
-lib3ds_tcb_read(Lib3dsTcb *tcb, Lib3dsIo *io)
-{
- Lib3dsWord flags;
-
- tcb->frame=lib3ds_io_read_intd(io);
- tcb->flags=flags=lib3ds_io_read_word(io);
- if (flags&LIB3DS_USE_TENSION) {
- tcb->tens=lib3ds_io_read_float(io);
- }
- if (flags&LIB3DS_USE_CONTINUITY) {
- tcb->cont=lib3ds_io_read_float(io);
- }
- if (flags&LIB3DS_USE_BIAS) {
- tcb->bias=lib3ds_io_read_float(io);
- }
- if (flags&LIB3DS_USE_EASE_TO) {
- tcb->ease_to=lib3ds_io_read_float(io);
- }
- if (flags&LIB3DS_USE_EASE_FROM) {
- tcb->ease_from=lib3ds_io_read_float(io);
- }
- if (lib3ds_io_error(io)) {
- return(LIB3DS_FALSE);
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup tcb
- */
-Lib3dsBool
-lib3ds_tcb_write(Lib3dsTcb *tcb, Lib3dsIo *io)
-{
- lib3ds_io_write_intd(io, tcb->frame);
- lib3ds_io_write_word(io, tcb->flags);
- if (tcb->flags&LIB3DS_USE_TENSION) {
- lib3ds_io_write_float(io, tcb->tens);
- }
- if (tcb->flags&LIB3DS_USE_CONTINUITY) {
- lib3ds_io_write_float(io, tcb->cont);
- }
- if (tcb->flags&LIB3DS_USE_BIAS) {
- lib3ds_io_write_float(io, tcb->bias);
- }
- if (tcb->flags&LIB3DS_USE_EASE_TO) {
- lib3ds_io_write_float(io, tcb->ease_to);
- }
- if (tcb->flags&LIB3DS_USE_EASE_FROM) {
- lib3ds_io_write_float(io, tcb->ease_from);
- }
- if (lib3ds_io_error(io)) {
- return(LIB3DS_FALSE);
- }
- return(LIB3DS_TRUE);
-}
-
-
-
-
+++ /dev/null
-/* -*- c -*- */
-#ifndef INCLUDED_LIB3DS_TCB_H
-#define INCLUDED_LIB3DS_TCB_H
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: tcb.h,v 1.9 2004/12/31 16:17:15 reed Exp $
- */
-
-#ifndef INCLUDED_LIB3DS_TYPES_H
-#include <lib3ds/types.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef enum _Lib3dsTcbFlags{
- LIB3DS_USE_TENSION =0x0001,
- LIB3DS_USE_CONTINUITY =0x0002,
- LIB3DS_USE_BIAS =0x0004,
- LIB3DS_USE_EASE_TO =0x0008,
- LIB3DS_USE_EASE_FROM =0x0010
-} Lib3dsTcbFlags;
-
-typedef struct _Lib3dsTcb {
- Lib3dsIntd frame;
- Lib3dsWord flags;
- Lib3dsFloat tens;
- Lib3dsFloat cont;
- Lib3dsFloat bias;
- Lib3dsFloat ease_to;
- Lib3dsFloat ease_from;
-} Lib3dsTcb;
-
-extern LIB3DSAPI void lib3ds_tcb(Lib3dsTcb *p, Lib3dsTcb *pc, Lib3dsTcb *c,
- Lib3dsTcb *nc, Lib3dsTcb *n, Lib3dsFloat *ksm, Lib3dsFloat *ksp,
- Lib3dsFloat *kdm, Lib3dsFloat *kdp);
-extern LIB3DSAPI Lib3dsBool lib3ds_tcb_read(Lib3dsTcb *tcb, Lib3dsIo *io);
-extern LIB3DSAPI Lib3dsBool lib3ds_tcb_write(Lib3dsTcb *tcb, Lib3dsIo *io);
-
-#ifdef __cplusplus
-}
-#endif
-#endif
-
+++ /dev/null
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: tracks.c,v 1.14 2004/11/20 09:00:38 efalk Exp $
- */
-#define LIB3DS_EXPORT
-#include <lib3ds/tracks.h>
-#include <lib3ds/io.h>
-#include <lib3ds/chunk.h>
-#include <lib3ds/float.h>
-#include <lib3ds/vector.h>
-#include <lib3ds/quat.h>
-#include <lib3ds/node.h>
-#include <stdlib.h>
-#include <string.h>
-#include <math.h>
-#ifdef WITH_DMALLOC
-#include <dmalloc.h>
-#endif
-
-
-/*!
- * \defgroup tracks Keyframing Tracks
- *
- * \author J.E. Hoffmann <je-h@gmx.net>
- */
-
-
-/*!
- * \ingroup tracks
- */
-Lib3dsBoolKey*
-lib3ds_bool_key_new()
-{
- Lib3dsBoolKey* k;
- k=(Lib3dsBoolKey*)calloc(sizeof(Lib3dsBoolKey), 1);
- return(k);
-}
-
-
-/*!
- * \ingroup tracks
- */
-void
-lib3ds_bool_key_free(Lib3dsBoolKey *key)
-{
- ASSERT(key);
- free(key);
-}
-
-
-/*!
- * \ingroup tracks
- */
-void
-lib3ds_bool_track_free_keys(Lib3dsBoolTrack *track)
-{
- Lib3dsBoolKey *p,*q;
-
- ASSERT(track);
- for (p=track->keyL; p; p=q) {
- q=p->next;
- lib3ds_bool_key_free(p);
- }
-}
-
-
-/*!
- * \ingroup tracks
- */
-void
-lib3ds_bool_track_insert(Lib3dsBoolTrack *track, Lib3dsBoolKey *key)
-{
- ASSERT(track);
- ASSERT(key);
- ASSERT(!key->next);
-
- if (!track->keyL) {
- track->keyL=key;
- key->next=0;
- }
- else {
- Lib3dsBoolKey *k,*p;
-
- for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
- if (k->tcb.frame>key->tcb.frame) {
- break;
- }
- }
- if (!p) {
- key->next=track->keyL;
- track->keyL=key;
- }
- else {
- key->next=k;
- p->next=key;
- }
-
- if (k && (key->tcb.frame==k->tcb.frame)) {
- key->next=k->next;
- lib3ds_bool_key_free(k);
- }
- }
-}
-
-
-/*!
- * \ingroup tracks
- */
-void
-lib3ds_bool_track_remove(Lib3dsBoolTrack *track, Lib3dsIntd frame)
-{
- Lib3dsBoolKey *k,*p;
-
- ASSERT(track);
- if (!track->keyL) {
- return;
- }
- for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
- if (k->tcb.frame==frame) {
- if (!p) {
- track->keyL=track->keyL->next;
- }
- else {
- p->next=k->next;
- }
- lib3ds_bool_key_free(k);
- break;
- }
- }
-}
-
-
-/*!
- * \ingroup tracks
- */
-void
-lib3ds_bool_track_eval(Lib3dsBoolTrack *track, Lib3dsBool *p, Lib3dsFloat t)
-{
- Lib3dsBoolKey *k;
- Lib3dsBool result;
-
- ASSERT(p);
- if (!track->keyL) {
- *p=LIB3DS_FALSE;
- return;
- }
- if (!track->keyL->next) {
- *p = LIB3DS_TRUE;
- return;
- }
-
- result=LIB3DS_FALSE;
- k=track->keyL;
- while ((t<(Lib3dsFloat)k->tcb.frame) && (t>=(Lib3dsFloat)k->next->tcb.frame)) {
- if (result) {
- result=LIB3DS_FALSE;
- }
- else {
- result=LIB3DS_TRUE;
- }
- if (!k->next) {
- if (track->flags&LIB3DS_REPEAT) {
- t-=(Lib3dsFloat)k->tcb.frame;
- k=track->keyL;
- }
- else {
- break;
- }
- }
- else {
- k=k->next;
- }
- }
- *p=result;
-}
-
-
-/*!
- * \ingroup tracks
- */
-Lib3dsBool
-lib3ds_bool_track_read(Lib3dsBoolTrack *track, Lib3dsIo *io)
-{
- int keys;
- int i;
- Lib3dsBoolKey *k;
-
- track->flags=lib3ds_io_read_word(io);
- lib3ds_io_read_dword(io);
- lib3ds_io_read_dword(io);
- keys=lib3ds_io_read_intd(io);
-
- for (i=0; i<keys; ++i) {
- k=lib3ds_bool_key_new();
- if (!lib3ds_tcb_read(&k->tcb, io)) {
- return(LIB3DS_FALSE);
- }
- lib3ds_bool_track_insert(track, k);
- }
-
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup tracks
- */
-Lib3dsBool
-lib3ds_bool_track_write(Lib3dsBoolTrack *track, Lib3dsIo *io)
-{
- Lib3dsBoolKey *k;
- Lib3dsDword num=0;
- for (k=track->keyL; k; k=k->next) {
- ++num;
- }
- lib3ds_io_write_word(io, (Lib3dsWord)track->flags);
- lib3ds_io_write_dword(io, 0);
- lib3ds_io_write_dword(io, 0);
- lib3ds_io_write_dword(io, num);
-
- for (k=track->keyL; k; k=k->next) {
- if (!lib3ds_tcb_write(&k->tcb,io)) {
- return(LIB3DS_FALSE);
- }
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup tracks
- */
-Lib3dsLin1Key*
-lib3ds_lin1_key_new()
-{
- Lib3dsLin1Key* k;
- k=(Lib3dsLin1Key*)calloc(sizeof(Lib3dsLin1Key), 1);
- return(k);
-}
-
-
-/*!
- * \ingroup tracks
- */
-void
-lib3ds_lin1_key_free(Lib3dsLin1Key *key)
-{
- ASSERT(key);
- free(key);
-}
-
-
-/*!
- * \ingroup tracks
- */
-void
-lib3ds_lin1_track_free_keys(Lib3dsLin1Track *track)
-{
- Lib3dsLin1Key *p,*q;
-
- ASSERT(track);
- for (p=track->keyL; p; p=q) {
- q=p->next;
- lib3ds_lin1_key_free(p);
- }
-}
-
-
-/*!
- * \ingroup tracks
- */
-void
-lib3ds_lin1_key_setup(Lib3dsLin1Key *p, Lib3dsLin1Key *cp, Lib3dsLin1Key *c,
- Lib3dsLin1Key *cn, Lib3dsLin1Key *n)
-{
- Lib3dsFloat np,nn;
- Lib3dsFloat ksm,ksp,kdm,kdp;
-
- ASSERT(c);
- if (!cp) {
- cp=c;
- }
- if (!cn) {
- cn=c;
- }
- if (!p && !n) {
- c->ds=0;
- c->dd=0;
- return;
- }
-
- if (n && p) {
- lib3ds_tcb(&p->tcb, &cp->tcb, &c->tcb, &cn->tcb, &n->tcb, &ksm, &ksp, &kdm, &kdp);
- np = c->value - p->value;
- nn = n->value - c->value;
-
- c->ds=ksm*np + ksp*nn;
- c->dd=kdm*np + kdp*nn;
- }
- else {
- if (p) {
- np = c->value - p->value;
- c->ds = np;
- c->dd = np;
- }
- if (n) {
- nn = n->value - c->value;
- c->ds = nn;
- c->dd = nn;
- }
- }
-}
-
-
-/*!
- * \ingroup tracks
- */
-void
-lib3ds_lin1_track_setup(Lib3dsLin1Track *track)
-{
- Lib3dsLin1Key *pp,*pc,*pn,*pl;
-
- ASSERT(track);
- pc=track->keyL;
- if (!pc) {
- return;
- }
- if (!pc->next) {
- pc->ds=0;
- pc->dd=0;
- return;
- }
-
- if (track->flags&LIB3DS_SMOOTH) {
- for (pl=track->keyL; pl->next->next; pl=pl->next);
- lib3ds_lin1_key_setup(pl, pl->next, pc, 0, pc->next);
- }
- else {
- lib3ds_lin1_key_setup(0, 0, pc, 0, pc->next);
- }
- for (;;) {
- pp=pc;
- pc=pc->next;
- pn=pc->next;
- if (!pn) {
- break;
- }
- lib3ds_lin1_key_setup(pp, 0, pc, 0, pn);
- }
-
- if (track->flags&LIB3DS_SMOOTH) {
- lib3ds_lin1_key_setup(pp, 0, pc, track->keyL, track->keyL->next);
- }
- else {
- lib3ds_lin1_key_setup(pp, 0, pc, 0, 0);
- }
-}
-
-
-/*!
- * \ingroup tracks
- */
-void
-lib3ds_lin1_track_insert(Lib3dsLin1Track *track, Lib3dsLin1Key *key)
-{
- ASSERT(track);
- ASSERT(key);
- ASSERT(!key->next);
-
- if (!track->keyL) {
- track->keyL=key;
- key->next=0;
- }
- else {
- Lib3dsLin1Key *k,*p;
-
- for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
- if (k->tcb.frame>key->tcb.frame) {
- break;
- }
- }
- if (!p) {
- key->next=track->keyL;
- track->keyL=key;
- }
- else {
- key->next=k;
- p->next=key;
- }
-
- if (k && (key->tcb.frame==k->tcb.frame)) {
- key->next=k->next;
- lib3ds_lin1_key_free(k);
- }
- }
-}
-
-
-/*!
- * \ingroup tracks
- */
-void
-lib3ds_lin1_track_remove(Lib3dsLin1Track *track, Lib3dsIntd frame)
-{
- Lib3dsLin1Key *k,*p;
-
- ASSERT(track);
- if (!track->keyL) {
- return;
- }
- for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
- if (k->tcb.frame==frame) {
- if (!p) {
- track->keyL=track->keyL->next;
- }
- else {
- p->next=k->next;
- }
- lib3ds_lin1_key_free(k);
- break;
- }
- }
-}
-
-
-/*!
- * \ingroup tracks
- */
-void
-lib3ds_lin1_track_eval(Lib3dsLin1Track *track, Lib3dsFloat *p, Lib3dsFloat t)
-{
- Lib3dsLin1Key *k;
- Lib3dsFloat nt;
- Lib3dsFloat u;
-
- ASSERT(p);
- if (!track->keyL) {
- *p=0;
- return;
- }
- if (!track->keyL->next) {
- *p = track->keyL->value;
- return;
- }
-
- for (k=track->keyL; k->next!=0; k=k->next) {
- if ((t>=(Lib3dsFloat)k->tcb.frame) && (t<(Lib3dsFloat)k->next->tcb.frame)) {
- break;
- }
- }
- if (!k->next) {
- if (track->flags&LIB3DS_REPEAT) {
- nt=(Lib3dsFloat)fmod(t, k->tcb.frame);
- for (k=track->keyL; k->next!=0; k=k->next) {
- if ((nt>=(Lib3dsFloat)k->tcb.frame) && (nt<(Lib3dsFloat)k->next->tcb.frame)) {
- break;
- }
- }
- ASSERT(k->next);
- }
- else {
- *p = k->value;
- return;
- }
- }
- else {
- nt=t;
- }
- u=nt - (Lib3dsFloat)k->tcb.frame;
- u/=(Lib3dsFloat)(k->next->tcb.frame - k->tcb.frame);
-
- *p = lib3ds_float_cubic(
- k->value,
- k->dd,
- k->next->ds,
- k->next->value,
- u
- );
-}
-
-
-/*!
- * \ingroup tracks
- */
-Lib3dsBool
-lib3ds_lin1_track_read(Lib3dsLin1Track *track, Lib3dsIo *io)
-{
- int keys;
- int i;
- Lib3dsLin1Key *k;
-
- track->flags=lib3ds_io_read_word(io);
- lib3ds_io_read_dword(io);
- lib3ds_io_read_dword(io);
- keys=lib3ds_io_read_intd(io);
-
- for (i=0; i<keys; ++i) {
- k=lib3ds_lin1_key_new();
- if (!lib3ds_tcb_read(&k->tcb, io)) {
- return(LIB3DS_FALSE);
- }
- k->value=lib3ds_io_read_float(io);
- lib3ds_lin1_track_insert(track, k);
- }
- lib3ds_lin1_track_setup(track);
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup tracks
- */
-Lib3dsBool
-lib3ds_lin1_track_write(Lib3dsLin1Track *track, Lib3dsIo *io)
-{
- Lib3dsLin1Key *k;
- Lib3dsDword num=0;
- for (k=track->keyL; k; k=k->next) {
- ++num;
- }
- lib3ds_io_write_word(io, (Lib3dsWord)track->flags);
- lib3ds_io_write_dword(io, 0);
- lib3ds_io_write_dword(io, 0);
- lib3ds_io_write_dword(io, num);
-
- for (k=track->keyL; k; k=k->next) {
- if (!lib3ds_tcb_write(&k->tcb,io)) {
- return(LIB3DS_FALSE);
- }
- lib3ds_io_write_float(io, k->value);
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * Create and return one keyframe in a Lin3 track. All values are
- * initialized to zero.
- *
- * \ingroup tracks
- */
-Lib3dsLin3Key*
-lib3ds_lin3_key_new()
-{
- Lib3dsLin3Key* k;
- k=(Lib3dsLin3Key*)calloc(sizeof(Lib3dsLin3Key), 1);
- return(k);
-}
-
-
-/*!
- * Free a Lin3 keyframe.
- *
- * \ingroup tracks
- */
-void
-lib3ds_lin3_key_free(Lib3dsLin3Key *key)
-{
- ASSERT(key);
- free(key);
-}
-
-
-/*!
- * Free all keyframes in a Lin3 track.
- *
- * \ingroup tracks
- */
-void
-lib3ds_lin3_track_free_keys(Lib3dsLin3Track *track)
-{
- Lib3dsLin3Key *p,*q;
-
- ASSERT(track);
- for (p=track->keyL; p; p=q) {
- q=p->next;
- lib3ds_lin3_key_free(p);
- }
-}
-
-
-/*!
- * \ingroup tracks
- */
-void
-lib3ds_lin3_key_setup(Lib3dsLin3Key *p, Lib3dsLin3Key *cp, Lib3dsLin3Key *c,
- Lib3dsLin3Key *cn, Lib3dsLin3Key *n)
-{
- Lib3dsVector np,nn;
- Lib3dsFloat ksm,ksp,kdm,kdp;
- int i;
-
- ASSERT(c);
- if (!cp) {
- cp=c;
- }
- if (!cn) {
- cn=c;
- }
- if (!p && !n) {
- lib3ds_vector_zero(c->ds);
- lib3ds_vector_zero(c->dd);
- return;
- }
-
- if (n && p) {
- lib3ds_tcb(&p->tcb, &cp->tcb, &c->tcb, &cn->tcb, &n->tcb, &ksm, &ksp, &kdm, &kdp);
- lib3ds_vector_sub(np, c->value, p->value);
- lib3ds_vector_sub(nn, n->value, c->value);
-
- for(i=0; i<3; ++i) {
- c->ds[i]=ksm*np[i] + ksp*nn[i];
- c->dd[i]=kdm*np[i] + kdp*nn[i];
- }
- }
- else {
- if (p) {
- lib3ds_vector_sub(np, c->value, p->value);
- lib3ds_vector_copy(c->ds, np);
- lib3ds_vector_copy(c->dd, np);
- }
- if (n) {
- lib3ds_vector_sub(nn, n->value, c->value);
- lib3ds_vector_copy(c->ds, nn);
- lib3ds_vector_copy(c->dd, nn);
- }
- }
-}
-
-
-/*!
- * \ingroup tracks
- */
-void
-lib3ds_lin3_track_setup(Lib3dsLin3Track *track)
-{
- Lib3dsLin3Key *pp,*pc,*pn,*pl;
-
- ASSERT(track);
- pc=track->keyL;
- if (!pc) {
- return;
- }
- if (!pc->next) {
- lib3ds_vector_zero(pc->ds);
- lib3ds_vector_zero(pc->dd);
- return;
- }
-
- if (track->flags&LIB3DS_SMOOTH) {
- for (pl=track->keyL; pl->next->next; pl=pl->next);
- lib3ds_lin3_key_setup(pl, pl->next, pc, 0, pc->next);
- }
- else {
- lib3ds_lin3_key_setup(0, 0, pc, 0, pc->next);
- }
- for (;;) {
- pp=pc;
- pc=pc->next;
- pn=pc->next;
- if (!pn) {
- break;
- }
- lib3ds_lin3_key_setup(pp, 0, pc, 0, pn);
- }
-
- if (track->flags&LIB3DS_SMOOTH) {
- lib3ds_lin3_key_setup(pp, 0, pc, track->keyL, track->keyL->next);
- }
- else {
- lib3ds_lin3_key_setup(pp, 0, pc, 0, 0);
- }
-}
-
-
-/*!
- * \ingroup tracks
- */
-void
-lib3ds_lin3_track_insert(Lib3dsLin3Track *track, Lib3dsLin3Key *key)
-{
- ASSERT(track);
- ASSERT(key);
- ASSERT(!key->next);
-
- if (!track->keyL) {
- track->keyL=key;
- key->next=0;
- }
- else {
- Lib3dsLin3Key *k,*p;
-
- for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
- if (k->tcb.frame>key->tcb.frame) {
- break;
- }
- }
- if (!p) {
- key->next=track->keyL;
- track->keyL=key;
- }
- else {
- key->next=k;
- p->next=key;
- }
-
- if (k && (key->tcb.frame==k->tcb.frame)) {
- key->next=k->next;
- lib3ds_lin3_key_free(k);
- }
- }
-}
-
-
-/*!
- * \ingroup tracks
- */
-void
-lib3ds_lin3_track_remove(Lib3dsLin3Track *track, Lib3dsIntd frame)
-{
- Lib3dsLin3Key *k,*p;
-
- ASSERT(track);
- if (!track->keyL) {
- return;
- }
- for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
- if (k->tcb.frame==frame) {
- if (!p) {
- track->keyL=track->keyL->next;
- }
- else {
- p->next=k->next;
- }
- lib3ds_lin3_key_free(k);
- break;
- }
- }
-}
-
-
-/*!
- * \ingroup tracks
- */
-void
-lib3ds_lin3_track_eval(Lib3dsLin3Track *track, Lib3dsVector p, Lib3dsFloat t)
-{
- Lib3dsLin3Key *k;
- Lib3dsFloat nt;
- Lib3dsFloat u;
-
- if (!track->keyL) {
- lib3ds_vector_zero(p);
- return;
- }
- if (!track->keyL->next) {
- lib3ds_vector_copy(p, track->keyL->value);
- return;
- }
-
- for (k=track->keyL; k->next!=0; k=k->next) {
- if ((t>=(Lib3dsFloat)k->tcb.frame) && (t<(Lib3dsFloat)k->next->tcb.frame)) {
- break;
- }
- }
- if (!k->next) {
- if (track->flags&LIB3DS_REPEAT) {
- nt=(Lib3dsFloat)fmod(t, k->tcb.frame);
- for (k=track->keyL; k->next!=0; k=k->next) {
- if ((nt>=(Lib3dsFloat)k->tcb.frame) && (nt<(Lib3dsFloat)k->next->tcb.frame)) {
- break;
- }
- }
- ASSERT(k->next);
- }
- else {
- lib3ds_vector_copy(p, k->value);
- return;
- }
- }
- else {
- nt=t;
- }
- u=nt - (Lib3dsFloat)k->tcb.frame;
- u/=(Lib3dsFloat)(k->next->tcb.frame - k->tcb.frame);
-
- lib3ds_vector_cubic(
- p,
- k->value,
- k->dd,
- k->next->ds,
- k->next->value,
- u
- );
-}
-
-
-/*!
- * \ingroup tracks
- */
-Lib3dsBool
-lib3ds_lin3_track_read(Lib3dsLin3Track *track, Lib3dsIo *io)
-{
- int keys;
- int i,j;
- Lib3dsLin3Key *k;
-
- track->flags=lib3ds_io_read_word(io);
- lib3ds_io_read_dword(io);
- lib3ds_io_read_dword(io);
- keys=lib3ds_io_read_intd(io);
-
- for (i=0; i<keys; ++i) {
- k=lib3ds_lin3_key_new();
- if (!lib3ds_tcb_read(&k->tcb, io)) {
- return(LIB3DS_FALSE);
- }
- for (j=0; j<3; ++j) {
- k->value[j]=lib3ds_io_read_float(io);
- }
- lib3ds_lin3_track_insert(track, k);
- }
- lib3ds_lin3_track_setup(track);
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup tracks
- */
-Lib3dsBool
-lib3ds_lin3_track_write(Lib3dsLin3Track *track, Lib3dsIo *io)
-{
- Lib3dsLin3Key *k;
- Lib3dsDword num=0;
- for (k=track->keyL; k; k=k->next) {
- ++num;
- }
- lib3ds_io_write_word(io, (Lib3dsWord)track->flags);
- lib3ds_io_write_dword(io, 0);
- lib3ds_io_write_dword(io, 0);
- lib3ds_io_write_dword(io, num);
-
- for (k=track->keyL; k; k=k->next) {
- if (!lib3ds_tcb_write(&k->tcb,io)) {
- return(LIB3DS_FALSE);
- }
- lib3ds_io_write_vector(io, k->value);
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup tracks
- */
-Lib3dsQuatKey*
-lib3ds_quat_key_new()
-{
- Lib3dsQuatKey* k;
- k=(Lib3dsQuatKey*)calloc(sizeof(Lib3dsQuatKey), 1);
- return(k);
-}
-
-
-/*!
- * \ingroup tracks
- */
-void
-lib3ds_quat_key_free(Lib3dsQuatKey *key)
-{
- ASSERT(key);
- free(key);
-}
-
-
-/*!
- * \ingroup tracks
- */
-void
-lib3ds_quat_track_free_keys(Lib3dsQuatTrack *track)
-{
- Lib3dsQuatKey *p,*q;
-
- ASSERT(track);
- for (p=track->keyL; p; p=q) {
- q=p->next;
- lib3ds_quat_key_free(p);
- }
-}
-
-
-/*!
- * \ingroup tracks
- */
-void
-lib3ds_quat_key_setup(Lib3dsQuatKey *p, Lib3dsQuatKey *cp, Lib3dsQuatKey *c,
- Lib3dsQuatKey *cn, Lib3dsQuatKey *n)
-{
- Lib3dsFloat ksm,ksp,kdm,kdp;
- Lib3dsQuat q,qp,qn,qa,qb;
- int i;
-
- ASSERT(c);
- if (!cp) {
- cp=c;
- }
- if (!cn) {
- cn=c;
- }
- if (!p || !n) {
- lib3ds_quat_copy(c->ds, c->q);
- lib3ds_quat_copy(c->dd, c->q);
- return;
- }
-
- if (p) {
- if (p->angle>LIB3DS_TWOPI-LIB3DS_EPSILON) {
- lib3ds_quat_axis_angle(qp, p->axis, 0.0f);
- lib3ds_quat_ln(qp);
- }
- else {
- lib3ds_quat_copy(q, p->q);
- if (lib3ds_quat_dot(q,c->q)<0) lib3ds_quat_neg(q);
- lib3ds_quat_ln_dif(qp, c->q, q);
- }
- }
- if (n) {
- if (n->angle>LIB3DS_TWOPI-LIB3DS_EPSILON) {
- lib3ds_quat_axis_angle(qn, n->axis, 0.0f);
- lib3ds_quat_ln(qn);
- }
- else {
- lib3ds_quat_copy(q, n->q);
- if (lib3ds_quat_dot(q,c->q)<0) lib3ds_quat_neg(q);
- lib3ds_quat_ln_dif(qn, c->q, q);
- }
- }
-
- if (n && p) {
- lib3ds_tcb(&p->tcb, &cp->tcb, &c->tcb, &cn->tcb, &n->tcb, &ksm, &ksp, &kdm, &kdp);
- for(i=0; i<4; i++) {
- qa[i]=-0.5f*(kdm*qn[i]+kdp*qp[i]);
- qb[i]=-0.5f*(ksm*qn[i]+ksp*qp[i]);
- }
- lib3ds_quat_exp(qa);
- lib3ds_quat_exp(qb);
-
- lib3ds_quat_mul(c->ds, c->q, qa);
- lib3ds_quat_mul(c->dd, c->q, qb);
- }
- else {
- if (p) {
- lib3ds_quat_exp(qp);
- lib3ds_quat_mul(c->ds, c->q, qp);
- lib3ds_quat_mul(c->dd, c->q, qp);
- }
- if (n) {
- lib3ds_quat_exp(qn);
- lib3ds_quat_mul(c->ds, c->q, qn);
- lib3ds_quat_mul(c->dd, c->q, qn);
- }
- }
-}
-
-
-/*!
- * \ingroup tracks
- */
-void
-lib3ds_quat_track_setup(Lib3dsQuatTrack *track)
-{
- Lib3dsQuatKey *pp,*pc,*pn,*pl;
- Lib3dsQuat q;
-
- ASSERT(track);
- for (pp=0,pc=track->keyL; pc; pp=pc,pc=pc->next) {
- lib3ds_quat_axis_angle(q, pc->axis, pc->angle);
- if (pp) {
- lib3ds_quat_mul(pc->q, q, pp->q);
- }
- else {
- lib3ds_quat_copy(pc->q, q);
- }
- }
-
- pc=track->keyL;
- if (!pc) {
- return;
- }
- if (!pc->next) {
- lib3ds_quat_copy(pc->ds, pc->q);
- lib3ds_quat_copy(pc->dd, pc->q);
- return;
- }
-
- if (track->flags&LIB3DS_SMOOTH) {
- for (pl=track->keyL; pl->next->next; pl=pl->next);
- lib3ds_quat_key_setup(pl, pl->next, pc, 0, pc->next);
- }
- else {
- lib3ds_quat_key_setup(0, 0, pc, 0, pc->next);
- }
- for (;;) {
- pp=pc;
- pc=pc->next;
- pn=pc->next;
- if (!pn) {
- break;
- }
- lib3ds_quat_key_setup(pp, 0, pc, 0, pn);
- }
-
- if (track->flags&LIB3DS_SMOOTH) {
- lib3ds_quat_key_setup(pp, 0, pc, track->keyL, track->keyL->next);
- }
- else {
- lib3ds_quat_key_setup(pp, 0, pc, 0, 0);
- }
-}
-
-
-/*!
- * \ingroup tracks
- */
-void
-lib3ds_quat_track_insert(Lib3dsQuatTrack *track, Lib3dsQuatKey *key)
-{
- ASSERT(track);
- ASSERT(key);
- ASSERT(!key->next);
-
- if (!track->keyL) {
- track->keyL=key;
- key->next=0;
- }
- else {
- Lib3dsQuatKey *k,*p;
-
- for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
- if (k->tcb.frame>key->tcb.frame) {
- break;
- }
- }
- if (!p) {
- key->next=track->keyL;
- track->keyL=key;
- }
- else {
- key->next=k;
- p->next=key;
- }
-
- if (k && (key->tcb.frame==k->tcb.frame)) {
- key->next=k->next;
- lib3ds_quat_key_free(k);
- }
- }
-}
-
-
-/*!
- * \ingroup tracks
- */
-void
-lib3ds_quat_track_remove(Lib3dsQuatTrack *track, Lib3dsIntd frame)
-{
- Lib3dsQuatKey *k,*p;
-
- ASSERT(track);
- if (!track->keyL) {
- return;
- }
- for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
- if (k->tcb.frame==frame) {
- if (!p) {
- track->keyL=track->keyL->next;
- }
- else {
- p->next=k->next;
- }
- lib3ds_quat_key_free(k);
- break;
- }
- }
-}
-
-
-/*!
- * \ingroup tracks
- */
-void
-lib3ds_quat_track_eval(Lib3dsQuatTrack *track, Lib3dsQuat q, Lib3dsFloat t)
-{
- Lib3dsQuatKey *k;
- Lib3dsFloat nt;
- Lib3dsFloat u;
-
- if (!track->keyL) {
- lib3ds_quat_identity(q);
- return;
- }
- if (!track->keyL->next) {
- lib3ds_quat_copy(q, track->keyL->q);
- return;
- }
-
- for (k=track->keyL; k->next!=0; k=k->next) {
- if ((t>=k->tcb.frame) && (t<k->next->tcb.frame)) {
- break;
- }
- }
- if (!k->next) {
- if (track->flags&LIB3DS_REPEAT) {
- nt=(Lib3dsFloat)fmod(t, k->tcb.frame);
- for (k=track->keyL; k->next!=0; k=k->next) {
- if ((nt>=k->tcb.frame) && (nt<k->next->tcb.frame)) {
- break;
- }
- }
- ASSERT(k->next);
- }
- else {
- lib3ds_quat_copy(q, k->q);
- return;
- }
- }
- else {
- nt=t;
- }
- u=nt - k->tcb.frame;
- u/=(k->next->tcb.frame - k->tcb.frame);
-
- lib3ds_quat_squad(
- q,
- k->q,
- k->dd,
- k->next->ds,
- k->next->q,
- u
- );
-}
-
-
-/*!
- * \ingroup tracks
- */
-Lib3dsBool
-lib3ds_quat_track_read(Lib3dsQuatTrack *track, Lib3dsIo *io)
-{
- int keys;
- int i,j;
- Lib3dsQuatKey *p,*k;
-
- track->flags=lib3ds_io_read_word(io);
- lib3ds_io_read_dword(io);
- lib3ds_io_read_dword(io);
- keys=lib3ds_io_read_intd(io);
-
- for (p=0,i=0; i<keys; p=k,++i) {
- k=lib3ds_quat_key_new();
- if (!lib3ds_tcb_read(&k->tcb, io)) {
- return(LIB3DS_FALSE);
- }
- k->angle=lib3ds_io_read_float(io);
- for (j=0; j<3; ++j) {
- k->axis[j]=lib3ds_io_read_float(io);
- }
- lib3ds_quat_track_insert(track, k);
- }
- lib3ds_quat_track_setup(track);
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup tracks
- */
-Lib3dsBool
-lib3ds_quat_track_write(Lib3dsQuatTrack *track, Lib3dsIo *io)
-{
- Lib3dsQuatKey *k;
- Lib3dsDword num=0;
- for (k=track->keyL; k; k=k->next) {
- ++num;
- }
- lib3ds_io_write_word(io, (Lib3dsWord)track->flags);
- lib3ds_io_write_dword(io, 0);
- lib3ds_io_write_dword(io, 0);
- lib3ds_io_write_dword(io, num);
-
- for (k=track->keyL; k; k=k->next) {
- if (!lib3ds_tcb_write(&k->tcb,io)) {
- return(LIB3DS_FALSE);
- }
- lib3ds_io_write_float(io, k->angle);
- lib3ds_io_write_vector(io, k->axis);
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup tracks
- */
-Lib3dsMorphKey*
-lib3ds_morph_key_new()
-{
- Lib3dsMorphKey* k;
- k=(Lib3dsMorphKey*)calloc(sizeof(Lib3dsMorphKey), 1);
- return(k);
-}
-
-
-/*!
- * \ingroup tracks
- */
-void
-lib3ds_morph_key_free(Lib3dsMorphKey *key)
-{
- ASSERT(key);
- free(key);
-}
-
-
-/*!
- * \ingroup tracks
- */
-void
-lib3ds_morph_track_free_keys(Lib3dsMorphTrack *track)
-{
- Lib3dsMorphKey *p,*q;
-
- ASSERT(track);
- for (p=track->keyL; p; p=q) {
- q=p->next;
- lib3ds_morph_key_free(p);
- }
-}
-
-
-/*!
- * \ingroup tracks
- */
-void
-lib3ds_morph_track_insert(Lib3dsMorphTrack *track, Lib3dsMorphKey *key)
-{
- ASSERT(track);
- ASSERT(key);
- ASSERT(!key->next);
-
- if (!track->keyL) {
- track->keyL=key;
- key->next=0;
- }
- else {
- Lib3dsMorphKey *k,*p;
-
- for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
- if (k->tcb.frame>key->tcb.frame) {
- break;
- }
- }
- if (!p) {
- key->next=track->keyL;
- track->keyL=key;
- }
- else {
- key->next=k;
- p->next=key;
- }
-
- if (k && (key->tcb.frame==k->tcb.frame)) {
- key->next=k->next;
- lib3ds_morph_key_free(k);
- }
- }
-}
-
-
-/*!
- * \ingroup tracks
- */
-void
-lib3ds_morph_track_remove(Lib3dsMorphTrack *track, Lib3dsIntd frame)
-{
- Lib3dsMorphKey *k,*p;
-
- ASSERT(track);
- if (!track->keyL) {
- return;
- }
- for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
- if (k->tcb.frame==frame) {
- if (!p) {
- track->keyL=track->keyL->next;
- }
- else {
- p->next=k->next;
- }
- lib3ds_morph_key_free(k);
- break;
- }
- }
-}
-
-
-/*!
- * \ingroup tracks
- */
-void
-lib3ds_morph_track_eval(Lib3dsMorphTrack *track, char *p, Lib3dsFloat t)
-{
- Lib3dsMorphKey *k;
- char* result;
-
- ASSERT(p);
- if (!track->keyL) {
- strcpy(p,"");
- return;
- }
- if (!track->keyL->next) {
- strcpy(p,track->keyL->name);
- return;
- }
-
-
- /* TODO: this function finds the mesh frame that corresponds to this
- * timeframe. It would be better to actually interpolate the mesh.
- */
-
- result=0;
-
- for(k = track->keyL;
- k->next != NULL && t >= k->next->tcb.frame;
- k = k->next);
-
- result=k->name;
-
- if (result) {
- strcpy(p,result);
- }
- else {
- strcpy(p,"");
- }
-}
-
-
-/*!
- * \ingroup tracks
- */
-Lib3dsBool
-lib3ds_morph_track_read(Lib3dsMorphTrack *track, Lib3dsIo *io)
-{
- /* This function was written by Stephane Denis on 5-18-04 */
- int i;
- Lib3dsMorphKey *k, *pk = 0;
- int keys;
- track->flags=lib3ds_io_read_word(io);
- lib3ds_io_read_dword(io);
- lib3ds_io_read_dword(io);
- keys=lib3ds_io_read_intd(io);
-
- for (i=0; i<keys; ++i) {
- k=lib3ds_morph_key_new();
- if (!lib3ds_tcb_read(&k->tcb, io)) {
- return(LIB3DS_FALSE);
- }
- if (!lib3ds_io_read_string(io, k->name, 11)) {
- return(LIB3DS_FALSE);
- }
- if (!track->keyL)
- track->keyL = k;
- else
- pk->next = k;
- pk = k;
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup tracks
- */
-Lib3dsBool
-lib3ds_morph_track_write(Lib3dsMorphTrack *track, Lib3dsIo *io)
-{
- /* FIXME: */
- ASSERT(0);
- return(LIB3DS_FALSE);
-}
-
-
-
-void
-tcb_dump(Lib3dsTcb *tcb)
-{
- printf(" tcb: frame=%d, flags=%04x, tens=%g, cont=%g, ",
- (int)tcb->frame, tcb->flags, tcb->tens, tcb->cont);
- printf("bias=%g, ease_to=%g, ease_from=%g\n",
- tcb->bias, tcb->ease_to, tcb->ease_from);
-}
-
-
-void
-lib3ds_boolTrack_dump(Lib3dsBoolTrack *track)
-{
- Lib3dsBoolKey *key;
- printf("flags: %08x, keys:\n", (unsigned int)track->flags);
- for( key = track->keyL; key != NULL; key = key->next)
- {
- tcb_dump(&key->tcb);
- }
-}
-
-
-void
-lib3ds_lin1Track_dump(Lib3dsLin1Track *track)
-{
- Lib3dsLin1Key *key;
- printf("flags: %08x, keys:\n", (unsigned int)track->flags);
- for( key = track->keyL; key != NULL; key = key->next)
- {
- tcb_dump(&key->tcb);
- printf(" value = %g, dd=%g, ds=%g\n",
- key->value, key->dd, key->ds);
- }
-}
-
-
-void
-lib3ds_lin3Track_dump(Lib3dsLin3Track *track)
-{
- Lib3dsLin3Key *key;
- printf("flags: %08x, keys:\n", (unsigned int)track->flags);
- for( key = track->keyL; key != NULL; key = key->next)
- {
- tcb_dump(&key->tcb);
- printf(" value = %g,%g,%g, dd=%g,%g,%g, ds=%g,%g,%g\n",
- key->value[0], key->value[1], key->value[2],
- key->dd[0], key->dd[1], key->dd[2],
- key->ds[0], key->ds[1], key->ds[2]);
- }
-}
-
-
-void
-lib3ds_quatTrack_dump(Lib3dsQuatTrack *track)
-{
- Lib3dsQuatKey *key;
- printf("flags: %08x, keys:\n", (unsigned int)track->flags);
- for( key = track->keyL; key != NULL; key = key->next)
- {
- tcb_dump(&key->tcb);
- printf(" axis = %g,%g,%g, angle=%g, q=%g,%g,%g,%g\n",
- key->axis[0], key->axis[1], key->axis[2], key->angle,
- key->q[0], key->q[1], key->q[2], key->q[3]);
- printf(" dd = %g,%g,%g,%g, ds=%g,%g,%g,%g\n",
- key->dd[0], key->dd[1], key->dd[2], key->dd[3],
- key->ds[0], key->ds[1], key->ds[2], key->ds[3]);
- }
-}
-
-
-void
-lib3ds_morphTrack_dump(Lib3dsMorphTrack *track)
-{
- Lib3dsMorphKey *key;
- printf("flags: %08x, keys:\n", (unsigned int)track->flags);
- for( key = track->keyL; key != NULL; key = key->next)
- {
- tcb_dump(&key->tcb);
- printf(" name = %s\n", key->name);
- }
-}
-
-
-
-void
-lib3ds_dump_tracks(Lib3dsNode *node)
-{
- switch( node->type ) {
- case LIB3DS_AMBIENT_NODE:
- printf("ambient: ");
- lib3ds_lin3Track_dump(&node->data.ambient.col_track);
- break;
- case LIB3DS_OBJECT_NODE:
- printf("pos: ");
- lib3ds_lin3Track_dump(&node->data.object.pos_track);
- printf("rot: ");
- lib3ds_quatTrack_dump(&node->data.object.rot_track);
- printf("scl: ");
- lib3ds_lin3Track_dump(&node->data.object.scl_track);
- printf("morph: ");
- lib3ds_morphTrack_dump(&node->data.object.morph_track);
- printf("hide: ");
- lib3ds_boolTrack_dump(&node->data.object.hide_track);
- break;
- case LIB3DS_CAMERA_NODE:
- printf("pos: ");
- lib3ds_lin3Track_dump(&node->data.camera.pos_track);
- printf("fov: ");
- lib3ds_lin1Track_dump(&node->data.camera.fov_track);
- printf("roll: ");
- lib3ds_lin1Track_dump(&node->data.camera.roll_track);
- break;
- case LIB3DS_TARGET_NODE:
- printf("pos: ");
- lib3ds_lin3Track_dump(&node->data.target.pos_track);
- break;
- case LIB3DS_LIGHT_NODE:
- printf("pos: ");
- lib3ds_lin3Track_dump(&node->data.light.pos_track);
- printf("col: ");
- lib3ds_lin3Track_dump(&node->data.light.col_track);
- printf("hotspot: ");
- lib3ds_lin1Track_dump(&node->data.light.hotspot_track);
- printf("falloff: ");
- lib3ds_lin1Track_dump(&node->data.light.falloff_track);
- printf("roll: ");
- lib3ds_lin1Track_dump(&node->data.light.roll_track);
- break;
- case LIB3DS_SPOT_NODE:
- printf("pos: ");
- lib3ds_lin3Track_dump(&node->data.spot.pos_track);
- break;
-
- default:
- break;
- }
-}
+++ /dev/null
-/* -*- c -*- */
-#ifndef INCLUDED_LIB3DS_TRACKS_H
-#define INCLUDED_LIB3DS_TRACKS_H
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: tracks.h,v 1.9 2004/12/31 16:17:15 reed Exp $
- */
-
-#ifndef INCLUDED_LIB3DS_TCB_H
-#include <lib3ds/tcb.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*!
- * Track flags
- * \ingroup tracks
- */
-typedef enum {
- LIB3DS_REPEAT =0x0001,
- LIB3DS_SMOOTH =0x0002,
- LIB3DS_LOCK_X =0x0008,
- LIB3DS_LOCK_Y =0x0010,
- LIB3DS_LOCK_Z =0x0020,
- LIB3DS_UNLINK_X =0x0100,
- LIB3DS_UNLINK_Y =0x0200,
- LIB3DS_UNLINK_Z =0x0400
-} Lib3dsTrackFlags;
-
-/*!
- * Boolean track key
- * \ingroup tracks
- */
-struct _Lib3dsBoolKey {
- Lib3dsTcb tcb;
- Lib3dsBoolKey *next;
-};
-
-/*!
- * Boolean track
- * \ingroup tracks
- */
-struct _Lib3dsBoolTrack {
- Lib3dsDword flags;
- Lib3dsBoolKey *keyL;
-};
-
-/*!
- * Floating-point track key
- * \ingroup tracks
- */
-struct _Lib3dsLin1Key {
- Lib3dsTcb tcb;
- Lib3dsLin1Key *next;
- Lib3dsFloat value;
- Lib3dsFloat dd;
- Lib3dsFloat ds;
-};
-
-/*!
- * Floating-point track
- * \ingroup tracks
- */
-struct _Lib3dsLin1Track {
- Lib3dsDword flags;
- Lib3dsLin1Key *keyL;
-};
-
-/*!
- * Vector track key
- * \ingroup tracks
- */
-struct _Lib3dsLin3Key {
- Lib3dsTcb tcb;
- Lib3dsLin3Key *next;
- Lib3dsVector value;
- Lib3dsVector dd;
- Lib3dsVector ds;
-};
-
-/*!
- * Vector track
- * \ingroup tracks
- */
-struct _Lib3dsLin3Track {
- Lib3dsDword flags;
- Lib3dsLin3Key *keyL;
-};
-
-/*!
- * Rotation track key
- * \ingroup tracks
- */
-struct _Lib3dsQuatKey {
- Lib3dsTcb tcb;
- Lib3dsQuatKey *next;
- Lib3dsVector axis;
- Lib3dsFloat angle;
- Lib3dsQuat q;
- Lib3dsQuat dd;
- Lib3dsQuat ds;
-};
-
-/*!
- * Rotation track
- * \ingroup tracks
- */
-struct _Lib3dsQuatTrack {
- Lib3dsDword flags;
- Lib3dsQuatKey *keyL;
-};
-
-/*!
- * Morph track key
- * \ingroup tracks
- */
-struct _Lib3dsMorphKey {
- Lib3dsTcb tcb;
- Lib3dsMorphKey *next;
- char name[64];
-};
-
-/*!
- * Morph track
- * \ingroup tracks
- */
-struct _Lib3dsMorphTrack {
- Lib3dsDword flags;
- Lib3dsMorphKey *keyL;
-};
-
-extern LIB3DSAPI Lib3dsBoolKey* lib3ds_bool_key_new();
-extern LIB3DSAPI void lib3ds_bool_key_free(Lib3dsBoolKey* key);
-extern LIB3DSAPI void lib3ds_bool_track_free_keys(Lib3dsBoolTrack *track);
-extern LIB3DSAPI void lib3ds_bool_track_insert(Lib3dsBoolTrack *track, Lib3dsBoolKey* key);
-extern LIB3DSAPI void lib3ds_bool_track_remove(Lib3dsBoolTrack *track, Lib3dsIntd frame);
-extern LIB3DSAPI void lib3ds_bool_track_eval(Lib3dsBoolTrack *track, Lib3dsBool *p, Lib3dsFloat t);
-extern LIB3DSAPI Lib3dsBool lib3ds_bool_track_read(Lib3dsBoolTrack *track, Lib3dsIo *io);
-extern LIB3DSAPI Lib3dsBool lib3ds_bool_track_write(Lib3dsBoolTrack *track, Lib3dsIo *io);
-
-extern LIB3DSAPI Lib3dsLin1Key* lib3ds_lin1_key_new();
-extern LIB3DSAPI void lib3ds_lin1_key_free(Lib3dsLin1Key* key);
-extern LIB3DSAPI void lib3ds_lin1_track_free_keys(Lib3dsLin1Track *track);
-extern LIB3DSAPI void lib3ds_lin1_key_setup(Lib3dsLin1Key *p, Lib3dsLin1Key *cp, Lib3dsLin1Key *c,
- Lib3dsLin1Key *cn, Lib3dsLin1Key *n);
-extern LIB3DSAPI void lib3ds_lin1_track_setup(Lib3dsLin1Track *track);
-extern LIB3DSAPI void lib3ds_lin1_track_insert(Lib3dsLin1Track *track, Lib3dsLin1Key *key);
-extern LIB3DSAPI void lib3ds_lin1_track_remove(Lib3dsLin1Track *track, Lib3dsIntd frame);
-extern LIB3DSAPI void lib3ds_lin1_track_eval(Lib3dsLin1Track *track, Lib3dsFloat *p, Lib3dsFloat t);
-extern LIB3DSAPI Lib3dsBool lib3ds_lin1_track_read(Lib3dsLin1Track *track, Lib3dsIo *io);
-extern LIB3DSAPI Lib3dsBool lib3ds_lin1_track_write(Lib3dsLin1Track *track, Lib3dsIo *io);
-
-extern LIB3DSAPI Lib3dsLin3Key* lib3ds_lin3_key_new();
-extern LIB3DSAPI void lib3ds_lin3_key_free(Lib3dsLin3Key* key);
-extern LIB3DSAPI void lib3ds_lin3_track_free_keys(Lib3dsLin3Track *track);
-extern LIB3DSAPI void lib3ds_lin3_key_setup(Lib3dsLin3Key *p, Lib3dsLin3Key *cp, Lib3dsLin3Key *c,
- Lib3dsLin3Key *cn, Lib3dsLin3Key *n);
-extern LIB3DSAPI void lib3ds_lin3_track_setup(Lib3dsLin3Track *track);
-extern LIB3DSAPI void lib3ds_lin3_track_insert(Lib3dsLin3Track *track, Lib3dsLin3Key *key);
-extern LIB3DSAPI void lib3ds_lin3_track_remove(Lib3dsLin3Track *track, Lib3dsIntd frame);
-extern LIB3DSAPI void lib3ds_lin3_track_eval(Lib3dsLin3Track *track, Lib3dsVector p, Lib3dsFloat t);
-extern LIB3DSAPI Lib3dsBool lib3ds_lin3_track_read(Lib3dsLin3Track *track, Lib3dsIo *io);
-extern LIB3DSAPI Lib3dsBool lib3ds_lin3_track_write(Lib3dsLin3Track *track, Lib3dsIo *io);
-
-extern LIB3DSAPI Lib3dsQuatKey* lib3ds_quat_key_new();
-extern LIB3DSAPI void lib3ds_quat_key_free(Lib3dsQuatKey* key);
-extern LIB3DSAPI void lib3ds_quat_track_free_keys(Lib3dsQuatTrack *track);
-extern LIB3DSAPI void lib3ds_quat_key_setup(Lib3dsQuatKey *p, Lib3dsQuatKey *cp, Lib3dsQuatKey *c,
- Lib3dsQuatKey *cn, Lib3dsQuatKey *n);
-extern LIB3DSAPI void lib3ds_quat_track_setup(Lib3dsQuatTrack *track);
-extern LIB3DSAPI void lib3ds_quat_track_insert(Lib3dsQuatTrack *track, Lib3dsQuatKey *key);
-extern LIB3DSAPI void lib3ds_quat_track_remove(Lib3dsQuatTrack *track, Lib3dsIntd frame);
-extern LIB3DSAPI void lib3ds_quat_track_eval(Lib3dsQuatTrack *track, Lib3dsQuat p, Lib3dsFloat t);
-extern LIB3DSAPI Lib3dsBool lib3ds_quat_track_read(Lib3dsQuatTrack *track, Lib3dsIo *io);
-extern LIB3DSAPI Lib3dsBool lib3ds_quat_track_write(Lib3dsQuatTrack *track, Lib3dsIo *io);
-
-extern LIB3DSAPI Lib3dsMorphKey* lib3ds_morph_key_new();
-extern LIB3DSAPI void lib3ds_morph_key_free(Lib3dsMorphKey* key);
-extern LIB3DSAPI void lib3ds_morph_track_free_keys(Lib3dsMorphTrack *track);
-extern LIB3DSAPI void lib3ds_morph_track_insert(Lib3dsMorphTrack *track, Lib3dsMorphKey *key);
-extern LIB3DSAPI void lib3ds_morph_track_remove(Lib3dsMorphTrack *track, Lib3dsIntd frame);
-extern LIB3DSAPI void lib3ds_morph_track_eval(Lib3dsMorphTrack *track, char *p, Lib3dsFloat t);
-extern LIB3DSAPI Lib3dsBool lib3ds_morph_track_read(Lib3dsMorphTrack *track, Lib3dsIo *io);
-extern LIB3DSAPI Lib3dsBool lib3ds_morph_track_write(Lib3dsMorphTrack *track, Lib3dsIo *io);
-
-#ifdef __cplusplus
-}
-#endif
-#endif
-
+++ /dev/null
-/* -*- c -*- */
-#ifndef INCLUDED_LIB3DS_TYPES_H
-#define INCLUDED_LIB3DS_TYPES_H
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: types.h,v 1.18 2005/01/11 16:12:52 madmac Exp $
- */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#if defined (UBUILD_SHARED) && defined(_WIN32) && (!defined(__GNUC__))
-#ifdef LIB3DS_EXPORT
-#define LIB3DSAPI __declspec(dllexport)
-#else
-#define LIB3DSAPI __declspec(dllimport)
-#endif
-#else
-#define LIB3DSAPI
-#endif
-
-#define LIB3DS_TRUE 1
-#define LIB3DS_FALSE 0
-
-typedef int Lib3dsBool;
-typedef unsigned char Lib3dsByte;
-typedef unsigned short int Lib3dsWord;
-typedef unsigned long Lib3dsDword;
-typedef signed char Lib3dsIntb;
-typedef signed short int Lib3dsIntw;
-typedef signed long Lib3dsIntd;
-typedef float Lib3dsFloat;
-typedef double Lib3dsDouble;
-
-typedef float Lib3dsVector[3];
-typedef float Lib3dsTexel[2];
-typedef float Lib3dsQuat[4];
-typedef float Lib3dsMatrix[4][4];
-typedef float Lib3dsRgb[3];
-typedef float Lib3dsRgba[4];
-
-#define LIB3DS_EPSILON (1e-8)
-#define LIB3DS_PI 3.14159265358979323846
-#define LIB3DS_TWOPI (2.0*LIB3DS_PI)
-#define LIB3DS_HALFPI (LIB3DS_PI/2.0)
-#define LIB3DS_RAD_TO_DEG(x) ((180.0/LIB3DS_PI)*(x))
-#define LIB3DS_DEG_TO_RAD(x) ((LIB3DS_PI/180.0)*(x))
-
-#ifndef INCLUDED_STDIO_H
-#define INCLUDED_STDIO_H
-#include <stdio.h>
-#endif
-
-#ifdef _DEBUG
- #ifndef ASSERT
- #include <assert.h>
- #define ASSERT(__expr) assert(__expr)
- #endif
- #define LIB3DS_ERROR_LOG \
- {printf("\t***LIB3DS_ERROR_LOG*** %s : %d\n", __FILE__, __LINE__);}
-#else
- #ifndef ASSERT
- #define ASSERT(__expr)
- #endif
- #define LIB3DS_ERROR_LOG
-#endif
-
-typedef struct _Lib3dsIo Lib3dsIo;
-typedef struct _Lib3dsFile Lib3dsFile;
-typedef struct _Lib3dsBackground Lib3dsBackground;
-typedef struct _Lib3dsAtmosphere Lib3dsAtmosphere;
-typedef struct _Lib3dsShadow Lib3dsShadow;
-typedef struct _Lib3dsViewport Lib3dsViewport;
-typedef struct _Lib3dsMaterial Lib3dsMaterial;
-typedef struct _Lib3dsFace Lib3dsFace;
-typedef struct _Lib3dsBoxMap Lib3dsBoxMap;
-typedef struct _Lib3dsMapData Lib3dsMapData;
-typedef struct _Lib3dsMesh Lib3dsMesh;
-typedef struct _Lib3dsCamera Lib3dsCamera;
-typedef struct _Lib3dsLight Lib3dsLight;
-typedef struct _Lib3dsBoolKey Lib3dsBoolKey;
-typedef struct _Lib3dsBoolTrack Lib3dsBoolTrack;
-typedef struct _Lib3dsLin1Key Lib3dsLin1Key;
-typedef struct _Lib3dsLin1Track Lib3dsLin1Track;
-typedef struct _Lib3dsLin3Key Lib3dsLin3Key;
-typedef struct _Lib3dsLin3Track Lib3dsLin3Track;
-typedef struct _Lib3dsQuatKey Lib3dsQuatKey;
-typedef struct _Lib3dsQuatTrack Lib3dsQuatTrack;
-typedef struct _Lib3dsMorphKey Lib3dsMorphKey;
-typedef struct _Lib3dsMorphTrack Lib3dsMorphTrack;
-
-typedef enum _Lib3dsNodeTypes {
- LIB3DS_UNKNOWN_NODE =0,
- LIB3DS_AMBIENT_NODE =1,
- LIB3DS_OBJECT_NODE =2,
- LIB3DS_CAMERA_NODE =3,
- LIB3DS_TARGET_NODE =4,
- LIB3DS_LIGHT_NODE =5,
- LIB3DS_SPOT_NODE =6
-} Lib3dsNodeTypes;
-
-typedef struct _Lib3dsNode Lib3dsNode;
-
-typedef union _Lib3dsUserData {
- void *p;
- Lib3dsIntd i;
- Lib3dsDword d;
- Lib3dsFloat f;
- Lib3dsMaterial *material;
- Lib3dsMesh *mesh;
- Lib3dsCamera *camera;
- Lib3dsLight *light;
- Lib3dsNode *node;
-} Lib3dsUserData;
-
-#ifndef LIB3DS_EXPORT
- /* The purpose of this variable is to force a recompile of any code
- * that links to the lib3ds library whenever there is an incompatible
- * change in the header files. It should be sufficient to include
- * any lib3ds header file in any source file to satisfy this dependency.
- *
- * This variable will be updated any time there is an incompatible change
- * in the lib3ds data structures.
- */
-// int lib3ds_version1_3;
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif
+++ /dev/null
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: vector.c,v 1.9 2004/11/16 07:41:44 efalk Exp $
- */
-#define LIB3DS_EXPORT
-#include <lib3ds/vector.h>
-#include <math.h>
-
-
-/*!
- * \defgroup vector Vector Mathematics
- *
- * \author J.E. Hoffmann <je-h@gmx.net>
- */
-/*!
- * \typedef Lib3dsVector
- * \ingroup vector
- */
-
-
-/*!
- * Clear a vector to zero.
- *
- * \param c Vector to clear.
- *
- * \ingroup vector
- */
-void
-lib3ds_vector_zero(Lib3dsVector c)
-{
- int i;
- for (i=0; i<3; ++i) {
- c[i]=0.0f;
- }
-}
-
-
-/*!
- * Copy a vector.
- *
- * \param dest Destination vector.
- * \param src Source vector.
- *
- * \ingroup vector
- */
-void
-lib3ds_vector_copy(Lib3dsVector dest, Lib3dsVector src)
-{
- int i;
- for (i=0; i<3; ++i) {
- dest[i]=src[i];
- }
-}
-
-
-/*!
- * Negate a vector.
- *
- * \param c Vector to negate.
- *
- * \ingroup vector
- */
-void
-lib3ds_vector_neg(Lib3dsVector c)
-{
- int i;
- for (i=0; i<3; ++i) {
- c[i]=-c[i];
- }
-}
-
-
-/*!
- * Add two vectors.
- *
- * \param c Result.
- * \param a First addend.
- * \param b Second addend.
- *
- * \ingroup vector
- */
-void
-lib3ds_vector_add(Lib3dsVector c, Lib3dsVector a, Lib3dsVector b)
-{
- int i;
- for (i=0; i<3; ++i) {
- c[i]=a[i]+b[i];
- }
-}
-
-
-/*!
- * Subtract two vectors.
- *
- * \param c Result.
- * \param a Addend.
- * \param b Minuend.
- *
- * \ingroup vector
- */
-void
-lib3ds_vector_sub(Lib3dsVector c, Lib3dsVector a, Lib3dsVector b)
-{
- int i;
- for (i=0; i<3; ++i) {
- c[i]=a[i]-b[i];
- }
-}
-
-
-/*!
- * Multiply a vector by a scalar.
- *
- * \param c Vector to be multiplied.
- * \param k Scalar.
- *
- * \ingroup vector
- */
-void
-lib3ds_vector_scalar(Lib3dsVector c, Lib3dsFloat k)
-{
- int i;
- for (i=0; i<3; ++i) {
- c[i]*=k;
- }
-}
-
-
-/*!
- * Compute cross product.
- *
- * \param c Result.
- * \param a First vector.
- * \param b Second vector.
- *
- * \ingroup vector
- */
-void
-lib3ds_vector_cross(Lib3dsVector c, Lib3dsVector a, Lib3dsVector b)
-{
- c[0]=a[1]*b[2] - a[2]*b[1];
- c[1]=a[2]*b[0] - a[0]*b[2];
- c[2]=a[0]*b[1] - a[1]*b[0];
-}
-
-
-/*!
- * Compute dot product.
- *
- * \param a First vector.
- * \param b Second vector.
- *
- * \return Dot product.
- *
- * \ingroup vector
- */
-Lib3dsFloat
-lib3ds_vector_dot(Lib3dsVector a, Lib3dsVector b)
-{
- return(a[0]*b[0] + a[1]*b[1] + a[2]*b[2]);
-}
-
-
-/*!
- * Compute square of vector.
- *
- * Computes x*x + y*y + z*z.
- *
- * \param c Vector to square.
- *
- * \return Square of vector.
- *
- * \ingroup vector
- */
-Lib3dsFloat
-lib3ds_vector_squared(Lib3dsVector c)
-{
- return(c[0]*c[0] + c[1]*c[1] + c[2]*c[2]);
-}
-
-
-/*!
- * Compute length of vector.
- *
- * Computes |c| = sqrt(x*x + y*y + z*z)
- *
- * \param c Vector to compute.
- *
- * \return Length of vector.
- *
- * \ingroup vector
- */
-Lib3dsFloat
-lib3ds_vector_length(Lib3dsVector c)
-{
- return((Lib3dsFloat)sqrt(c[0]*c[0] + c[1]*c[1] + c[2]*c[2]));
-}
-
-
-/*!
- * Normalize a vector.
- *
- * Scales a vector so that its length is 1.0.
- *
- * \param c Vector to normalize.
- *
- * \ingroup vector
- */
-void
-lib3ds_vector_normalize(Lib3dsVector c)
-{
- Lib3dsFloat l,m;
-
- l=(Lib3dsFloat)sqrt(c[0]*c[0] + c[1]*c[1] + c[2]*c[2]);
- if (fabs(l)<LIB3DS_EPSILON) {
- if ((c[0]>=c[1]) && (c[0]>=c[2])) {
- c[0]=1.0f;
- c[1]=c[2]=0.0f;
- }
- else
- if (c[1]>=c[2]) {
- c[1]=1.0f;
- c[0]=c[2]=0.0f;
- }
- else {
- c[2]=1.0f;
- c[0]=c[1]=0.0f;
- }
- }
- else {
- m=1.0f/l;
- c[0]*=m;
- c[1]*=m;
- c[2]*=m;
- }
-}
-
-
-/*!
- * Compute a vector normal to two line segments.
- *
- * Computes the normal vector to the lines b-a and b-c.
- *
- * \param n Returned normal vector.
- * \param a Endpoint of first line.
- * \param b Base point of both lines.
- * \param c Endpoint of second line.
- *
- * \ingroup vector
- */
-void
-lib3ds_vector_normal(Lib3dsVector n, Lib3dsVector a, Lib3dsVector b, Lib3dsVector c)
-{
- Lib3dsVector p,q;
-
- lib3ds_vector_sub(p,c,b);
- lib3ds_vector_sub(q,a,b);
- lib3ds_vector_cross(n,p,q);
- lib3ds_vector_normalize(n);
-}
-
-
-/*!
- * Multiply a point by a transformation matrix.
- *
- * Applies the given transformation matrix to the given point. With some
- * transformation matrices, a vector may also be transformed.
- *
- * \param c Result.
- * \param m Transformation matrix.
- * \param a Input point.
- *
- * \ingroup vector
- */
-void
-lib3ds_vector_transform(Lib3dsVector c, Lib3dsMatrix m, Lib3dsVector a)
-{
- c[0]= m[0][0]*a[0] + m[1][0]*a[1] + m[2][0]*a[2] + m[3][0];
- c[1]= m[0][1]*a[0] + m[1][1]*a[1] + m[2][1]*a[2] + m[3][1];
- c[2]= m[0][2]*a[0] + m[1][2]*a[1] + m[2][2]*a[2] + m[3][2];
-}
-
-
-/*!
- * Compute a point on a cubic spline.
- *
- * Computes a point on a parametric Bezier spline.
- *
- * \param c Result.
- * \param a First endpoint of the spline.
- * \param p First tangent vector of the spline.
- * \param q Second tangent vector of the spline.
- * \param b Second endpoint of the spline.
- * \param t Spline parameter [0. 1.]
- *
- * \ingroup vector
- */
-void
-lib3ds_vector_cubic(Lib3dsVector c, Lib3dsVector a, Lib3dsVector p, Lib3dsVector q,
- Lib3dsVector b, Lib3dsFloat t)
-{
- Lib3dsDouble x,y,z,w;
-
- x=2*t*t*t - 3*t*t + 1;
- y=-2*t*t*t + 3*t*t;
- z=t*t*t - 2*t*t + t;
- w=t*t*t - t*t;
- c[0]=(Lib3dsFloat)(x*a[0] + y*b[0] + z*p[0] + w*q[0]);
- c[1]=(Lib3dsFloat)(x*a[1] + y*b[1] + z*p[1] + w*q[1]);
- c[2]=(Lib3dsFloat)(x*a[2] + y*b[2] + z*p[2] + w*q[2]);
-}
-
-
-/*!
- * c[i] = min(c[i], a[i]);
- *
- * Computes minimum values of x,y,z independently.
- *
- * \ingroup vector
- */
-void
-lib3ds_vector_min(Lib3dsVector c, Lib3dsVector a)
-{
- int i;
- for (i=0; i<3; ++i) {
- if (a[i]<c[i]) {
- c[i] = a[i];
- }
- }
-}
-
-
-/*!
- * c[i] = max(c[i], a[i]);
- *
- * Computes maximum values of x,y,z independently.
- *
- * \ingroup vector
- */
-void
-lib3ds_vector_max(Lib3dsVector c, Lib3dsVector a)
-{
- int i;
- for (i=0; i<3; ++i) {
- if (a[i]>c[i]) {
- c[i] = a[i];
- }
- }
-}
-
-
-/*!
- * \ingroup vector
- */
-void
-lib3ds_vector_dump(Lib3dsVector c)
-{
- fprintf(stderr, "%f %f %f\n", c[0], c[1], c[2]);
-}
-
+++ /dev/null
-/* -*- c -*- */
-#ifndef INCLUDED_LIB3DS_VECTOR_H
-#define INCLUDED_LIB3DS_VECTOR_H
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: vector.h,v 1.6 2004/12/31 16:17:15 reed Exp $
- */
-
-#ifndef INCLUDED_LIB3DS_TYPES_H
-#include <lib3ds/types.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-extern LIB3DSAPI void lib3ds_vector_zero(Lib3dsVector c);
-extern LIB3DSAPI void lib3ds_vector_copy(Lib3dsVector dest, Lib3dsVector src);
-extern LIB3DSAPI void lib3ds_vector_neg(Lib3dsVector c);
-extern LIB3DSAPI void lib3ds_vector_add(Lib3dsVector c, Lib3dsVector a, Lib3dsVector b);
-extern LIB3DSAPI void lib3ds_vector_sub(Lib3dsVector c, Lib3dsVector a, Lib3dsVector b);
-extern LIB3DSAPI void lib3ds_vector_scalar(Lib3dsVector c, Lib3dsFloat k);
-extern LIB3DSAPI void lib3ds_vector_cross(Lib3dsVector c, Lib3dsVector a, Lib3dsVector b);
-extern LIB3DSAPI Lib3dsFloat lib3ds_vector_dot(Lib3dsVector a, Lib3dsVector b);
-extern LIB3DSAPI Lib3dsFloat lib3ds_vector_squared(Lib3dsVector c);
-extern LIB3DSAPI Lib3dsFloat lib3ds_vector_length(Lib3dsVector c);
-extern LIB3DSAPI void lib3ds_vector_normalize(Lib3dsVector c);
-extern LIB3DSAPI void lib3ds_vector_normal(Lib3dsVector n, Lib3dsVector a,
- Lib3dsVector b, Lib3dsVector c);
-extern LIB3DSAPI void lib3ds_vector_transform(Lib3dsVector c, Lib3dsMatrix m, Lib3dsVector a);
-extern LIB3DSAPI void lib3ds_vector_cubic(Lib3dsVector c, Lib3dsVector a, Lib3dsVector p,
- Lib3dsVector q, Lib3dsVector b, Lib3dsFloat t);
-extern LIB3DSAPI void lib3ds_vector_min(Lib3dsVector c, Lib3dsVector a);
-extern LIB3DSAPI void lib3ds_vector_max(Lib3dsVector c, Lib3dsVector a);
-extern LIB3DSAPI void lib3ds_vector_dump(Lib3dsVector c);
-
-#ifdef __cplusplus
-}
-#endif
-#endif
-
+++ /dev/null
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: viewport.c,v 1.7 2004/11/16 07:40:56 efalk Exp $
- */
-#define LIB3DS_EXPORT
-#include <lib3ds/viewport.h>
-#include <lib3ds/chunk.h>
-#include <lib3ds/io.h>
-#include <stdlib.h>
-#include <string.h>
-
-
-/*!
- * \defgroup viewport Viewport and default view settings
- *
- * \author J.E. Hoffmann <je-h@gmx.net>
- */
-
-
-/*!
- * \ingroup viewport
- */
-Lib3dsBool
-lib3ds_viewport_read(Lib3dsViewport *viewport, Lib3dsIo *io)
-{
- Lib3dsChunk c;
- Lib3dsWord chunk;
-
- if (!lib3ds_chunk_read_start(&c, 0, io)) {
- return(LIB3DS_FALSE);
- }
-
- switch (c.chunk) {
- case LIB3DS_VIEWPORT_LAYOUT:
- {
- int cur=0;
- viewport->layout.style=lib3ds_io_read_word(io);
- viewport->layout.active=lib3ds_io_read_intw(io);
- lib3ds_io_read_intw(io);
- viewport->layout.swap=lib3ds_io_read_intw(io);
- lib3ds_io_read_intw(io);
- viewport->layout.swap_prior=lib3ds_io_read_intw(io);
- viewport->layout.swap_view=lib3ds_io_read_intw(io);
- lib3ds_chunk_read_tell(&c, io);
- while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
- switch (chunk) {
- case LIB3DS_VIEWPORT_SIZE:
- {
- viewport->layout.position[0]=lib3ds_io_read_word(io);
- viewport->layout.position[1]=lib3ds_io_read_word(io);
- viewport->layout.size[0]=lib3ds_io_read_word(io);
- viewport->layout.size[1]=lib3ds_io_read_word(io);
- }
- break;
- case LIB3DS_VIEWPORT_DATA_3:
- {
- lib3ds_viewport_set_views(viewport,cur+1);
- lib3ds_io_read_intw(io);
- viewport->layout.viewL[cur].axis_lock=lib3ds_io_read_word(io);
- viewport->layout.viewL[cur].position[0]=lib3ds_io_read_intw(io);
- viewport->layout.viewL[cur].position[1]=lib3ds_io_read_intw(io);
- viewport->layout.viewL[cur].size[0]=lib3ds_io_read_intw(io);
- viewport->layout.viewL[cur].size[1]=lib3ds_io_read_intw(io);
- viewport->layout.viewL[cur].type=lib3ds_io_read_word(io);
- viewport->layout.viewL[cur].zoom=lib3ds_io_read_float(io);
- lib3ds_io_read_vector(io, viewport->layout.viewL[cur].center);
- viewport->layout.viewL[cur].horiz_angle=lib3ds_io_read_float(io);
- viewport->layout.viewL[cur].vert_angle=lib3ds_io_read_float(io);
- lib3ds_io_read(io, (unsigned char*)viewport->layout.viewL[cur].camera, 11);
- ++cur;
- }
- break;
- case LIB3DS_VIEWPORT_DATA:
- /* 3DS R2 & R3 chunk
- unsupported */
- break;
- default:
- lib3ds_chunk_unknown(chunk);
- }
- }
- }
- break;
- case LIB3DS_DEFAULT_VIEW:
- {
- memset(&viewport->default_view,0,sizeof(Lib3dsDefaultView));
- while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
- switch (chunk) {
- case LIB3DS_VIEW_TOP:
- {
- viewport->default_view.type=LIB3DS_VIEW_TYPE_TOP;
- lib3ds_io_read_vector(io, viewport->default_view.position);
- viewport->default_view.width=lib3ds_io_read_float(io);
- }
- break;
- case LIB3DS_VIEW_BOTTOM:
- {
- viewport->default_view.type=LIB3DS_VIEW_TYPE_BOTTOM;
- lib3ds_io_read_vector(io, viewport->default_view.position);
- viewport->default_view.width=lib3ds_io_read_float(io);
- }
- break;
- case LIB3DS_VIEW_LEFT:
- {
- viewport->default_view.type=LIB3DS_VIEW_TYPE_LEFT;
- lib3ds_io_read_vector(io, viewport->default_view.position);
- viewport->default_view.width=lib3ds_io_read_float(io);
- }
- break;
- case LIB3DS_VIEW_RIGHT:
- {
- viewport->default_view.type=LIB3DS_VIEW_TYPE_RIGHT;
- lib3ds_io_read_vector(io, viewport->default_view.position);
- viewport->default_view.width=lib3ds_io_read_float(io);
- }
- break;
- case LIB3DS_VIEW_FRONT:
- {
- viewport->default_view.type=LIB3DS_VIEW_TYPE_FRONT;
- lib3ds_io_read_vector(io, viewport->default_view.position);
- viewport->default_view.width=lib3ds_io_read_float(io);
- }
- break;
- case LIB3DS_VIEW_BACK:
- {
- viewport->default_view.type=LIB3DS_VIEW_TYPE_BACK;
- lib3ds_io_read_vector(io, viewport->default_view.position);
- viewport->default_view.width=lib3ds_io_read_float(io);
- }
- break;
- case LIB3DS_VIEW_USER:
- {
- viewport->default_view.type=LIB3DS_VIEW_TYPE_USER;
- lib3ds_io_read_vector(io, viewport->default_view.position);
- viewport->default_view.width=lib3ds_io_read_float(io);
- viewport->default_view.horiz_angle=lib3ds_io_read_float(io);
- viewport->default_view.vert_angle=lib3ds_io_read_float(io);
- viewport->default_view.roll_angle=lib3ds_io_read_float(io);
- }
- break;
- case LIB3DS_VIEW_CAMERA:
- {
- viewport->default_view.type=LIB3DS_VIEW_TYPE_CAMERA;
- lib3ds_io_read(io, (unsigned char*)viewport->default_view.camera, 11);
- }
- break;
- default:
- lib3ds_chunk_unknown(chunk);
- }
- }
- }
- break;
- }
-
- lib3ds_chunk_read_end(&c, io);
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * \ingroup viewport
- */
-void
-lib3ds_viewport_set_views(Lib3dsViewport *viewport, Lib3dsDword views)
-{
- ASSERT(viewport);
- if (viewport->layout.views) {
- if (views) {
- viewport->layout.views=views;
- viewport->layout.viewL=(Lib3dsView*)realloc(viewport->layout.viewL, sizeof(Lib3dsView)*views);
- }
- else {
- free(viewport->layout.viewL);
- viewport->layout.views=0;
- viewport->layout.viewL=0;
- }
- }
- else {
- if (views) {
- viewport->layout.views=views;
- viewport->layout.viewL=(Lib3dsView*)calloc(sizeof(Lib3dsView),views);
- }
- }
-}
-
-
-/*!
- * \ingroup viewport
- */
-Lib3dsBool
-lib3ds_viewport_write(Lib3dsViewport *viewport, Lib3dsIo *io)
-{
- if (viewport->layout.views) {
- Lib3dsChunk c;
- unsigned i;
-
- c.chunk=LIB3DS_VIEWPORT_LAYOUT;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
-
- lib3ds_io_write_word(io, viewport->layout.style);
- lib3ds_io_write_intw(io, viewport->layout.active);
- lib3ds_io_write_intw(io, 0);
- lib3ds_io_write_intw(io, viewport->layout.swap);
- lib3ds_io_write_intw(io, 0);
- lib3ds_io_write_intw(io, viewport->layout.swap_prior);
- lib3ds_io_write_intw(io, viewport->layout.swap_view);
-
- {
- Lib3dsChunk c;
- c.chunk=LIB3DS_VIEWPORT_SIZE;
- c.size=14;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_intw(io, viewport->layout.position[0]);
- lib3ds_io_write_intw(io, viewport->layout.position[1]);
- lib3ds_io_write_intw(io, viewport->layout.size[0]);
- lib3ds_io_write_intw(io, viewport->layout.size[1]);
- }
-
- for (i=0; i<viewport->layout.views; ++i) {
- Lib3dsChunk c;
- c.chunk=LIB3DS_VIEWPORT_DATA_3;
- c.size=55;
- lib3ds_chunk_write(&c,io);
-
- lib3ds_io_write_intw(io, 0);
- lib3ds_io_write_word(io, viewport->layout.viewL[i].axis_lock);
- lib3ds_io_write_intw(io, viewport->layout.viewL[i].position[0]);
- lib3ds_io_write_intw(io, viewport->layout.viewL[i].position[1]);
- lib3ds_io_write_intw(io, viewport->layout.viewL[i].size[0]);
- lib3ds_io_write_intw(io, viewport->layout.viewL[i].size[1]);
- lib3ds_io_write_word(io, viewport->layout.viewL[i].type);
- lib3ds_io_write_float(io, viewport->layout.viewL[i].zoom);
- lib3ds_io_write_vector(io, viewport->layout.viewL[i].center);
- lib3ds_io_write_float(io, viewport->layout.viewL[i].horiz_angle);
- lib3ds_io_write_float(io, viewport->layout.viewL[i].vert_angle);
- lib3ds_io_write(io, (unsigned char*)viewport->layout.viewL[i].camera,11);
- }
-
- if (!lib3ds_chunk_write_end(&c,io)) {
- return(LIB3DS_FALSE);
- }
- }
-
- if (viewport->default_view.type) {
- Lib3dsChunk c;
-
- c.chunk=LIB3DS_DEFAULT_VIEW;
- if (!lib3ds_chunk_write_start(&c,io)) {
- return(LIB3DS_FALSE);
- }
-
- switch (viewport->default_view.type) {
- case LIB3DS_VIEW_TYPE_TOP:
- {
- Lib3dsChunk c;
- c.chunk=LIB3DS_VIEW_TOP;
- c.size=22;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_vector(io, viewport->default_view.position);
- lib3ds_io_write_float(io, viewport->default_view.width);
- }
- break;
- case LIB3DS_VIEW_TYPE_BOTTOM:
- {
- Lib3dsChunk c;
- c.chunk=LIB3DS_VIEW_BOTTOM;
- c.size=22;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_vector(io, viewport->default_view.position);
- lib3ds_io_write_float(io, viewport->default_view.width);
- }
- break;
- case LIB3DS_VIEW_TYPE_LEFT:
- {
- Lib3dsChunk c;
- c.chunk=LIB3DS_VIEW_LEFT;
- c.size=22;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_vector(io, viewport->default_view.position);
- lib3ds_io_write_float(io, viewport->default_view.width);
- }
- break;
- case LIB3DS_VIEW_TYPE_RIGHT:
- {
- Lib3dsChunk c;
- c.chunk=LIB3DS_VIEW_RIGHT;
- c.size=22;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_vector(io, viewport->default_view.position);
- lib3ds_io_write_float(io, viewport->default_view.width);
- }
- break;
- case LIB3DS_VIEW_TYPE_FRONT:
- {
- Lib3dsChunk c;
- c.chunk=LIB3DS_VIEW_FRONT;
- c.size=22;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_vector(io, viewport->default_view.position);
- lib3ds_io_write_float(io, viewport->default_view.width);
- }
- break;
- case LIB3DS_VIEW_TYPE_BACK:
- {
- Lib3dsChunk c;
- c.chunk=LIB3DS_VIEW_BACK;
- c.size=22;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_vector(io, viewport->default_view.position);
- lib3ds_io_write_float(io, viewport->default_view.width);
- }
- break;
- case LIB3DS_VIEW_TYPE_USER:
- {
- Lib3dsChunk c;
- c.chunk=LIB3DS_VIEW_USER;
- c.size=34;
- lib3ds_chunk_write(&c,io);
- lib3ds_io_write_vector(io, viewport->default_view.position);
- lib3ds_io_write_float(io, viewport->default_view.width);
- lib3ds_io_write_float(io, viewport->default_view.horiz_angle);
- lib3ds_io_write_float(io, viewport->default_view.vert_angle);
- lib3ds_io_write_float(io, viewport->default_view.roll_angle);
- }
- break;
- case LIB3DS_VIEW_TYPE_CAMERA:
- {
- Lib3dsChunk c;
- c.chunk=LIB3DS_VIEW_CAMERA;
- c.size=17;
- lib3ds_chunk_write(&c, io);
- lib3ds_io_write(io, (unsigned char*)viewport->default_view.camera, 11);
- }
- break;
- }
-
- if (!lib3ds_chunk_write_end(&c, io)) {
- return(LIB3DS_FALSE);
- }
- }
- return(LIB3DS_TRUE);
-}
-
-
-/*!
- * Dump viewport.
- *
- * \param viewport The viewport to be dumped.
- *
- * \ingroup node
- */
-void
-lib3ds_viewport_dump(Lib3dsViewport *vp)
-{
- Lib3dsView *view;
- int i;
- ASSERT(vp);
-
- printf(" viewport:\n");
- printf(" layout:\n");
- printf(" style: %d\n", vp->layout.style);
- printf(" active: %d\n", vp->layout.active);
- printf(" swap: %d\n", vp->layout.swap);
- printf(" swap_prior: %d\n", vp->layout.swap_prior);
- printf(" position: %d,%d\n",
- vp->layout.position[0], vp->layout.position[1]);
- printf(" size: %d,%d\n", vp->layout.size[0], vp->layout.size[1]);
- printf(" views: %ld\n", vp->layout.views);
- if (vp->layout.views > 0 && vp->layout.viewL != NULL) {
- for(i=0, view=vp->layout.viewL; i < vp->layout.views; ++i, ++view) {
- printf(" view %d:\n", i);
- printf(" type: %d\n", view->type);
- printf(" axis_lock: %d\n", view->axis_lock);
- printf(" position: (%d,%d)\n",
- view->position[0], view->position[1]);
- printf(" size: (%d,%d)\n", view->size[0], view->size[1]);
- printf(" zoom: %g\n", view->zoom);
- printf(" center: (%g,%g,%g)\n",
- view->center[0], view->center[1], view->center[2]);
- printf(" horiz_angle: %g\n", view->horiz_angle);
- printf(" vert_angle: %g\n", view->vert_angle);
- printf(" camera: %s\n", view->camera);
- }
- }
-
- printf(" default_view:\n");
- printf(" type: %d\n", vp->default_view.type);
- printf(" position: (%g,%g,%g)\n",
- vp->default_view.position[0],
- vp->default_view.position[1],
- vp->default_view.position[2]);
- printf(" width: %g\n", vp->default_view.width);
- printf(" horiz_angle: %g\n", vp->default_view.horiz_angle);
- printf(" vert_angle: %g\n", vp->default_view.vert_angle);
- printf(" roll_angle: %g\n", vp->default_view.roll_angle);
- printf(" camera: %s\n", vp->default_view.camera);
-}
-
-
-/*!
-
-\typedef Lib3dsViewport
- \ingroup viewport
- \sa _Lib3dsViewport
-
-*/
+++ /dev/null
-/* -*- c -*- */
-#ifndef INCLUDED_LIB3DS_VIEWPORT_H
-#define INCLUDED_LIB3DS_VIEWPORT_H
-/*
- * The 3D Studio File Format Library
- * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: viewport.h,v 1.6 2004/12/31 16:17:15 reed Exp $
- */
-
-#ifndef INCLUDED_LIB3DS_TYPES_H
-#include <lib3ds/types.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*!
- * Layout view types
- * \ingroup viewport
- */
-typedef enum _Lib3dsViewType {
- LIB3DS_VIEW_TYPE_NOT_USED =0,
- LIB3DS_VIEW_TYPE_TOP =1,
- LIB3DS_VIEW_TYPE_BOTTOM =2,
- LIB3DS_VIEW_TYPE_LEFT =3,
- LIB3DS_VIEW_TYPE_RIGHT =4,
- LIB3DS_VIEW_TYPE_FRONT =5,
- LIB3DS_VIEW_TYPE_BACK =6,
- LIB3DS_VIEW_TYPE_USER =7,
- LIB3DS_VIEW_TYPE_SPOTLIGHT =18,
- LIB3DS_VIEW_TYPE_CAMERA =65535
-} Lib3dsViewType;
-
-/*!
- * Layout view settings
- * \ingroup viewport
- */
-typedef struct _Lib3dsView {
- Lib3dsWord type;
- Lib3dsWord axis_lock;
- Lib3dsIntw position[2];
- Lib3dsIntw size[2];
- Lib3dsFloat zoom;
- Lib3dsVector center;
- Lib3dsFloat horiz_angle;
- Lib3dsFloat vert_angle;
- char camera[11];
-} Lib3dsView;
-
-/*!
- * Layout styles
- * \ingroup viewport
- */
-typedef enum _Lib3dsLayoutStyle {
- LIB3DS_LAYOUT_SINGLE =0,
- LIB3DS_LAYOUT_TWO_PANE_VERT_SPLIT =1,
- LIB3DS_LAYOUT_TWO_PANE_HORIZ_SPLIT =2,
- LIB3DS_LAYOUT_FOUR_PANE =3,
- LIB3DS_LAYOUT_THREE_PANE_LEFT_SPLIT =4,
- LIB3DS_LAYOUT_THREE_PANE_BOTTOM_SPLIT =5,
- LIB3DS_LAYOUT_THREE_PANE_RIGHT_SPLIT =6,
- LIB3DS_LAYOUT_THREE_PANE_TOP_SPLIT =7,
- LIB3DS_LAYOUT_THREE_PANE_VERT_SPLIT =8,
- LIB3DS_LAYOUT_THREE_PANE_HORIZ_SPLIT =9,
- LIB3DS_LAYOUT_FOUR_PANE_LEFT_SPLIT =10,
- LIB3DS_LAYOUT_FOUR_PANE_RIGHT_SPLIT =11
-} Lib3dsLayoutStyle;
-
-/*!
- * Viewport layout settings
- * \ingroup viewport
- */
-typedef struct _Lib3dsLayout {
- Lib3dsWord style;
- Lib3dsIntw active;
- Lib3dsIntw swap;
- Lib3dsIntw swap_prior;
- Lib3dsIntw swap_view;
- Lib3dsWord position[2];
- Lib3dsWord size[2];
- Lib3dsDword views;
- Lib3dsView *viewL;
-} Lib3dsLayout;
-
-/*!
- * Default view settings
- * \ingroup viewport
- */
-typedef struct _Lib3dsDefaultView {
- Lib3dsWord type;
- Lib3dsVector position;
- Lib3dsFloat width;
- Lib3dsFloat horiz_angle;
- Lib3dsFloat vert_angle;
- Lib3dsFloat roll_angle;
- char camera[64];
-} Lib3dsDefaultView;
-
-/*!
- * Viewport and default view settings
- * \ingroup viewport
- */
-struct _Lib3dsViewport {
- Lib3dsLayout layout;
- Lib3dsDefaultView default_view;
-};
-
-extern LIB3DSAPI Lib3dsBool lib3ds_viewport_read(Lib3dsViewport *viewport, Lib3dsIo *io);
-extern LIB3DSAPI void lib3ds_viewport_set_views(Lib3dsViewport *viewport, Lib3dsDword views);
-extern LIB3DSAPI Lib3dsBool lib3ds_viewport_write(Lib3dsViewport *viewport, Lib3dsIo *io);
-extern LIB3DSAPI void lib3ds_viewport_dump(Lib3dsViewport *viewport);
-
-#ifdef __cplusplus
-}
-#endif
-#endif
-
-
-
-
projects / summerhack / commitdiff